50

"มดหลัก" เป็นสัตว์ดื้อรั้นที่นำทางจำนวนเต็มและหารพวกมันจนกว่าจะเหลือเฉพาะช่วงเวลาเท่านั้น!

เริ่มแรกเรามีอาร์เรย์อนันต์ A ที่มีจำนวนเต็มทั้งหมด> = 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

— Arnaud
แหล่งที่มา

32

ฉันคิดอย่างสุจริตว่ามีมดบนหน้าจอของฉันเมื่อฉันเห็นสิ่งนี้ในคำถามเครือข่ายที่น่าสนใจ

— Kodos Johnson

14

ฉันสงสัยว่าลำดับนั้นถูกกำหนดไว้อย่างชัดเจนสำหรับขนาดใหญ่โดยพลการnหรือไม่หรือว่าเคสคอมโพสิตสามารถผลักมดไปทางซ้ายของเริ่มต้น2ได้หรือไม่

— Martin Ender

1

@ SuperChafouin ดังนั้นผลลัพธ์ของกรณีทดสอบอาจเป็น: 1,7,10,275,513หากมีการระบุ 1 ดัชนี? หรือพวกเขาจะยังคงต้องตรงกับผลลัพธ์ของคุณ

— Tom Carpenter

12

@ มาร์ตินเอนเดอร์คำถามที่เปิดกว้างอีกข้อคือว่าในที่สุดคนที่ดีกว่า 7 คนสามารถถูกทิ้งไว้ให้ดีได้หรือไม่

— Arnauld

2

@Annauld ออกไปไกลเท่าที่ย้าย n = 1,000,000,000 (โดยที่ p = 17156661) ความสัมพันธ์ระหว่าง n และ p อยู่ใกล้กับ p = n / (ln (n) * ln (ln (n))

— Penguino

11

อลิซ 45 ไบต์

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

ลองออนไลน์!

การใช้งานที่ตรงไปตรงมาเป็นส่วนใหญ่

วนรอบnครั้งในอลิซมักจะกระทำโดยการผลักดันที่อยู่กลับมาครั้งจากนั้นกลับมาในตอนท้ายของแต่ละซ้ำด้วยn-1 kครั้งสุดท้ายที่ผ่านลูปkคำสั่งไม่มีที่ใดที่จะกลับไปและการดำเนินการจะดำเนินต่อไป

โปรแกรมนี้ใช้kคำสั่งเดียวกันเพื่อหยุด แต่เนิ่น ๆ เมื่อจำนวนนั้นเป็นจำนวนเฉพาะ ดังนั้นการวนซ้ำครั้งสุดท้ายจะเลื่อนมดไปทางซ้ายเสมอ เพื่อชดเชยข้อผิดพลาดนี้เราทำการn+1วนซ้ำในอาร์เรย์ที่มีการจัดทำดัชนี 1 ซึ่งให้ผลลัพธ์ตรงตามที่เราต้องการ (และมอบเคสn=0ฟรี)

— Nitrodon
แหล่งที่มา

7

Python 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เดินออกมาจากทาง ในกรณีของเรานี้หมายถึงการที่เราตรวจสอบทั้งหมดและพบว่าไม่มีของพวกเขาที่จะแบ่งqp

— ลินน์
แหล่งที่มา

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 เช่นเดียวกับรุ่น Octave ฉันได้ทดสอบกับกรณีทดสอบทั้งหมดใน MATLAB เป็นตัวอย่างเอาต์พุตที่ 100,000 คือ 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

ตามความสนใจนี่คือตำแหน่งมดเทียบกับจำนวนการวนซ้ำสำหรับ 10,000 ค่าแรกของ n

ดูเหมือนว่ามีแนวโน้มว่ามดจะมีแนวโน้มที่จะไม่มีที่สิ้นสุด แต่ใครจะรู้ว่ารูปลักษณ์สามารถหลอกลวง

MATLAB: บันทึก 6 ไบต์ด้วยforแทนที่จะใช้whileและลบเครื่องหมายวงเล็บออกif- ขอบคุณ @Giuseppe
MATLAB: บันทึก 2 ไบต์ - ขอบคุณ @Sanchises
ระดับแปดเสียง: บันทึก 10 ไบต์โดยใช้ระดับเสียง\=และ+=การดำเนินการ - ขอบคุณ @Giuseppe
อ็อกเทฟ: บันทึก 2 ไบต์ด้วยi++และi--- ขอบคุณ @LuisMendo
อ็อกเทฟ: บันทึก 7 ไบต์ - ขอบคุณ @Sanchises

— ทอมคาร์เพนเตอร์
แหล่งที่มา

เพื่อให้มันทำงานบน TIO ฉันคิดว่าคุณต้องendตรงกับลายเซ็นของฟังก์ชั่น

— Giuseppe

@Giuseppe อ่าโอเค ใน MATLAB การติดตามendเป็นทางเลือก

— Tom Carpenter

คุณสามารถสร้างฟังก์ชั่นที่ไม่ระบุชื่อได้โดยใช้ @ (n) ในตอนเริ่มต้นแทนที่จะใช้ฟังก์ชั่น i = a (n)

— Michthan

@Michthan ไม่สามารถทำได้ใน MATLAB ฉันไม่คิดว่ามันเป็นไปได้ใน Octave ทั้งที่มีลูป?

— Tom Carpenter

1

ส่วนท้ายendเป็นทางเลือกใน Octave ด้วยเช่นกัน ที่นี่มีความจำเป็นเพียงเพราะคุณมีรหัสหลังจากฟังก์ชั่น

— Luis Mendo

6

JavaScript (ES6), 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

Haskell , 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ตำแหน่ง TH nจะถูกส่งกลับได้รับการป้อนข้อมูล

รูปแบบ((a:b)#(p:q))ผูกpกับค่าของตำแหน่งปัจจุบันของมดและaค่าที่เป็นตำแหน่งก่อนหน้า bเป็นคำนำหน้าของอาร์เรย์จากตำแหน่ง 1 ไปp-2และส่วนที่เหลือไม่มีที่สิ้นสุดเริ่มต้นจากตำแหน่งqp+1

เราสร้างรายการการเรียกซ้ำโดยวิธีต่อไปนี้: เราดูตัวหารแต่ละตัวdของp(ซึ่งใหญ่กว่าหนึ่งและเล็กกว่าp) ตามลำดับจากน้อยไปหามากและเพิ่มb#(a+d:div p d:q)สำหรับแต่ละสายนั่นคือค่าปัจจุบันpถูกหารด้วยdและการเคลื่อนไหวของมด ขั้นตอนหนึ่งไปทางซ้ายที่จะถูกเพิ่มd aจากนั้นเราจะผนวก(p:a:b)#qส่วนท้ายของรายการนี้ซึ่งบ่งชี้ว่ามดเคลื่อนที่หนึ่งก้าวไปทางขวา

จากนั้นเราจะใช้เป็นครั้งแรกของการโทร recursive bเหล่านั้นออกจากรายการและย่อหน้าตำแหน่งปัจจุบันซึ่งเกิดขึ้นพร้อมกับความยาวของรายการคำนำหน้า เนื่องจากตัวหารอยู่ในลำดับจากน้อยไปมากการเลือกสายแรกจากรายการการโทรซ้ำเพื่อให้แน่ใจว่าเราใช้สายที่เล็กที่สุด นอกจากนี้เนื่องจาก(p:a:b)#qถูกเพิ่มลงในส่วนท้ายของรายการจึงจะถูกเลือกก็ต่อเมื่อไม่มีตัวหารและpเป็นตัวเลือกที่ดีที่สุด

Edits:
-2 bytes โดยสลับรายการของฟังก์ชั่นจากมากไปหาน้อยเป็นลำดับขึ้น
-12 ไบต์ขอบคุณแนวคิดของ Zgarb ที่จะจัดทำดัชนีลงในรายการที่ไม่มีที่สิ้นสุดแทนการจัดการตัวนับและโดยสลับไปที่การทำดัชนี 0 รายการ

— Laikoni
แหล่งที่มา

2

96 ไบต์โดยการสร้างรายการและการทำดัชนีไม่ จำกัด แทนที่จะถือรอบตัวนับ

— Zgarb

1

@Zgarb ขอบคุณมาก! มีขนาดเพียง 94 ไบต์เมื่อเปลี่ยนเป็นดัชนี 0

— Laikoni

5

TI-BASIC, 108 103 102 98 ไบต์

input และ output 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:สิ่งเดียวกันในบรรทัดถัดไป

— Scott Milner

@ScottMilner ไม่ได้ผลเสมอไป not(fPart(7⁻¹7เป็น 0 แต่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

Pyth - 44 ไบต์

การดำเนินการตามขั้นตอนที่ตรงไปตรงมา

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

Test Suite

— 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

สวยอธิบายตนเอง (ไม่ใช่กอล์ฟ - ish) หากคุณไม่นับชิ้น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)จะให้ 150 ขั้นตอนแรกใน 25 คอลัมน์เช่นนี้

  > 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 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 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 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 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 2> 2 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 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 2 2 3 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> 15 <7 15 16 17 18 19 20 21 22 23 24 25 26
   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
   2 5 5 5 3 3 2 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
   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 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 3 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 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 3 2 7 3 7 5> 7 <8 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2 7 3 7 5 7> 8 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5> 9 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 7 7> 8 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 3 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 3 7 7> 6 <3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 2> 9 <3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2> 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 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> 5 <2 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5> 2 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2> 3 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 3> 4 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 5 5 3 3 5 2> 5 <2 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5> 2 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 5 5 3 3 5 2 5 2> 17 <18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2 17> 18 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2> 19 <9 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2 19> 9 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 2 5 5 3 3 5 2 5 2> 22 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5> 4 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2> 7 <2 11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7> 2 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2> 11 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11> 3 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11 3> 19 <20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11 3 19> 20 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11 3> 21 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11> 6 <7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2> 13 <3 7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13> 3 <7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13 3> 7 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13 3 7> 10 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13 3> 9 <5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13> 6 <3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2> 15 <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 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 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 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 <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> 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 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 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 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 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 5 3 3 5 2 7 5 5 3 7 2> 9 <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 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 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 <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> 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 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
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3> 16 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 5 <8 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 5> 8 <5 12 25 26
   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
   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
   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
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7> 8 <3 2 5 12 25 26
   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 5 3 3 5 2 7 5 5> 6 <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
   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
   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
   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
   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
   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
   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
   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
   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
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2> 9 <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 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 7 3 5 2 3 5 3 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
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5> 5 <4 5 26

— Jeppe Stig Nielsen
แหล่งที่มา

2

Python 2 , 142 127 ไบต์

ที่บันทึกไว้สิบห้าไบต์ขอบคุณที่Sherlock9

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

ลองออนไลน์!

— Jonathan Frech
แหล่งที่มา

127 ไบต์ถ้าคุณไม่ได้ใช้P(n)

— Sherlock9

126 bytes

— Felipe Nardi Batista

@FelipeNardiBatista น่าเสียดายที่คำแนะนำของคุณดูเหมือนจะไม่ทำงานสำหรับกรณีทดสอบn<=4

— Sherlock9

2

Mathematica, 118 103 ไบต์

(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)&

ลองออนไลน์!

Martin Ender บันทึก 15 ไบต์

— J42161217
แหล่งที่มา

คุณจะมีพื้นที่จรจัดอยู่ตรงหน้าDivisorsคุณสามารถใช้สัญกรณ์มัดสำหรับDoและคุณสามารถส่งคืนtแทนt-1(ผลลัพธ์ 1 รายการ)

— Martin Ender

2

Python 3 , 158 149 133 ไบต์

นี่คือการดำเนินการตามขั้นตอนที่ตรงไปตรงมากับหนึ่งหรือสองนิสัยใจคอเพื่อให้แน่ใจว่ารหัสที่ใช้งานได้สำหรับกรณีทดสอบทั้งหมด ฉันจะใช้[*range(2,n+9)]เพื่อให้แน่ใจว่ามีขนาดใหญ่พอ (ยกเว้นn<3, n+9เป็นมากกว่าเพียงพอ) elseข้อแบ่งเก่าA[p]โดยd, การลดลงpและจากนั้นจะเพิ่มdไปอยู่ที่ใหม่A[p]ซึ่งเป็นวิธีการเข้ารหัสที่ไม่ดีแน่นอน มิฉะนั้นตรงไปตรงมาสวย ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ!

แก้ไข: -9 ไบต์โดยไม่ต้องsympyขอบคุณ Halvard Hummel -14 bytes จาก Felipe Nardi Batista, -6 bytes จากตัวชี้นำบางส่วนจากPython 2 ของ Jonathan Frech

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 ไบต์

— Halvard Hummel

148 bytesโดยทำให้เป็นโปรแกรมเต็ม

— Felipe Nardi Batista

if d-m:A[p]...และelse:p+=1บันทึกไบต์

— Felipe Nardi Batista

143 bytesโดยลบelseข้อความ

— Felipe Nardi Batista

หลังจากลบelseคำสั่งไม่มีความแตกต่างเป็นไบต์กับรุ่นของฟังก์ชัน

— Felipe Nardi Batista

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

หรือใช้เวอร์ชันที่มีการจัดทำดัชนีนี้ (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

R , 123 ไบต์

การดำเนินการที่ตรงไปตรงมา มันมีไว้เป็นฟังก์ชั่นซึ่งใช้จำนวนของการเคลื่อนไหวเป็นอินพุตและส่งกลับตำแหน่ง p

มันวนซ้ำไปมาตามลำดับและเลื่อนตัวชี้ไปมาและกลับตามกฎ ผลลัพธ์เป็น 0

หมายเหตุ: เพื่อค้นหาตัวประกอบสำคัญที่เล็กที่สุดของตัวเลข x จะคำนวณโมดูลัสของ x เทียบกับจำนวนเต็มทั้งหมดตั้งแต่ 0 ถึง 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

C (gcc), 152 148 bytes

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
แหล่งที่มา

คุณสามารถโกนไบต์บางตัวออกได้โดยประกาศ A เป็นอาร์เรย์และเริ่มต้นการควบคุมลูปของคุณก่อนลูปถ้าเป็นไปได้ใช่ไหม?

— Reinstate Monica

1

Clojure, 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))))

ดังนั้นการแก้ไข "สถานะ" ไม่เหมาะใน Clojure คุณจะต้องเพิ่มเลขยกกำลังสำหรับอินพุตที่ใหญ่ขึ้น

— NikoNyrh
แหล่งที่มา

ทำไมคุณถึงใช้รูปแบบการจับคู่ในloop? คุณควรจะสามารถสูญเสียไม่กี่ไบต์โดยที่

— clismique

นอกจากนี้คุณอาจสามารถเปลี่ยนfirstสิ่งที่เป็นsomeคำสั่ง

— clismique

หากไม่มีการจับคู่รูปแบบฉันต้องทำซ้ำrecurสองครั้งสำหรับแต่ละif-letสาขา นอกจากนี้ยัง(dec i)จะมีการทำซ้ำ someต้องการคำกริยา, ฉันสามารถใช้+ในขณะที่เรากำลังเผชิญกับตัวเลข firstแต่นี้เป็นตัวละครตัวหนึ่งนานกว่า CMIIW

— NikoNyrh

1

Java 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

— Kevin Cruijssen
แหล่งที่มา

1

Clojure, 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
แหล่งที่มา

มดสำคัญ prime

อลิซ 45 ไบต์

Python 2 , 120 ไบต์

อ็อกเทฟ , 109 103 101 94 ไบต์

MATLAB, 130 123 118 117 ไบต์

JavaScript (ES6), 91 ไบต์

การสาธิต

Haskell , 108 106 94 ไบต์

TI-BASIC, 108 103 102 98 ไบต์

MATL , 41 ไบต์

คำอธิบาย

Pyth - 44 ไบต์

PARI / GP, 87 ไบต์

Python 2 , 142 127 ไบต์

Mathematica, 118 103 ไบต์

Python 3 , 158 149 133 ไบต์

PHP, 102 + 1 ไบต์

R , 123 ไบต์

C (gcc), 152 148 bytes

minified

จัดทำขึ้นด้วยความคิดเห็นบางส่วน

ฟังก์ชั่นหลักสำหรับการทดสอบ

สำหรับการแสดงแต่ละขั้นตอน

Clojure, 185 ไบต์

Java 8, 138 135 ไบต์

Clojure, 198 193 191 ไบต์

การใช้งาน:

รหัสไม่ได้รับการตอบกลับ: