उचित विभाजक मैश-अप

20

एक उचित भाजक एक है भाजक एक नंबर के n है, जो नहीं है n ही। उदाहरण के लिए, 12 के उचित भाजक 1, 2, 3, 4 और 6 हैं।

आपको एक पूर्णांक x , x x 2, x inte 1000 दिया जाएगा । आपका कार्य पूर्णांक के सभी उच्चतम समुचित विभाजकों को 2 से x (समावेशी) (OEIS A280050 ) तक समेटना है ।

उदाहरण (साथ x = 6):

  • 2 और 6 (समावेशी) के बीच सभी पूर्णांक खोजें: 2,3,4,5,6।

  • उन सभी के समुचित विभाजक प्राप्त करें, और प्रत्येक संख्या से उच्चतम को चुनें:

    • 2 -> 1
    • 3 -> 1
    • 4 -> 1, 2
    • 5 -> 1
    • 6 -> 1, 2, 3 ।

  • उच्चतम उचित भाजक 1 + 1 + 2 + 1 + 3 = 8:।

  • अंतिम परिणाम 8 है।

परीक्षण के मामलों

इनपुट | उत्पादन
------- + ---------
       |
 2 | 1
 4 | 4
 6 | 8
 8 | 13
 15 | 41
 37 | 229
 100 | 1690
 1000 | 165,279

नियम

code-golf  math  number  number-theory  division 
— श्री Xcoder
स्रोत
— श्री एक्सकोडर
5
यदि आप किसी सैंडबॉक्स में जा रहे हैं, तो उसे दो घंटे से अधिक समय के लिए वहाँ छोड़ दें।
— पीटर टेलर
@PeterTaylor मैंने केवल प्रतिक्रिया प्राप्त करने के लिए पोस्ट को सैंडबॉक्स किया, क्योंकि यह एक बहुत ही सरल चुनौती है जिसे मैं आमतौर पर सैंडबॉक्स में बिल्कुल भी पोस्ट नहीं करूंगा। संपादित करने के लिए BTW धन्यवाद।
— श्री एक्सकोडर

जवाबों:

5

भूसी , 7 बाइट्स

ṁȯΠtptḣ

इसे ऑनलाइन आज़माएं!

व्याख्या

हस्क के पास सीधे (अभी तक) डिवाइडर की गणना के लिए कोई अंतर्निहित नहीं है, इसलिए मैं इसके बजाय प्रधान कारक का उपयोग कर रहा हूं। किसी संख्या का सबसे बड़ा उचित भाजक सबसे छोटे को छोड़कर इसके प्रमुख कारकों का उत्पाद है। मैं इस फ़ंक्शन को 2 से लेकर इनपुट तक की सीमा पर मैप करता हूं, और परिणामों को योग करता हूं।

ṁȯΠtptḣ  Define a function:
      ḣ  Range from 1 to input.
     t   Remove the first element (range from 2).
ṁ        Map over the list and take sum:
 ȯ        The composition of
    p     prime factorization,
   t      tail (remove smallest prime) and
  Π       product.
— Zgarb
स्रोत
5

अजगर 2 , 50 बाइट्स

f=lambda n,k=2:n/k and(f(n,k+1),n/k+f(n-1))[n%k<1]

यह धीमा है और TIO पर इनपुट 15 का सामना भी नहीं कर सकता है ।

इसे ऑनलाइन आज़माएं!

हालांकि, सभी परीक्षण मामलों को सत्यापित करने के लिए संस्मरण ( धन्यवाद @ musicman523 ) का उपयोग किया जा सकता है।

इसे ऑनलाइन आज़माएं!

वैकल्पिक संस्करण, 52 बाइट्स

2 बाइट्स की कीमत पर, हम यह चुन सकते हैं कि गणना करना है f(n,k+1)या नहीं n/k+f(n-1)।

f=lambda n,k=2:n>1and(n%k and f(n,k+1)or n/k+f(n-1))

कुछ चालबाजी के साथ, यह सभी परीक्षण मामलों के लिए काम करता है, यहां तक ​​कि टीआईओ पर भी।

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
के बाद से fएक है शुद्ध समारोह , आप उस पर बड़े मामलों को चलाने के लिए कर सकते हैं memoize TIO
— musicman523
सही, एक सज्जाकार का उपयोग करने में सक्षम नहीं होने के कारण मुझे फेंक दिया। धन्यवाद!
— डेनिस
4

जावास्क्रिप्ट (ईएस 6), 40 बाइट्स

f=(n,i=2)=>n<2?0:n%i?f(n,i+1):n/i+f(n-1)
<input type=number oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

एक संख्या अपने उच्चतम उचित विभाजक और उसके सबसे छोटे प्रधान कारक के उत्पाद के बराबर होती है।

— नील
स्रोत
स्टैक ओवरफ्लो n>352(कम से कम इस स्निपेट में, न जाने क्या है कि यह मेरा ब्राउज़र / मशीन निर्भरता है) जबकि आपको कम से कम तक का समर्थन करना चाहिए n=1000।
— आधिकारिक
@officialaimm यह काम करता है n=1000यदि आप उदा node --stack_size=8000।
— नील
4

05AB1E , 9 8 बाइट्स

-1 बाइट की बदौलत लीकी नून के प्राइम फैक्टर ट्रिक के बारे में अपने पाइथ के जवाब में

L¦vyÒ¦PO

इसे ऑनलाइन आज़माएं!

व्याख्या

L¦vyÒ¦PO
L¦       # Range [2 .. input]
  vy     # For each...
    Ò¦    # All prime factors except the first one
      P   # Product
       O  # Sum with previous results
         # Implicit print

वैकल्पिक 8 बाइट समाधान (यह TIO पर काम नहीं करता है)

L¦vyѨθO

और ofc वैकल्पिक 9 बाइट समाधान (यह TIO पर काम करता है)

L¦vyѨ®èO
— Datboi
स्रोत
4

रेटिना , 31 24 बाइट्स

मार्टिन एंडर को 7 बाइट्स धन्यवाद।

.+
$*
M!&`(1+)(?=\1+$)
1

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

Regex /^(1+)\1+$/एक निश्चित संख्या के सबसे बड़े समुचित भाजक को दर्शाता है जो एकात्मक में दर्शाया गया है। कोड में, \1+लुकहेड सिंटैक्स में बदल जाता है।

— लीक नन
स्रोत
4

पायथ , 13 9 8 बाइट्स

जैकोब्लाव के लिए 1 बाइट धन्यवाद।

tsm*FtPh

टेस्ट सूट ।

यह काम किस प्रकार करता है

सबसे बड़ा उचित भाजक सबसे छोटे वाले को छोड़कर प्रमुख कारकों का उत्पाद है।

— लीक नन
स्रोत
— जाकोबाला
4

पायथन 2 (PyPy) , 73 71 70 बाइट्स

n=input();r=[0]*n;d=1
while n:n-=1;r[d+d::d]=n/d*[d];d+=1
print sum(r)

सबसे कम पायथन जवाब नहीं है, लेकिन यह सिर्फ परीक्षण के मामलों के माध्यम से उभरता है। TIO एक पसीने को तोड़ने के बिना 30,000,000 तक के इनपुट संभालती है ; मेरा डेस्कटॉप कंप्यूटर एक मिनट में 300,000,000 संभालता है ।

2 बाइट्स की कीमत पर , हालत n>d~ 10% की गति के लिए इस्तेमाल की जा सकती है।

इस r=[0]*nविचार के लिए @xnor को धन्यवाद , जिसने 3 बाइट्स बचाए!

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
मजेदार, मैंने अभी मूल रूप से एक ही कोड लिखा था ।
— xnor
l=[0]*nआपको छूटने देना चाहिए -2। execथोड़े गति को मारता है, लेकिन यहां तक ​​कि एक whileलूप भी मेरे दृष्टिकोण से छोटा होगा।
— डेनिस
यह मेरे दृष्टिकोण की तुलना में थोड़ा तेज है। अगर मैं अपने उत्तर को संपादित करूं तो मन?
— डेनिस
कृपया, इसके लिए जाएं।
— xnor
1
@ Mr.Xcoder PyPy में नहीं है, लेकिन हां, इस तरह की समस्या के लिए लोग ठीक करते हैं।
— डेनिस
4

हास्केल, 48 46 43 बाइट्स

f 2=1
f n=until((<1).mod n)pred(n-1)+f(n-1)

इसे ऑनलाइन आज़माएं!

संपादित करें: @rogaos ने दो बाइट्स बचाए। धन्यवाद!

एडिट II: ... और @xnor 3 अन्य बाइट्स।

— nimi
स्रोत
-2 बाइट्स:f 2=1 f n=last[d|d<-[1..n-1],mod n d<1]+f(n-1)
— vroomfondel
@rogaos: धन्यवाद! मैंने स्वयं स्पष्ट पुनरावृत्ति की कोशिश की है, लेकिन हटाया नहीं sum, इसलिए मैंने सोचा कि यह छोटा नहीं है।
— निम्मी
1
untilकुछ और बचाता है:until((<1).mod n)pred(n-1)+f(n-1)
— xnor
4

जाप , 8 + 2 = 10 8 6 बाइट्स

òâ1 xo

झसे आज़माओ

  • 1 बाइट ETHproductions के लिए धन्यवाद बचा लिया।

व्याख्या

    :Implicit input of integer U.
ò   :Generate an array of integers from 1 to U, inclusive
â   :Get the divisors of each number,
1   :  excluding itself.
x   :Sum the main array
o   :by popping the last element from each sub-array.
    :Implicit output of result
— झबरा
स्रोत
ध्यान दें कि इस पोस्ट के-x अनुसार दो बाइट्स के रूप में गिना जाता है । हालाँकि, मुझे लगता है कि आप एक बाइट को बचा सकते हैं ( एक तर्क दिए जाने पर मूल संख्या को ò2_â1 oâ
— छोड़कर
धन्यवाद, @ETHproductions; मैं उन दोनों चीजों को याद करता था। मुझे आश्चर्य है कि उन सभी समाधानों पर अप्रत्यक्ष रूप से लागू होता है जहां हमने 1 बाइट के रूप में झंडे गिने थे? मैं एक वैकल्पिक समाधान पर काम कर रहा था जो वैसे भी एक ध्वज का उपयोग नहीं करता था; इशारा करते हुए âकहा कि मुझे वह बचत मिल गई जिसकी मुझे तलाश थी।
— झबरा
मैं ऐसा मान सकता हूं, क्योंकि हम पहले आम सहमति का पालन नहीं कर रहे थे। Btw, मैं के साथ खेलने गया था õ Åसे पहले और एक जोड़ी 8- और 9 byters पाया: õ Åx_/k g, õ Åx_k Å×, õ Åx_â¬o। और संयोजन õऔर Åआपकी प्रतिभा के साथ xoमुझे एक 7-बाइट समाधान मिला :-)
— ETHproductions
3

MATL, 12 बाइट्स

q:Q"@Z\l_)vs

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

        % Implicitly grab input (N)
q       % Subtract one
:       % Create an array [1...(N-1)]
Q       % Add one to create [2...N]
"       % For each element
  @Z\   % Compute the divisors of this element (including itself)
  l_)   % Grab the next to last element (the largest that isn't itself)
  v     % Vertically concatenate the entire stack so far
  s     % Sum the result
— Suever
स्रोत
3

क्यूबिक्स , 27 39 बाइट्स

?%\(W!:.U0IU(;u;p+qu.@Op\;;

इसे ऑनलाइन आज़माएं!

Cubified

      ? % \
      ( W !
      : . U
0 I U ( ; u ; p + q u .
@ O p \ ; ; . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

यह देखो भागो

  • 0IUस्टैक को एक संचायक, और शुरुआती पूर्णांक के साथ सेट करें। बाहरी लूप में यू-टर्न लें
  • :(? स्टैक, डीक्रीमेंट और टेस्ट के वर्तमान शीर्ष को डुप्लिकेट करें
  • \pO@ यदि दर्पण में घन के चारों ओर शून्य लूप है, तो स्टैक, आउटपुट और हाल्ट के निचले भाग को पकड़ो
  • %\! अगर सकारात्मक, आधुनिक, पुनरावृत्ति और परीक्षण।
    • u;.W यदि सत्य, यू-टर्न, मॉड परिणाम को हटा दें और लेन वापस आंतरिक लूप में बदल जाए
    • U;p+qu;;\(यदि फाल्सी, यू-टर्न, मॉड रिजल्ट को हटा दें, तो संचायक को शीर्ष पर लाएँ, वर्तमान पूर्णांक (टॉप) डिविज़र पुश को नीचे और यू-टर्न में जोड़ें। केवल संचायक और वर्तमान पूर्णांक के लिए स्टैक को साफ करें, पूर्णांक को घटाएं और बाहरी लूप को फिर से दर्ज करें।
— MickyT
स्रोत
3

सी # (.NET कोर) , 74 72 बाइट्स

n=>{int r=0,j;for(;n>1;n--)for(j=n;--j>0;)if(n%j<1){r+=j;j=0;}return r;}

इसे ऑनलाइन आज़माएं!

  • 2 बाइट्स ने केविन क्रूज़सेन को धन्यवाद दिया।
— चार्ली
स्रोत
1
मैं जानता हूँ कि यह एक साल के बारे में किया गया है, लेकिन आप यह कर सकते हैं गोल्फ breakके लिए j=0।
— केविन क्रूज़सेन
@KevinCruijssen एक बहुत ही सरल लेकिन प्रभावी ट्रिक है। अछा सुझाव!
— चार्ली
2

पायथन 3 , 78 75 73 71 बाइट्स

बाइट काउंट में लीकी नन के अजगर जवाब के करीब भी नहीं।

f=lambda z:sum(max(i for i in range(1,y)if 1>y%i)for y in range(2,z+1))

इसे ऑनलाइन आज़माएं!

— officialaimm
स्रोत
1
आप मेरे उत्तर के पहले संशोधन के करीब पहुँच रहे हैं ... आप मेरा संपादन इतिहास देख सकते हैं।
— लीक नून
ओह, हाहा ... मैं कसम खाता हूं कि मैंने इसे नहीं चुराया ... :)
— आधिकारिक
2

पायथन 3 , 69 63 59 बाइट्स

4 बाइट्स डेनिस के लिए धन्यवाद।

f=lambda n:n-1and max(j for j in range(1,n)if n%j<1)+f(n-1)

इसे ऑनलाइन आज़माएं!

मैंने 1000 के लिए काम करने के लिए 2000 के लिए पुनरावर्तन सीमा निर्धारित की है।

— लीक नन
स्रोत
+1 आपके पास मेरे ब्राउनी पॉइंट हैं! यही वह समाधान है जिसके बारे में मैं कह रहा था जब "70 बाइट्स से कम" ...
— श्री एक्सकोडर
इसके अलावा, यह पायथन 2 में भी काम करता है
— श्री एक्सकोडर
2

चारकोल , 37 बाइट्स

Ａ⁰βＦ…·²Ｎ«Ａ⟦⟧δＦ⮌…¹ι«¿¬﹪ικ⊞δκ»Ａ⁺β⌈δβ»Ｉβ

इसे ऑनलाइन आज़माएं!

लिंक वर्बोज़ संस्करण के लिए है। मुझे यह जानने में लगभग पूरा दिन लगा कि मैं चारकोल में एक गैर-एएससीआईआई-कला-संबंधित प्रश्न को कैसे हल कर सकता हूं, लेकिन आखिरकार मुझे मिल गया और मुझे मुझ पर बहुत गर्व है। :-D

हां, मुझे यकीन है कि यह बहुत बड़ा हो सकता है। मैंने सिर्फ अपने C # उत्तर का अनुवाद किया है और मुझे यकीन है कि चारकोल में चीजों को अलग तरीके से किया जा सकता है। कम से कम यह 1000कुछ सेकंड में मामले को हल करता है ...

— चार्ली
स्रोत
2

पायथन 2 (PyPy) , 145 बाइट्स

क्योंकि कोड-गोल्फ प्रतियोगिताओं को सबसे तेज़-कोड प्रतियोगिताओं में बदलना मज़ेदार है, यहाँ एक O ( n ) एल्गोरिथ्म है, जो TIO पर, n = 5,000,000,000 को 30 सेकंड में हल करता है । ( डेनिस की छलनी हे ( एन लॉग एन )।)

import sympy
n=input()
def g(i,p,k,s):
 while p*max(p,k)<=n:l=k*p;i+=1;p=sympy.sieve[i];s-=g(i,p,l,n/l*(n/l*k+k-2)/2)
 return s
print~g(1,2,1,-n)

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

हम सेट का आकार गिनते हैं

एस = {( ए , बी ) | 2 ≤ एक ≤ n , 2 ≤ ख ≤ सबसे बड़े उचित-भाजक ( एक )},

संघ के रूप में इसे फिर से लिखकर, सभी primes p √ then, पर

एस पी = {( पी ⋅ डी , बी ) | 2 ≤ घ ≤ n / पी , 2 ≤ ख ≤ घ },

और समावेश-बहिष्करण सिद्धांत का उपयोग करना :

| एस | = = (∑1) m - 1 | S p 1। ∩ ∩ S p m | m over 1 और primes p 1 < p < p m ≤ √n,

कहाँ पे

एस पी 1 ∩ ⋯ ∩ एस पी मीटर = {( पी 1 ⋯ पी मीटर ⋅ ई , बी ) | 1 ≤ ई ≤ n / ( पी 1 ⋯ पी एम ), 2 ≤ ख ≤ पी 1 ⋯ पी एम - 1 ई },
| S p 1। ∩ ∩ S p m | = ⌊ n / ( पी 1 ⋯ पी एम ) ⌋⋅ ( पी 1 ⋯पी एम - 1 ⋅ (⌊ n / ( पी 1 ⋯ पी एम ) ⌋ +1) - 2) / 2।

योग है सी ⋅ n अशून्य मामले, जहां सी कुछ निरंतर शायद इसलिए है कि 6⋅ (1 - 2 ln) को converges / π 2 ≈ .१,८६,५४४। अंतिम परिणाम तो | एस | + एन - 1।

— एंडर्स कसीगोर
स्रोत
ऊह, यह तेज़ है ...
— श्री एक्सकोडर
2

न्यूस्टैक , 5 बाइट्स

सौभाग्य से, वास्तव में एक अंतर्निहित है।

Nᵢ;qΣ

विभाजन:

Nᵢ       Add the first (user's input) natural numbers to the stack.
  ;      Perform the highest factor operator on whole stack.
   q     Pop bottom of stack.
    Σ    Sum stack.

वास्तविक अंग्रेजी में:

8 के इनपुट के लिए एक उदाहरण चलाते हैं।

Nᵢ: 1 से प्राकृतिक संख्या की सूची बनाएं, हालांकि 8: 1, 2, 3, 4, 5, 6, 7, 8

;: सबसे बड़े कारकों की गणना करें: 1, 1, 1, 2, 1, 3, 1, 4

q। पहला तत्व निकालें:1, 1, 2, 1, 3, 1, 4

Σऔर योग लो: 1+1+2+1+3+1+4=13

— Graviton
स्रोत
1+1+2+1+3+1+4= 13नहीं है 8। इसके अलावा: महान जवाब तो +1।
— केविन क्रूज़सेन
@KevinCruijssen वूप्स, कि पकड़ने के लिए धन्यवाद!
— ग्रेविटॉन
2

जावा 8, 78 74 72 बाइट्स

n->{int r=0,j;for(;n>1;n--)for(j=n;j-->1;)if(n%j<1){r+=j;j=0;}return r;}

पोर्ट @CarlosAlejo का के सी # उत्तर।

इसे यहाँ आज़माएँ।

पुराना उत्तर (78 बाइट्स):

n->{int r=0,i=1,j,k;for(;++i<=n;r+=k)for(j=1,k=1;++j<i;k=i%j<1?j:k);return r;}

इसे यहाँ आज़माएँ।

स्पष्टीकरण (पुराने उत्तर का):

n->{                    // Method with integer parameter and integer return-type
  int r=0,              //  Result-integers
      i=1,j,k;          //  Some temp integers
  for(;++i<=n;          //  Loop (1) from 2 to `n` (inclusive)
      r+=k)             //    And add `k` to the result after every iteration
    for(j=1,k=1;++j<i;  //   Inner loop (2) from `2` to `i` (exclusive)
      k=i%j<1?j:k       //    If `i` is dividable by `j`, replace `k` with `j`
    );                  //   End of inner loop (2)
                        //  End of loop (2) (implicit / single-line body)
  return r;             //  Return result-integer
}                       // End of method
— केविन क्रूज़सेन
स्रोत
1

स्टैक्ड , 31 बाइट्स

[2\|>[divisors:pop\MAX]map sum]

इसे ऑनलाइन आज़माएं! (1000 को छोड़कर सभी टेस्टकेस, जो 60 सेकंड की ऑनलाइन समय सीमा से अधिक है।)

व्याख्या

[2\|>[divisors:pop\MAX]map sum]
 2\|>                               range from 2 to the input inclusive
     [                ]map          map this function over the range
      divisors                      get the divisors of the number (including the number)
              :pop\                 pop a number off the array and swap it with the array
                   MAX              gets the maximum value from the array
                           sum      sum's all the max's
— कोनोर ओ ब्रायन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.