50

"प्राइम चींटी" एक अड़ियल जानवर है जो पूर्णांकों को नेविगेट करता है और उन्हें तब तक विभाजित करता है जब तक कि केवल प्राइम नहीं बचे हैं!

प्रारंभ में, हमारे पास एक अनंत सरणी है जिसमें सभी पूर्णांक हैं> = 2: [2,3,4,5,6,.. ]

pसरणी पर चींटी की स्थिति होने दें । प्रारंभ में, p = 0(सरणी 0-अनुक्रमित है)

प्रत्येक मोड़, चींटी इस प्रकार आगे बढ़ेगी:

यदि A[p]प्रधान है, तो चींटी अगली स्थिति में जाती है:p ← p+1
किसी और, अगर A[p]एक समग्र संख्या है, चलो qअपने छोटे भाजक> 1. हो हम विभाजित A[p]द्वारा q, और हम जोड़ने qके लिए A[p-1]। चींटी पिछली स्थिति में जाती है:p ← p-1

यहाँ चींटी के लिए पहली चाल है:

 2  3  4  5  6  7  8  9  ... 
 ^
 2  3  4  5  6  7  8  9  ... 
    ^
 2  3  4  5  6  7  8  9  ... 
       ^
 2  5  2  5  6  7  8  9  ... 
    ^
 2  5  2  5  6  7  8  9  ... 
       ^
 2  5  2  5  6  7  8  9  ... 
          ^
 2  5  2  5  6  7  8  9  ... 
             ^
 2  5  2  7  3  7  8  9  ... 
          ^

आपका कार्यक्रम nचाल के बाद चींटी की स्थिति का उत्पादन करना चाहिए । (आप मान सकते हैं n <= 10000)

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

0 => 0
10 => 6
47 => 9
4734 => 274
10000 => 512

संपादित करें। आप 1-अनुक्रमित सूचियों का भी उपयोग कर सकते हैं, उपरोक्त परीक्षण मामले के लिए परिणाम 1, 7, 10, 275, 513 प्रदर्शित करना स्वीकार्य है।

यह कोड-गोल्फ है, इसलिए बाइट्स में सबसे कम कोड वाला कोड जीतता है।

code-golf sequence primes

— अरनॉड
स्रोत

32

मैंने ईमानदारी से सोचा था कि मेरे स्क्रीन पर एक चींटी थी जब मैंने इसे हॉट नेटवर्क प्रश्नों में देखा था।

— कोडोस जॉनसन

14

मुझे आश्चर्य है कि क्या अनुक्रम मनमाने ढंग से बड़े के लिए अच्छी तरह से परिभाषित है n(या क्या समग्र मामला कभी भी चींटी को शुरुआती के बाईं ओर धकेल सकता है 2)।

— मार्टिन एंडर

1

@ SuperChafouin परीक्षण मामलों के लिए आउटपुट हो सकता है: 1,7,10,275,513यदि 1-इंडेक्सिंग कहा गया हो? या फिर उन्हें अपने आउटपुट से मेल खाना होगा।

— टॉम कारपेंटर

12

@MartinEnder एक और खुला सवाल है कि क्या कोई प्राइम> 7 अंततः अच्छे के लिए पीछे रह सकता है।

— अरनुलद

2

@ अरनल्ड आउट जहाँ तक n = 1,000,000,000 (जहाँ p = 17156661) है, n और p के बीच का संबंध p = n / (ln (n) * ln (ln (n))) के बहुत निकट है।

— पेंगुइन

11

ऐलिस , 45 बाइट्स

/o
\i@/.&wqh!]k.&[&w;;?c]dt.n$k&;[.?~:![?+!kq

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

ज्यादातर सीधे-सादे कार्यान्वयन।

nऐलिस में लूपिंग बार आम तौर पर रिटर्न एड्रेस n-1बार को पुश करके किया जाता है , फिर प्रत्येक पुनरावृत्ति के अंत में वापस आ रहा है k। पिछली बार लूप के माध्यम से, kनिर्देश कहीं नहीं लौटा है, और निष्पादन आगे बढ़ता है।

यह प्रोग्राम kनंबर के प्राइम होने पर जल्दी बंद होने के लिए उसी निर्देश का उपयोग करता है। नतीजतन, अंतिम पुनरावृत्ति हमेशा बाईं ओर चींटी को स्थानांतरित करेगी। इस बग की भरपाई करने के लिए, हम n+11-अनुक्रमित सरणी पर पुनरावृत्तियों को करते हैं , जो वास्तव में हम चाहते हैं परिणाम देता है (और n=0मुफ्त में केस देता है )।

— Nitrodon
स्रोत

7

पायथन 2 , 120 बाइट्स

p=0
A=range(2,input()+2)
for _ in A:
 for q in range(2,A[p]):
	if A[p]%q<1:A[p]/=q;p-=1;A[p]+=q;break
 else:p+=1
print p

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

आह, दुर्लभ for- elseपाश! elseखंड केवल कार्यान्वित करता है, तो forशरीर है नहीं के माध्यम से बाहर निकल गया break। हमारे मामले में, इसका मतलब है कि हमने सभी qs की जाँच की और उनमें से किसी को भी विभाजित नहीं पाया p।

— लिन
स्रोत

7

ऑक्टेव , 109 103 101 94 बाइट्स

function i=a(n)i=1;for l=z=2:n+1
if nnz(q=factor(z(i)))>1
z(i--)/=p=q(1);z(i--)+=p;end
i++;end

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

यह कोड 1-अनुक्रमण में स्थिति को आउटपुट करेगा, इसलिए परीक्षण मामलों के लिए आउटपुट हैं:

0 => 1
10 => 7
47 => 10
4734 => 275
10000 => 513

यह संस्करण कुछ ऑक्टेव अनुकूलन का उपयोग करता है ताकि MATLAB के साथ संगत न हो। नीचे दिया गया कोड MATLAB संगत संस्करण है।

MATLAB, 130 123 118 117 बाइट्स

function i=a(n)
z=2:n+1;i=1;for l=z
q=factor(z(i));if nnz(q)>1
z(i)=z(i)/q(1);i=i-1;z(i)=z(i)+q(1);else
i=i+1;end
end

ऑक्टेव संस्करण के साथ 1-इंडेक्सिंग का उपयोग करता है। मैंने MATLAB में सभी परीक्षण मामलों के खिलाफ इसका परीक्षण किया है। एक उदाहरण के रूप में 100000 पर आउटपुट 3675 (एक-अनुक्रमण) है।

उपरोक्त कोड का एक टिप्पणी संस्करण:

function i=a(n)
    z=2:n+1;                %Create our field of numbers
    i=1;                    %Start of at index of 1 (MATLAB uses 1-indexing)
    for l=1:n               %For the required number of iterations
        q=factor(z(i));     %Calculate the prime factors of the current element
        if nnz(q)>1         %If there are more than one, then not prime
            z(i)=z(i)/q(1); %So divide current by the minimum
            i=i-1;          %Move back a step
            z(i)=z(i)+q(1); %And add on the minimum to the previous.
        else
            i=i+1;          %Otherwise we move to the next step
        end
    end

ब्याज के मामले के रूप में, यह चींटियों की संख्या है जो पहले 10000 मानों के पुनरावृत्तियों की संख्या है।

लगता है कि चींटी शायद अनंत की ओर रुख करेगी, लेकिन कौन जानता है, लग रहा है कि धोखा हो सकता है।

MATLAB: के साथ सहेजा 6 बाइट्स forके बजाय whileऔर से कोष्ठक को हटाने if- धन्यवाद @Giuseppe
MATLAB: 2 बाइट्स सहेजें - धन्यवाद @ सेंचुरीज़
ऑक्टेव: ऑक्टेव \=और +=संचालन का उपयोग करके 10 बाइट्स बचाएं - धन्यवाद @Giuseppe
ऑक्टेव: 2 बाइट्स बचाएं i++और i--- धन्यवाद @LuisMendo
ऑक्टेव: 7 बाइट्स बचाएं - धन्यवाद @ सेंचुरीज़

— टॉम बढ़ई
स्रोत

TIO पर काम करने के लिए, मुझे लगता है कि आपको endफ़ंक्शन हस्ताक्षर से मेल खाने की आवश्यकता है

— Giuseppe

@ गुइसेप्पे आह, ठीक है। MATLAB में अनुगामी endवैकल्पिक है।

— टॉम कारपेंटर

आप फ़ंक्शन का उपयोग करने के बजाय प्रारंभ में @ (n) का उपयोग करके अनाम फ़ंक्शन बना सकते हैं i (a)

— Michthan

@ मिचथन MATLAB में ऐसा नहीं कर सकते। मुझे नहीं लगता कि ओक्टेव में यह संभव है या तो यह लूप है?

— टॉम कारपेंटर

1

endऑक्टेव में भी ट्रेलिंग वैकल्पिक है। यहां केवल इसकी आवश्यकता है क्योंकि आपके पास फ़ंक्शन के बाद कोड है

— लुइस मेंडो

6

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

f=(n,a=[p=0])=>n--?f(n,a,(P=n=>++x<n?n%x?P(n):a[a[p]/=x,--p]+=x:p++)(a[p]=a[p]||p+2,x=1)):p

डेमो

एनबी: आपको अपने इंजन के डिफ़ॉल्ट स्टैक आकार को बढ़ाना पड़ सकता है ताकि सभी परीक्षण मामलों को पास किया जा सके।

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

— Arnauld
स्रोत

6

हास्केल , 108 106 94 बाइट्स

([0]#[2..]!!)
(a:b)#(p:q)=length b:([b#(a+d:div p d:q)|d<-[2..p-1],mod p d<1]++[(p:a:b)#q])!!0

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: ([0]#[2..]!!) 10पैदावार 6(0-अनुक्रमित)।

फ़ंक्शन #दो सूची पर काम करता है, सरणी का उल्टा सामने [p-1, p-2, ..., 1]और सरणी के अनंत बाकी [p, p+1, p+2, ...]। यह पदों की एक अनंत सूची का निर्माण करता है, जिसमें से nवें स्थान को एक इनपुट दिया जाता है n।

पैटर्न चींटी की वर्तमान स्थिति के मूल्य और पिछले स्थिति के मान को ((a:b)#(p:q))बांधता pहै a। bस्थिति 1 से लेकर सरणी तक का उपसर्ग p-2और qस्थिति से शुरू होने वाला अनंत विश्राम है p+1।

हम निम्नलिखित तरीके से पुनरावर्ती कॉल की सूची का निर्माण: हम प्रत्येक भाजक को देखने dके p(जो एक से बड़ा है और से छोटी है pआरोही क्रम में और जोड़ें) b#(a+d:div p d:q)उनमें से प्रत्येक के लिए, कि वर्तमान मूल्य है pसे विभाजित है dऔर चींटी चाल बाईं ओर एक कदम जहां dजोड़ा जाता है a। फिर हम (p:a:b)#qइस सूची के अंत में जाते हैं, जो चींटी को एक कदम दाईं ओर जाने का संकेत देती है।

हम फिर सूची से उन पुनरावर्ती कॉलों में से पहला लेते हैं और वर्तमान स्थिति को दिखाते हैं, जो उपसर्ग सूची की लंबाई के साथ मेल खाता है b। क्योंकि भाजक आरोही क्रम में हैं, पुनरावर्ती कॉल की सूची में से पहला उठाकर सुनिश्चित करता है कि हम सबसे छोटे का उपयोग करें। इसके अतिरिक्त, क्योंकि (p:a:b)#qसूची के अंत में जोड़ दिया जाता है, यह केवल तभी चुना जाता है जब कोई भाजक न हो और pइस प्रकार अभाज्य हो।

संपादन:
-2 बाइट्स के कार्यों की सूची को आरोही क्रम से आरोही करके।
-12 बाइट्स एक काउंटर को संभालने के बजाय, और 0-इंडेक्सिंग पर स्विच करके एक अनंत सूची में इंडेक्स करने के ज़गरब के विचार के लिए धन्यवाद।

— Laikoni
स्रोत

2

काउंटर के चारों ओर ले जाने के बजाय एक अनंत सूची और अनुक्रमण बनाकर 96 बाइट्स ।

— जर्ब

1

@Zgarb बहुत बहुत धन्यवाद! 0-इंडेक्सिंग पर स्विच करते समय यह केवल 94 बाइट्स है।

— लकोनी

5

टीआई-बेसिक, 108 103 102 98 बाइट्स

इनपुट और आउटपुट में संग्रहीत हैं Ans। आउटपुट 1-अनुक्रमित है।

Ans→N
seq(X,X,2,9³→A
1→P
For(I,1,N
1→X:∟A(P→V
For(F,2,√(V
If X and not(fPart(V/F:Then
DelVar XV/F→∟A(P
P-1→P
F+∟A(P→∟A(P
End
End
P+X→P
End

— kamoroso94
स्रोत

आप के fPart(∟A(P)/F:साथ एक बाइट ले सकते हैं fPart(F¹∟A(P:। अगली पंक्ति में भी यही बात।

— स्कॉट मिलनर

@ScottMilner जो हमेशा काम नहीं करता है। not(fPart(7⁻¹70 है, लेकिन not(fPart(7/7है 1.

— kamoroso94

5

MATL , 41 बाइट्स

:Q1y"XHyw)Zp?5MQ}1MtYf1)/H(8MyfHq=*+9M]]&

आउटपुट 1-आधारित है। ऑनलाइन दुभाषिया में अंतिम परीक्षण मामले के लिए कार्यक्रम का समय।

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

व्याख्या

कार्यक्रम चुनौती में वर्णित प्रक्रिया को लागू करता है। ऐसा करने के लिए, यह MATL के मैनुअल और स्वचालित क्लिपबोर्ड के असामान्य रूप से भारी उपयोग करता है।

सबसे छोटे भाजक को प्रधान कारक अपघटन में पहली प्रविष्टि के रूप में प्राप्त किया जाता है।

"डिवाइड" अपडेट सरणी ए की संगत प्रविष्टि को ओवरराइट करके किया जाता है । "जोड़ें" अद्यतन तत्व वार को जोड़कर किया जाता है एक एक सरणी है कि इच्छित स्थान पर छोड़कर शून्य होता है।

:Q        % Implicitly input n. Push array [2 3 ... n+1]. This is the initial array A. 
          % It contains all required positions. Some values will be overwritten
1         % Push 1. This is the initial value for p
y         % Duplicate from below
"         % For each loop. This executes the following n times.
          %   STACK (contents whosn bottom to top): A, p
  XH      %   Copy p into clipboard H
  y       %   Duplicate from below. STACK: A, p, A
  w       %   Swap. STACK: A, A, p
  )       %   Reference indexing. STACK: A, A[p]
  Zp      %   Isprime. STACK: A, false/true
  ?       %   If true (that is, if A[p] is prime)
    5M    %     Push p from automatic clipboard. STACK: A, p
    Q     %     Add 1. STACK: A, p+1
  }       %   Else (that is, if A[p] is not prime)
    1M    %     Push A[p] from automatic clipboard. STACK: A, A[p]
    t     %     Duplicate. STACK: A, A[p], A[p]
    Yf    %     Prime factors, with repetitions. STACK: A, A[p], prime factors of A[p]
    1)    %     Get first element, d. STACK: A, A[p], d
    /     %     Divide. STACK: A, A[p]/d
    H     %     Push p from clipboard H. STACK: A, A[p]/d, p
    (     %     Assignment indexing: write value. STACK: A with A[p] updated
    8M    %     Push d from automatic clipboard.
    y     %     Duplicate from below. STACK: A with A[p] updated, d, A with A[p] updated
    f     %     Find: push indices of nonzero entries.
          %     STACK: A with A[p] updated, d, [1 2 ... n]
    Hq    %     Push p from clipboard H, subtract 1.
          %     STACK: A with A[p] updated, d, [1 2 ... n], p-1
    =     %     Test for equality, element-wise.
          %     STACK: A with A[p] updated, d, [0 ... 0 1 0 ... 0]
    *     %     Multiply, element-wise. STACK: A with A[p] updated, [0 ... 0 d 0 ... 0]
    +     %     Add, element-wise. STACK: A with A[p-1] and A[p] updated
    9M    %     Push p-1 from automatic clipboard.
          %     STACK: A with A[p-1] and A[p] updated, p-1
  ]       %   End if. The stack contains the updated array and index
]         % End for each. Process the next iteration
&         % Specify that the following implicit display function should display only
          % the top of the stack. Implicitly display

— लुइस मेंडो
स्रोत

3

पायथ - 44 बाइट्स

सीधे प्रक्रियात्मक कार्यान्वयन।

K}2hhQVQJ@KZIP_J=hZ).?=GhPJ XKZ/JG=tZ XZKG;Z

टेस्ट सूट ।

— Maltysen
स्रोत

3

PARI / GP, 87 बाइट्स

f(n)=A=[2..9^5];p=1;for(i=1,n,q=factor(A[p])[1,1];if(A[p]-q,A[p]/=q;p--;A[p]+=q,p++));p

सुंदर आत्म-व्याख्यात्मक (गोल्फ-ईश नहीं)। यदि आप f(n)=भाग को नहीं गिनते हैं , तो यह 82 बाइट्स है। आप n->(85 बाइट्स) से भी शुरू कर सकते हैं ।

यह 1-अनुक्रमित भाषा है।

संपादित करें: संशोधन illustrate(n,m)=A=[2..m+1];p=1;for(i=1,n,for(j=1,m,printf("%5s",if(j==p,Str(">",A[j],"<"),Str(A[j]," "))));print();q=factor(A[p])[1,1];if(A[p]!=q,A[p]/=q;p--;A[p]+=q,p++))चींटी के चलने का चित्रण प्रिंट करेगा (एक विस्तृत पर्याप्त टर्मिनल दिया गया है)। उदाहरण के लिए illustrate(150,25), 25 स्तंभों पर पहला 150 चरण इस प्रकार देंगे:

  > 2 <3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2> 3 <4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 3> 4 <5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2> 5 <2 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5> 2 <5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2> 5 <6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 5> 6 <7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2> 7 <3 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7> 3 <7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3> 7 <8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3 7> 8 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3> 9 <4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7> 6 <3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2> 9 <3 3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5> 5 <3 3 3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5> 3 <3 3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3> 3 <3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 3 <4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 3> 4 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 5 <2 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 2 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 2> 9 <10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 5 <3 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 3 <10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 3> 10 <11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 5 <5 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5> 5 <11 12 13 14 15 16 17 18 19 19 21 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 11 <12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5 11> 12 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 13 <6 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5 13> 6 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 15 <3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5> 8 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 7 <4 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 7> 4 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 9 <2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 8 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 7 <4 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 7> 4 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 9 <2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3> 6 <3 2 3 2 5 3 3 14 14 15 16 17 18 19 20 21 22 23 24 25 26
   २ ५ ५> ५ <३ ३ २ ३ २ ५ ३ १३ १४ १५ १ <१ 20 १ 21 १ ९ १ ९ २० २२ २४ २४ २५ २६
   2 5 5 5> 3 <3 2 3 2 5 3 3 14 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3> 3 <2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3> 2 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2> 3 <2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3> 2 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 5 <3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5> 3 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ २ २ ३ ३> १३ <१४ १५ १६ १ 20 १ 21 १ ९ २० २० २२ २३ २४ २५ २६
   2 5 5 5 3 3 2 2 3 5 3 13> 14 <15 16 17 18 19 20 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ २ २ ३ ३> १५ <17 १५ १६ १ 3 १ 21 १ ९ १ ९ २० २२ २३ २४ २४ २६
   2 5 5 5 3 3 2 3 2 5> 6 <5 7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 7 <3 5 7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7> 3 <5 7 15 16 17 18 19 20 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ २ २ ३ ३> ५ <17 १५ १६ १ 3 १ 21 १ 21 १ ९ २० २१ २३ २४ २४ २६
   2 5 5 5 3 3 2 2 2 7 3 5> 7 <15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 7 5 5 7> 15 <16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3 5> 10 <5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3> 7 <5 5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3 7> 5 <5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 7 7 7 5> 5 <16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 7 7 5 5> 16 <17 18 19 20 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ २ २ 7 ३ 7> 17 <19 १ 20 १ 21 १ ९ १ ९ २० २२ २३ २४ २५ २६
   २ ५ ५ ५ ३ ३ २ २ २ 7 ३> 8> 18 <१ 20 १ 21 १ ९ २० २० २२ २३ २४ २५ २६
   2 5 5 5 3 3 2 2 2 7 3 7 5> 9 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3 7> 8 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3> 9 <4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7> 6 <3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 9 <3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3> 5 <3 3 3 4 4 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5> 3 <3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3> 3 <3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3> 3 <4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3> 4 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3> 5 <2 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5> 2 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2> 3 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 5 3 3 2 2> 4 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 3 3 5 2> 5 <2 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 3 3 5 2 5> 2 <17 18 19 19 21 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 5 2> 17 <18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 5 5 2 2 17> 18 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 5 2> 19 <9 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 2 2 19> 9 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 5 2> 22 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 5> 4 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2> 7 <2 11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7> 2 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2> 11 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 11> 3 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 11 3> 19 <20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 5 3 3 2 2 7 2 11 3 19> 20 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 11 3> 21 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 11> 6 <7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2> 13 <3 7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 13> 3 <7 10 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ २ 3 २ १३ ३> 21 <१० २१ २२ २३ २४ २५ २६
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 13 3 7> 10 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 13 3> 9 <5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2 13> 6 <3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 2> 15 <3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7> 5 <5 3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5> 5 <3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5> 3 <3 5 21 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 3 ५ ३> ३ <५ २१ २२ २३ २४ २५ २६
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ २ 3 ५ ३ ३> ५ <२१ २२ २३ २४ २५ २६
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5 3 3 5> 21 <22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 3> 8 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 5 <4 7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 5> 4 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 7 <2 7 22 23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5 3 7> 2 <7 22 23 24 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ ५ ५ ३ ३ २> 23 <२२ २३ २४ २५ २६
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5 3 7 2 7> 22 <23 24 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5 3 7 2> 9 <11 23 24 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ ५ ५ ३ <> ५ <३ ११ २३ २४ २५ २६
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5 3 7 5> 3 <11 23 24 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ ५ ५ ३ ३ ५ ३> ११ <२३ २४ २५ २६
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 3 ५ ५ ३ 11 ३ ११> २३ <२४ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3 11 23> 24 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3 11> 25 <12 25 26
   २ ५ ५ ५ ३ ३ २ ३ ३ ३ ३ ५ २ 5 ५ ५ 3 ५ ३> १६ <५ १२ २५ २६
   २ ५ ५ ५ ३ ३ २ ३ ३ ३ ३ ५ ५ ५ ५ ३ 5> ५ <12 ५ १२ २५ २६
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ २ 5 ५ ५ ५ ५> 5 <५ १२ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 7 <4 5 12 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ ५ ५ ३ ३ ५ 4> ४ <५ १२ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 9 <2 5 12 25 26
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ २ 5 ५ ५ <> 2 <३ २ ५ १२ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 9 <4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 5> 6 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5> 7 <3 3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 3 3 3 5 2 7 5 7> 3 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3> 3 <4 3 2 5 12 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 3 ५ ३ ३> ४ <३ २ ५ १२ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3> 5 <2 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5> 2 <3 2 5 12 25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 7 2 ५ २> ३ <२ ५ १२ २५ २६
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 7 2 ५ ५ २ ३> २ <५ १२ २५ २६
   २ ५ ५ ५ ३ ३ २ ३ ३ ३ ३ ५ २ 7 5 ५ ५ २ ३ २> ५ <१२ २५ २६
   2 5 5 5 3 3 2 3 3 3 5 5 7 7 5 5 3 3 2 2 5 5> 12 <25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 3 2 ५ २ ३ २> 6 <६ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2 7> 6 <25 26
   २ ५ ५ ५ ३ ३ २ ३ ५ ३ ३ ५ २ 7 2 ५ २ ३ २> ९ <३ २५ २६
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ ५ 3 5 ५ २ ३> ५ <३ ३ २५ २६
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5> 3 <3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5 3> 3 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 3 3 5 2 3 5 3 3> 25 <26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5 3> 8 <5 26
   २ ५ ५ ५ ३ ३ २ २ ३ ३ ३ ५ २ 7 3 ५ ५ २ ३ ५> ५ <४ ५ २६

— जेपी स्टिग नीलसन
स्रोत

2

पायथन 2 , 142 127 बाइट्स

शेरलाक 9 की बदौलत पंद्रह बाइट्स बचाए ।

T=range(2,input()+2);p=0
for _ in T:
 m=T[p];d=min(k for k in range(2,m+1)if m%k<1);p+=1
 if d<m:T[p-1]/=d;p-=2;T[p]+=d
print p

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

— जोनाथन फ्रेच
स्रोत

127 बाइट्स यदि आप उपयोग नहीं करते हैंP(n)

— शर्लक

126 बाइट्स

— फेलिप नारदी बतिस्ता

@FelipeNardiBatista दुर्भाग्य से, आपका सुझाव परीक्षण के मामलों के लिए काम नहीं करता हैn<=4

— शर्लक

2

गणितज्ञ, ११hem १०३ बाइट्स

(s=Range[2,5^6];t=1;Do[If[PrimeQ@s[[t]],t++,s[[t]]/=(k=#2&@@ Divisors@s[[t]]);s[[t-1]]+=k;t--],#];t-1)&

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

मार्टिन एंडर ने 15 बाइट बचाए

— J42161217
स्रोत

आप के सामने एक भटका स्थान मिला होगा Divisors , आप के लिए infix संकेतन का उपयोग कर सकते हैं Do, और आप (1-आधारित परिणाम) के tबजाय बस वापस आ सकते हैं t-1।

— मार्टिन एंडर

2

पायथन 3 , 158 149 133 बाइट्स

यह एक या दो quirks के साथ एक सीधी प्रक्रियात्मक कार्यान्वयन है, यह सुनिश्चित करने के लिए कि कोड सभी परीक्षण मामलों के लिए काम करता है। मैं [*range(2,n+9)]यह सुनिश्चित करने के लिए उपयोग करता हूं कि ए काफी बड़ा है (इसके अलावा n<3, n+9पर्याप्त से अधिक है)। elseखंड वर्ष बांटता A[p]द्वारा d, decrements p, और फिर कहते हैं dनया करने के लिए A[p]है, जो निश्चित रूप से बुरा कोडिंग अभ्यास है। अन्यथा, बहुत सीधा। गोल्फ सुझाव का स्वागत करते हैं!

संपादित करें: -9 बाइट्स sympyHalvard Wil के धन्यवाद के बिना । -फेलिप नारदी बतिस्ता से -14 बाइट्स, जोनाथन फ्रेच के पायथन 2 के कुछ संकेतों से -6 बाइट्स

p,_,*A=range(int(input())+2)
for _ in A:
 m=A[p];d=min(k for k in range(2,m+1)if m%k<1);p+=1
 if d<m:A[p-1]//=d;p-=2;A[p]+=d
print(p)

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

— Sherlock9
स्रोत

145 बाइट्स

— हैलवार्ड शेमन्स

148 बाइट्स इसे एक पूर्ण कार्यक्रम बनाकर

— फेलिप नारदी बतिस्ता

if d-m:A[p]...और else:p+=1बाइट बचाने के लिए

— फेलिप नारदी बतिस्ता

elseबयान को हटाकर 143 बाइट्स

— फेलिप नारदी बतिस्ता

elseकथन को हटाने के बाद , फ़ंक्शन संस्करण में बाइट्स में कोई अंतर नहीं है

— फेलिप नारदी बतिस्ता

2

PHP, 102 + 1 बाइट्स

for($a=range(2,$argn);$argn--;$d<$a[+$p]?$a[$p--]/=$d+!$a[$p]+=$d:$p++)for($d=1;$a[+$p]%++$d;);echo$p;

ऑनलाइन के साथ पाइप के रूप में चलाएं -Rया इसे आज़माएं ।

इनपुट के लिए खाली आउटपुट 0; सम्मिलित +करने के बाद echoएक शाब्दिक के लिए0

या इस 1-अनुक्रमित संस्करण (103 + 1 बाइट्स) का उपयोग करें:

for($a=range($p=1,$argn);$argn--;$d<$a[$p]?$a[$p--]/=$d+!$a[$p]+=$d:$p++)for($d=1;$a[$p]%++$d;);echo$p;

— टाइटस
स्रोत

2

आर , 123 बाइट्स

एक सीधा कार्यान्वयन। यह एक फ़ंक्शन के रूप में प्रदान किया जाता है, जो इनपुट के रूप में चाल की संख्या लेता है और स्थिति पी वापस करता है।

यह अनुक्रम पर लूप करता है और पॉइंटर को नियमों के अनुसार आगे और पीछे ले जाता है। आउटपुट 0-आधारित है।

एक नोट: संख्या x का सबसे छोटा अभाज्य गुणक ज्ञात करने के लिए, यह 0 से x के सभी पूर्णांकों के सापेक्ष x के मापांक की गणना करता है। यह फिर 0 के बराबर मापांक के साथ संख्याओं को निकालता है, जो हमेशा [0,1, ..., x] होते हैं। यदि तीसरी ऐसी संख्या x नहीं है, तो यह x का सबसे छोटा अभाज्य गुणनखंड है।

p=function(l){w=0:l;v=w+1;j=1;for(i in w){y=v[j];x=w[!y%%w][3]
if(x%in%c(NA,y))j=j+1
else{v[j]=y/x;j=j-1;v[j]=v[j]+x}}
j-2}

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

— NofP
स्रोत

2

सी (जीसीसी), 152 148 बाइट्स

minified

int f(int n){int*A=malloc(++n*4),p=0,i,q;for(i=0;i<n;i++)A[i]=i+2;for(i=1;i<n;i++){for(q=2;A[p]%q;q++);if(A[p++]>q){A[--p]/=q;A[--p]+=q;}}return p;}

कुछ टिप्पणियों के साथ बनाया गया

int f(int n) {
  int *A = malloc(++n * 4), p = 0, i, q;
  // Initialize array A
  for (i = 0; i < n; i++)
    A[i] = i + 2;
  // Do n step (remember n was incremented)
  for (i = 1; i < n; i++) {
    // Find smallest divisor
    for (q = 2; A[p] % q; q++)
      ;
    if (A[p++] > q) {
      A[--p] /= q;
      A[--p] += q;
    }
  }
  return p;
}

परीक्षण के लिए मुख्य कार्य

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv) {
  if (argc != 2)
    return 2;
  int n = atoi(argv[1]);
  int p = f(n);
  printf("%d => %d\n", n, p);
  return 0;
}

प्रत्येक चरण दिखाने के लिए

डिक्लेयर डिस्प्ले () f (अंदर)

int f(int n) {
  int *A = malloc(++n * 4), p = 0, i, q;
  void display(void) {
    for (int i=0; i < p; i++) {
      printf(" %d", A[i]);
    }
    printf(" \033[1;31m%d\033[m", A[p]);
    if (p+1 < n)
      printf(" %d", A[p+1]);
    printf("\n");
  }
  ...

कॉल प्रदर्शन ()
```
  A[i] = i + 2;
display();
```
कॉल प्रदर्शन ()
```
  }
  display();
}
```

— user285259
स्रोत

आप ए को एक ऐरे के रूप में घोषित करके और कुछ जहां संभव हो, छोरों से पहले अपने लूप नियंत्रण को आरंभीकृत करके कुछ बाइट्स से दाढ़ी बना सकते हैं ?

— मोनिका

1

क्लोजर, 185 बाइट्स

#(loop[[n p][(vec(range 2 1e3))0]i %](if(= i 0)p(recur(if-let[q(first(for[i(range 2(n p)):when(=(mod(n p)i)0)]i))][(assoc n p(/(n p)q)(dec p)(+(n(dec p))q))(dec p)][n(inc p)])(dec i))))

आउच, क्लोजर में एक "राज्य" संपादित करना आदर्श नहीं है। आपको बड़े इनपुट के लिए घातांक बढ़ाने की आवश्यकता होगी।

— NikoNyrh
स्रोत

आपने पैटर्न मिलान का उपयोग क्यों किया loop? आपको इसके बिना कुछ बाइट्स खोने में सक्षम होना चाहिए।

— क्लिम्सिक

इसके अलावा, आप firstएक someबयान में बात को बदलने में सक्षम हो सकते हैं ।

— cl

पैटर्न मिलान के बिना मुझे recurदो बार दोहराना पड़ा , प्रत्येक if-letशाखा के लिए एक । साथ (dec i)ही नकल भी होगी। someएक विधेय की जरूरत है, मैं उपयोग कर सकता हूं +क्योंकि हम संख्याओं के साथ काम कर रहे हैं लेकिन यह एक चरित्र से अधिक लंबा है first। CMIIW

— NikoNyrh

1

जावा 8, 138 135 बाइट्स

n->{int a[]=new int[++n],s=0,p=0,j=0;for(;j<n;a[j++]=j+1);for(;++s<n;p++)for(j=1;++j<a[p];)if(a[p]%j<1){a[p--]/=j;a[p--]+=j;}return p;}

स्पष्टीकरण:

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

n->{                     // Method with integer as both parameter and return-type
  int a[]=new int[++n],  //  Integer-array with a length of `n+1`
      s=0,               //  Steps-counter (starting at 0)
      p=0,               //  Current position (starting at 0)
      j=0;               //  Index integer (starting at 0)
  for(;j<n;              //  Loop (1) from 0 to the input (inclusive due to `++n` above)
    a[j++]=j+1           //   And fill the array with 2 through `n+2`
  );                     //  End of loop (1)
  for(;++s<n;            //  Loop (2) `n` amount of steps:
      p++)               //    And after every iteration: increase position `p` by 1
    for(j=1;             //   Reset `j` to 1
        ++j<a[p];)       //   Inner loop (3) from 2 to `a[p]` (the current item)
      if(a[p]%j<1){      //    If the current item is divisible by `j`:
        a[p--]/=j;       //     Divide the current item by `j`
        a[p--]+=j;}      //     And increase the previous item by `j`
                         //     And set position `p` two steps back (with both `p--`)
                         //   End of inner loop (3) (implicit / single-line body)
                         //  End of loop (2) (implicit / single-line body)
  return p;              //  Return the resulting position `p`
}                        // End of method

— केविन क्रूज़सेन
स्रोत

1

क्लोजर, 198 193 191 बाइट्स

यह गंभीर रूप से गोल्फ होने की जरूरत है ...

#(loop[i(vec(range 2(+ % 9)))c 0 p 0](if(= % c)p(let[d(dec p)u(i p)f(some(fn[n](if(=(mod u n)0)n))(range 2(inc u)))e(= u f)](recur(if e i(assoc i d(+(i d)f)p(/ u f)))(inc c)(if e(inc p)d)))))

गोल्फ 1 : 5 बाइट्स को बदलकर सहेजा (first(filter ...))गया(some ...)

गोल्फ 2 : 2 बाइट्स को बदलकर सहेजा (zero? ...)गया(= ... 0)

उपयोग:

(#(...) 10000) => 512

अघोषित कोड:

(defn prime-ant [n]
  (loop [counter 0
         pos 0
         items (vec (range 2 (+ n 9)))]
    (if (= n counter) pos
      (let [cur-item (nth items pos)
            prime-factor
            (some #(if (zero? (mod cur-item %)) %)
              (range 2 (inc cur-item)))
            equals? (= cur-item prime-factor)]
        (recur
          (inc counter)
          (if equals? (inc pos) (dec pos))
          (if equals? items
            (assoc items
              (dec pos) (+ (items (dec pos)) prime-factor)
              pos (/ cur-item prime-factor))))))))

— clismique
स्रोत

मुख्य चींटी 🐜

ऐलिस , 45 बाइट्स

पायथन 2 , 120 बाइट्स

ऑक्टेव , 109 103 101 94 बाइट्स

MATLAB, 130 123 118 117 बाइट्स

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

डेमो

हास्केल , 108 106 94 बाइट्स

टीआई-बेसिक, 108 103 102 98 बाइट्स

MATL , 41 बाइट्स

व्याख्या

पायथ - 44 बाइट्स

PARI / GP, 87 बाइट्स

पायथन 2 , 142 127 बाइट्स

गणितज्ञ, ११hem १०३ बाइट्स

पायथन 3 , 158 149 133 बाइट्स

PHP, 102 + 1 बाइट्स

आर , 123 बाइट्स

सी (जीसीसी), 152 148 बाइट्स

minified

कुछ टिप्पणियों के साथ बनाया गया

परीक्षण के लिए मुख्य कार्य

प्रत्येक चरण दिखाने के लिए

क्लोजर, 185 बाइट्स

जावा 8, 138 135 बाइट्स

क्लोजर, 198 193 191 बाइट्स

उपयोग:

अघोषित कोड: