17

आपका फ़ंक्शन एक प्राकृतिक संख्या लेता है और सबसे छोटी प्राकृतिक संख्या देता है, जिसमें स्वयं सहित, विभाजक की मात्रा होती है।

उदाहरण:

f(1) =  1 [1]
f(2) =  2 [1, 2]
f(3) =  4 [1, 2, 4]
f(4) =  6 [1, 2, 3, 6]
f(5) = 16 [1, 2, 4, 8, 16]
f(6) = 12 [1, 2, 3, 4, 6, 12]
 ...

फ़ंक्शन को divisers की सूची को वापस नहीं करना है, वे केवल उदाहरण के लिए यहां हैं।

code-golf math sequence

— SteeveDroz
स्रोत

2

क्या यह कोड-गोल्फ या कोड-चैलेंज है?

— मारिनस

उफ़, उस टैग, कोड-गोल्फ के बारे में भूल गया!

— स्टेवड्रोज़

11

A005179

— पीटर टेलर

6

एपीएल, 25 24 23 वर्ण

f←{({+/⍵=⍵∧⍳⍵}¨⍳2*⍵)⍳⍵}

एक फ़ंक्शन को परिभाषित करता है fजो तब संख्याओं की गणना करने के लिए उपयोग किया जा सकता है:

समाधान इस तथ्य का उपयोग करता है कि LCM (n, x) == n iff x n को विभाजित करता है । इस प्रकार, ब्लॉक {+/⍵=⍵∧⍳⍵}केवल विभाजकों की संख्या की गणना करता है। यह फ़ंक्शन 1 से 2 ^ डी तक सभी नंबरों पर लागू होता है ¨⍳2*⍵। परिणामी सूची को तब d ( ⍳⍵) के लिए खोजा जाता है, जो वांछित फ़ंक्शन f (d) है ।

— हावर्ड
स्रोत

बधाई! 23 अक्षर ... वाह!

— स्टेवड्रोज़

19:{⍵⍳⍨(+/⊢=⊢∧⍳)¨⍳2*⍵}

— अदाम

मुझे नहीं लगता कि आपको परिभाषित करने की आवश्यकता है f।

— जकार्इ

5

GolfScript, 29 28 अक्षर

{.{\.,{)1$\%},,-=}+2@?,?}:f;

संपादित करें: यदि हम इस विचार के लिए पीटर टेलर को धन्यवाद देते हैं, तो एक खोज को बचाया जा सकता है।

पुराना वर्जन:

{.{\)..,{)1$\%},,-@=!}+do}:f;

GolfScript में एक प्रयास, ऑनलाइन भागो ।

उदाहरण:

13 f p  # => 4096
14 f p  # => 192
15 f p  # => 144

कोड में अनिवार्य रूप से तीन ब्लॉक होते हैं जिन्हें निम्नलिखित पंक्तियों में विस्तार से बताया गया है।

# Calculate numbers of divisors
#         .,{)1$\%},,-    
# Input stack: n
# After application: D(n)

.,          # push array [0 .. n-1] to stack
{           # filter array by function
  )         #   take array element and increase by one
  1$\%      #   test division of n ($1) by this value
},          # -> List of numbers x where n is NOT divisible by x+1
,           # count these numbers. Stack now is n xd(n)
-           # subtracting from n yields the result



# Test if number of divisors D(n) is equal to d
#         {\D=}+   , for D see above
# Input stack: n d
# After application: D(n)==d

{
  \         # swap stack -> d n
  D         # calculate D(n) -> d D(n)
  =         # compare
}+          # consumes d from stack and prepends it to code block         



# Search for the first number which D(n) is equal to d
#         .T2@?,?    , for T see above
# Input stack: d
# After application: f(d)

.           # duplicate -> d d
T           # push code block (!) for T(n,d) -> d T(n,d)
2@?         # swap and calculate 2^d -> T(n,d) 2^d
,           # make array -> T(n,d) [0 .. 2^d-1]
?           # search first element in array where T(n,d) is true -> f(d)

— हावर्ड
स्रोत

इनपुट के लिए एक अनंत लूप में जाने लगता है 1।

— पीटर टेलर

मेरा अब तक का सबसे अच्छा समाधान आपके लिए काफी हद तक उधार लेता है, इस हद तक कि मुझे लगता है कि यह एक अलग जवाब के बजाय एक टिप्पणी के योग्य है।

— पीटर टेलर

4

अजगर: 64

बकुरी के समाधान को संशोधित करना और grc के सुझाव के साथ-साथ प्लैनैपस के R समाधान से चाल को शामिल करना, हमें मिलता है:

f=lambda n,k=1:n-sum(k%i<1for i in range(1,k+1))and f(n,k+1)or k

— निकिता बोरिसोव
स्रोत

4

अजगर: 66

f=lambda n,k=1:n==sum(k%i<1for i in range(1,k+1))and k or f(n,k+1)

ऊपर RuntimeError: maximum recursion depth exceededसीपीथॉन में छोटे इनपुट के साथ, और यहां तक कि एक बड़ी संख्या की सीमा निर्धारित करने से यह संभवत: कुछ समस्याएं देगा। अजगर कार्यान्वयन पर जो पूंछ की पुनरावृत्ति को अनुकूलित करता है, उसे ठीक काम करना चाहिए।

अधिक वर्बोज़ संस्करण, जिसमें ऐसी सीमाएँ नहीं होनी चाहिए, निम्नलिखित 79 बाइट्स समाधान है:

def f(n,k=1):
    while 1:
        if sum(k%i<1for i in range(1,k+1))==n:return k
        k+=1

— Bakuriu
स्रोत

मैं 11, 13, 17, 19 और अन्य पर पुनरावृत्ति सीमा मार रहा हूं।

— स्टीवन रूमालस्की

@StevenRumbalski किसी ने उल्लेख नहीं किया कि कार्यक्रम को मनमाने ढंग से पूर्णांकों के साथ काम करना चाहिए। दुर्भाग्य से संख्या छोटे आदानों के साथ भी बहुत तेजी से बढ़ती है।

— बकुरीउ

आप के if elseसाथ and orऔर के ==1साथ का उपयोग करके कुछ चार्ट बचा सकते हैं <1:f=lambda n,k=1:n==sum(k%i<1for i in range(1,k+1))and k or f(n,k+1)

— grc

क्योंकि मुझे 66 थोड़ी बहुत बुराई लगती है, अगर आप उपयोग करते हैं तो आप 2 अक्षर बचा सकते हैंsum(k%-~i<1for i in range(k))

— अस्थिरता

f=lambda n,k=1:n==sum(k%-~i<1for i in range(k))or-~f(n,k+1)7 बाइट्स बचाता है।

— डेनिस

4

गणितज्ञ ३hem ३६

(For[i=1,DivisorSum[++i,1&]!=#,];i)&

उपयोग:

(For[i=1,DivisorSum[++i,1&]!=#,];i)&@200

परिणाम:

संपादित करें

कुछ स्पष्टीकरण:

DivisorSum [n, form] सभी के लिए [i] फॉर्म के योग को दर्शाता है जो n को विभाजित करता है।

जैसा कि form[i]मैं फ़ंक्शन का उपयोग कर रहा हूं 1 &, जो हमेशा रिटर्न करता है 1, इसलिए प्रभावी ढंग से विभाजन के योग को गणना करता है।

— डॉ। बेलिसरियस
स्रोत

कोई कोड-गोल्फ टैग नहीं था इसलिए मैंने एक लंबा जवाब दिया! उफ़

— डेविड 23

@ दाविदकरहर मैं सिर्फ अनुमान लगाया :)

— डॉ। बेलिसरियस

मुझे लगा कि मुझे पता है कि क्या DivisorSumरिटर्न (डिवोर्स का योग) है, लेकिन मैं यह नहीं देखता कि प्रश्न का उत्तर देने के लिए यह कैसे महत्वपूर्ण है। क्या आप बताएंगे कि यह कैसे काम करता है। BTW, मुझे लगता है कि आपको n = 200 के लिए समय डेटा शामिल करना चाहिए; फ़ंक्शन उल्लेखनीय रूप से तेज़ है, यह देखने के लिए सभी नंबरों को देखते हुए।

— डेविड

@DavidCarraher संपादन देखें पुन: समय - मेरी मशीन रास्ता बहुत धीमी है :(

— डॉ। Belisarius

क्या मैथेमेटिका के पास कम परिष्कृत होने के लिए अधिक परिष्कृत दृष्टिकोण के लिए पर्याप्त बिल्ट-इन नहीं है? अगर ऐसा है, तो मैं निराश हूं।

— पीटर टेलर

3

जे, 33 वर्ण

बहुत जल्दी, सभी छोटी संख्याओं से गुजरता है और कारक के आधार पर विभाजकों की संख्या की गणना करता है।

   f=.>:@]^:([~:[:*/[:>:_&q:@])^:_&1

   f 19
262144

— randomra
स्रोत

3

हास्केल 54

त्वरित और गंदा (इतना पठनीय और गैर-मुश्किल) समाधान:

f k=head[x|x<-[k..],length[y|y<-[1..x],mod x y==0]==k]

— shiona
स्रोत

संपादन ने उत्तर को कोई छोटा नहीं बनाया, लेकिन यह शायद अधिक हैस्केल की तरह है। इसके अलावा, मैंने हमेशा अपनी कोड लंबाई में अनुगामी न्यूलाइन को शामिल किया है, क्या यह गलत है?

— शियोना

मुझे लगा कि आपने मिसकॉल किया है; संपादन का मुख्य उद्देश्य गिनती को अद्यतन करना था। कोड में बदलाव केवल मामूली था। मुझे लगता है कि यहां की अन्य प्रविष्टियाँ अनुगामी न्यूलाइन की गणना नहीं करती हैं, जैसे कि J (33 वर्ण) के लिए प्रविष्टि।

— विल नेस

2

के, ४२

अपर्याप्त पुनरावर्ती समाधान जो स्टैक को काफी आसानी से उड़ा देता है

{{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]}

।

k){{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]}14
192
k){{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]}13
'stack

— tmartin
स्रोत

2

एपीएल 33

F n            
i←0              
l:i←i+1          
→(n≠+/0=(⍳i)|i)/l
i

उदाहरण:

F 6
12

— ग्राहम
स्रोत

2

एपीएल (25)

{⍵{⍺=+/0=⍵|⍨⍳⍵:⍵⋄⍺∇⍵+1}1}

— मारीनस
स्रोत

बेईमान! इको-एन '{⍵ {⍺ = + / 0 = ⍨⍳⍵ | ⍵⋄⍺∇⍵: ⍵⋄⍺∇⍵ + 1} 1}' | wc -c मुझे 47 देता है! लेकिन वास्तव में, क्या आप मुझे एपीएल के लिए कुछ आसान ट्यूटोरियल का लिंक दे सकते हैं? मैंने इसे गूगल करने की कोशिश की है और कुछ लेख पढ़े हैं, लेकिन फिर भी अंत में मैं हमेशा पूछना चाहता हूं कि "वे ऐसा क्यों कर रहे हैं ?(?"। मैंने कभी भी किसी गैर-एएससीआईआई सिंटैक्स भाषा के साथ काम नहीं किया है और यह पता लगाना चाहता हूं। इसका कोई वास्तविक फायदा है।

— XzKto

यह डायलाग एपीएल के लिए है, जो कि मैं उपयोग करता हूं, आप उसी साइट पर मुफ्त में विंडोज संस्करण डाउनलोड कर सकते हैं। dyalog.com/MasteringDyalogAPL/MasteringDyalogAPL.pdf

— मारीनस

वाह, ऐसा लग रहा है कि मैं वास्तव में इसे समझ सकता हूं। लिंक के लिए आपको धन्यवाद! केवल नकारात्मक पक्ष यह है कि उनके पास कुछ बहुत ही अजीब लाइसेंसिंग नीति है लेकिन शायद मुझे अपनी अंग्रेजी में सुधार करने की आवश्यकता है)

— XzKto

2

आर - 47 वर्ण

f=function(N){n=1;while(N-sum(!n%%1:n))n=n+1;n}

!n%%1:nबूलियन्स का एक वेक्टर देता है: सही है जब 1 से n तक का पूर्णांक n और FALSE का विभाजक है यदि नहीं। sum(!n%%1:n)बूलियनों को 0 को यदि FALSE और 1 को TRUE किया जाता है और उन्हें सम्‍मिलित करता है, तो यह N-sum(...)है कि 0 तब होता है जब विभाजक की संख्या N होती है। 0 को तब FALSE के रूप में समझा जाता है whileजिसके बाद रुक जाता है।

उपयोग:

f(6)
[1] 12
f(13)
[1] 4096

— plannapus
स्रोत

2

जावास्क्रिप्ट 70

function f(N){for(j=i=m=1;m-N||j-i;j>i?i+=m=j=1:m+=!(i%++j));return i}

वास्तव में केवल 46 सार्थक चरित्र हैं:

for(j=i=m=1;m-N||j-i;j>i?i+=m=j=1:m+=!(i%++j))

मैं शायद कम वाक्य रचना के साथ एक भाषा सीखना चाहिए :)

— XzKto
स्रोत

N=>eval("for(j=i=m=1;m-N||j-i;j>i?i+=m=j=1:m+=!(i%++j));i")

— TuxCrafting 10

2

हास्केल: 49 अक्षर

इसे पहले के हास्केल समाधान के सुधार के रूप में देखा जा सकता था, लेकिन इसकी कल्पना अपने अधिकार में की गई थी (चेतावनी: यह बहुत धीमी है):

f n=until(\i->n==sum[1|j<-[1..i],rem i j<1])(+1)1

यह काफी दिलचस्प कार्य है, उदाहरण के लिए ध्यान दें कि f (p) = 2 ^ (p-1), जहाँ p एक अभाज्य संख्या है।

— Fors
स्रोत

कुशल, के रूप में कम करने का विरोध किया, जिस तरह से गणना करने के लिए यह कारक होगा nअभाज्य में (दोहराव के साथ), तरह उतरते, हर एक घटती, अभाज्य संख्या की एक अनंत अनुक्रम के साथ ज़िप, और उसके बाद के उत्पाद गुनाp^(factor-1)

— पीटर टेलर

2

@PeterTaylor आवश्यक नहीं है। N = 16 = 2 * 2 * 2 * 2 समाधान के लिए 2 ^ 3 * 3 ^ 1 * 5 ^ 1 = 120 है, 2 ^ 1 * 3 ^ 1 * 5 ^ 1 * 7 ^ 1 = 210 नहीं है।

— यादृच्छिक

2

सी: 66 64 वर्ण

एक लगभग संक्षिप्त समाधान:

i;f(n){while(n-g(++i));return i;}g(j){return j?!(i%j)+g(j-1):0;}

और मेरा पिछला समाधान जो पुनरावृत्ति नहीं करता है:

i;j;k;f(n){while(k-n&&++i)for(k=0,j=1;j<=i;k+=!(i%j++));return i;}

बहुत कम समाधान मौजूद होने चाहिए।

— Fors
स्रोत

2

हास्केल (120 सी), एक बहुत ही कुशल विधि

1<>p=[]
x<>p|mod x p>0=x<>(p+1)|1<2=(div x p<>p)++[p]
f k=product[p^(c-1)|(p,c)<-zip[r|r<-[2..k],2>length(r<>2)](k<>2)]

टेस्ट कोड:

main=do putStrLn$show$ f (100000::Integer)

यह विधि बहुत तेज है। यह विचार सबसे पहले के प्रमुख कारकों को खोजने के लिए है k=p1*p2*...*pm, जहां p1 <= P2 <= ... <= pm। तो जवाब हैn = 2^(pm-1) * 3^(p(m-1)-1) * 5^(p(m-2)-1) ... ।

उदाहरण के लिए, k = 18 को फैक्टरिंग करते हुए, हमें 18 = 2 * 3 * 3 मिलते हैं। पहले 3 प्राइम्स 2, 3, 5. होते हैं। इसलिए उत्तर n = 2 ^ (3-1) * 3 ^ (3-1) * 5 ^ (2-1) = 4 * 9 * 5 = 180

आप इसे नीचे देख सकते हैं ghci:

*Main> f 18
180
*Main> f 10000000
1740652905587144828469399739530000
*Main> f 1000000000
1302303070391975081724526582139502123033432810000
*Main> f 100000000000
25958180173643524088357042948368704203923121762667635047013610000
*Main> f 10000000000000
6558313786906640112489895663139340360110815128467528032775795115280724604138270000
*Main> f 1000000000000000
7348810968806203597063900192838925279090695601493714327649576583670128003853133061160889908724790000
*Main> f 100000000000000000
71188706857499485011467278407770542735616855123676504522039680180114830719677927305683781590828722891087523475746870000
*Main> f 10000000000000000000
2798178979166951451842528148175504903754628434958803670791683781551387366333345375422961774196997331643554372758635346791935929536819490000
*Main> f 10000000000000000000000
6628041919424064609742258499702994184911680129293140595567200404379028498804621325505764043845346230598649786731543414049417584746693323667614171464476224652223383190000

— रे
स्रोत

यह एक खराब गोल्फ स्कोर है, लेकिन आपके द्वारा लिए गए रास्ते के लिए +1 है!

— स्टीवेयड्रोज़

8 = 2 * 2 * 2 के लिए यह एल्गोरिथम नंबर 2 * 3 * 5 = 30 देता है। लेकिन सबसे अच्छा समाधान 2 ^ 3 * 3 = 24 (8 = 2 * 4 के लिए) है

— AMK

समाधान गलत है यदि निर्दिष्ट संख्या में विभाजकों में छोटे प्राइम की उच्च शक्ति है। तो 10 की शक्तियों के लिए सबसे संभावित सूचीबद्ध समाधान गलत हैं।

— AMK

@AMK हां, आप सही कह रहे हैं। यह बात बताने के लिए धन्यवाद।

— रे

2

ब्रेकीलॉग , 2 बाइट्स

fl

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

इसके आउटपुट चर के माध्यम से इनपुट लेता है और इसके इनपुट चर के माध्यम से आउटपुट करता है।

f     The list of factors of
      the input variable
 l    has length equal to
      the output variable.

यह सटीक समान है, इसके इनपुट चर के माध्यम से इनपुट लेता है और इसके आउटपुट चर के माध्यम से आउटपुट करता है, इसके बजाय इस चुनौती को हल करता है ।

— असंबंधित स्ट्रिंग
स्रोत

अच्छा है, लेकिन उस पहेली के लिए पात्र नहीं है क्योंकि भाषा प्रश्न से अधिक हाल की है।

— स्टिवडोज़र

जब मैं यहाँ नया था, तो पहली बार जो मुझे बताया गया था, वह यह था कि सवालों की तुलना में नई भाषाएँ अब और नहीं हैं, और यह मेटा द्वारा समर्थित है: codegolf.meta.stackexchange.com/questions/12877/...

— असंबंधित स्ट्रिंग

ओह ठीक है, फिर कभी नहीं। जाहिर है, नियम विकसित करने के लिए बनाए गए हैं और हमें ध्यान रखना चाहिए कि इस साइट का मुख्य उद्देश्य खुद को बेहतर बनाना और मज़े करना है। उत्तर स्वीकृत!

— २०:०

1

C, 69 वर्ण

सबसे छोटा नहीं, लेकिन पहला C उत्तर:

f(n,s){return--s?f(n,s)+!(n%s):1;}
x;
g(d){return++x,f(x,x)-d&&g(d),x;}

f(n,s)nश्रेणी में विभाजक गिना जाता है 1..s। तो के f(n,n)विभाजक गिना जाता है n।
g(d)छोरों (पुनरावृत्ति द्वारा) तक f(x,x)==d, फिर एक्स लौटाता है।

— ugoren
स्रोत

1

गणितज्ञ ३hem ३६

(For[k=1,DivisorSigma[0, k]!= #,k++]; k)&

प्रयोग

   (For[k = 1, DivisorSigma[0, k] != #, k++]; k) &[7]

(* 64 *)

पहली प्रविष्टि ( code-golfटैग को प्रश्न में जोड़े जाने से पहले )

एक सीधी समस्या, यह देखते हुए कि (सहित) Divisors[n]के विभाजकों को लौटाता हैnn )Length[Divisors[n]] लौटाता है और ऐसे भाजक की संख्या को लौटाता है। **

smallestNumber[nDivisors_] :=
   Module[{k = 1},
   While[Length[Divisors[k]] != nDivisors, k++];k]

उदाहरण

Table[{i, nDivisors[i]}, {i, 1, 20}] // Grid

गणितज्ञ ग्राफिक्स

— DavidC
स्रोत

डेविड, इससे छोटा और तेज Length@Divisors@nहै DivisorSigma[0,n]।

— मि। छिपकली

धन्यवाद। मैं उस उपयोग के बारे में नहीं जानता था DivisorSigma।

— डेविड

math.stackexchange.com/questions/1551959/…

— शुक्राणु

1

जेली , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

2*RÆdi

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

2*RÆdi  Main link. Argument: n (integer)

2*      Compute 2**n.
  R     Range; yield [1, ..., 2**n]. Note that 2**(n-1) has n divisors, so this
        range contains the number we are searching for.
   Æd   Divisor count; compute the number of divisors of each integer in the range.
     i  Index; return the first (1-based) index of n.

— डेनिस
स्रोत

क्यों करते हो 2*? क्या ऐसा है कि हर संख्या के बाद n से अधिक भाजक हैं?

— आउटगॉल्फ

2

नहीं; उदाहरण के लिए, सभी अपराधों में दो विभाजक हैं। हालाँकि, हम सबसे छोटे पॉजिटिव पूर्णांक की खोज कर रहे हैं, जो एन डिविजर्स के साथ है । चूंकि 2**(n-1)उस सीमा से संबंधित है, सबसे छोटा भी करता है।

— डेनिस

0

सी ++, 87 वर्ण

int a(int d){int k=0,r,i;for(;r!=d;k++)for(i=2,r=1;i<=k;i++)if(!(k%i))r++;return k-1;}

— cisplatin
स्रोत

0

पायथन 2, 95 अक्षर, गैर-पुनरावर्ती

अन्य अजगर समाधानों की तुलना में थोड़ा अधिक क्रियात्मक है लेकिन यह गैर-पुनरावर्ती है, इसलिए यह साइफन की पुनरावृत्ति सीमा को नहीं मारता है:

from itertools import*
f=lambda n:next(i for i in count()if sum(1>i%(j+1)for j in range(i))==n)

— बैप्टिस्ट एम।
स्रोत

0

पर्ल 6 , 39 वर्ण

{my \a=$=0;a++while $_-[+] a X%%1..a;a}

उदाहरण का उपयोग:

say (0..10).map: {my \a=$=0;a++while $_-[+] a X%%1..a;a}

(0 1 2 4 6 16 12 64 24 36 48)

— ब्रैड गिल्बर्ट b2gills
स्रोत

सबसे छोटी संख्या दें जिसमें एन डिविजर्स हों

एपीएल, 25 24 23 वर्ण

GolfScript, 29 28 अक्षर

गणितज्ञ ३hem ३६

जे, 33 वर्ण

हास्केल 54

के, ४२

एपीएल 33

एपीएल (25)

आर - 47 वर्ण

हास्केल: 49 अक्षर

सी: 66 64 वर्ण

हास्केल (120 सी), एक बहुत ही कुशल विधि

ब्रेकीलॉग , 2 बाइट्स

C, 69 वर्ण

गणितज्ञ ३hem ३६

जेली , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

पायथन 2, 95 अक्षर, गैर-पुनरावर्ती

पर्ल 6 , 39 वर्ण