50

"프라임 개미"는 정수를 탐색하고 소수만 남을 때까지 정수를 나누는 완고한 동물입니다!

처음에는 모든 정수> = 2를 포함하는 무한 배열 A가 있습니다. [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

나는 Hot Network Questions에서 이것을 보았을 때 스크린에 개미가 있다고 생각했다.

— Kodos Johnson

14

순서가 임의로 정의되어 n있는지 (또는 복합 케이스가 개미를 초기의 왼쪽으로 밀어 넣을 수 있는지) 궁금합니다 2.

— Martin Ender

1

@SuperChafouin이므로 테스트 사례의 출력은 다음과 같습니다. 1,7,10,275,5131- 인덱싱이 명시된 경우? 또는 여전히 출력과 일치해야합니다.

— Tom Carpenter

12

@MartinEnder 또 다른 열린 질문은 프라임> 7이 결국에 남을 수 있는지 여부입니다.

— Arnauld

2

@Arnauld 이동 n = 1,000,000,000 (여기서 p = 17156661)까지 n과 p의 관계는 p = n / (ln (n) * ln (ln (n)))에 매우 가깝습니다.

— Penguino

11

Alice , 45 바이트

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

온라인으로 사용해보십시오!

대부분 간단한 구현입니다.

nAlice의 루핑 시간은 일반적으로 리턴 주소 n-1시간 을 푸시 한 다음을 사용하여 각 반복의 끝에 리턴하여 수행됩니다 k. 루프를 통과 한 마지막 시간에는 k명령이 돌아갈 곳이없고 실행이 진행됩니다.

이 프로그램은 동일한 k명령어를 사용하여 숫자가 소수 일 때 일찍 중지합니다. 결과적으로 최종 반복은 항상 개미를 왼쪽으로 이동시킵니다. 이 버그를 보상하기 위해 n+11- 인덱스 배열에서 반복을 수행하여 원하는 결과를 정확하게 제공합니다 ( n=0무료로 제공).

— 니트로 돈
소스

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 경우에만 실행됩니다 . 우리의 경우에, 이것은 우리가 모든 s를 점검 했고 그것들 중 어느 것도 나누지 않았다는 것을 의미 합니다 .forbreakqp

— 린
소스

7

옥타브 , 109103101 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

이 버전은 일부 Octave 최적화를 사용하므로 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

Octave 버전과 마찬가지로 1- 인덱싱을 사용합니다. MATLAB의 모든 테스트 사례에 대해 테스트했습니다. 예를 들어 100000의 출력은 3675 (1 인덱싱)입니다.

위 코드의 주석이 달린 버전 :

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

관심의 대상으로, 이것은 n의 첫 10000 값에 대한 개미 위치 대 반복 횟수입니다.

개미는 아마도 무한한 경향이있을 것 같지만, 알고있는 사람은기만 할 수 있습니다.

MATLAB : 대괄호를 제거하는 for대신 6 바이트를 절약 while했습니다. if-Thanks @Giuseppe
MATLAB : 2 바이트 저장-감사합니다 @Sanchises
옥타브 : 옥타브 \=와 +=연산 을 사용하여 10 바이트 절약 -Thanks @Giuseppe
옥타브 : 2 바이트를 저장 i++하고 i--- 감사 @LuisMendo
옥타브 : 7 바이트 저장-감사합니다 @Sanchises

— 톰 카펜터
소스

TIO에서 작동하려면 end함수 시그니처와 일치 해야한다고 생각합니다.

— Giuseppe

@ 주세페 아, 알았어. MATLAB에서 후행 end은 선택 사항입니다.

— Tom Carpenter

함수 i = a (n) 대신 @ (n)을 사용하여 익명 함수를 만들 수 있습니다.

— Michthan

@Michthan은 MATLAB에서 그렇게 할 수 없습니다. 루프가 있기 때문에 옥타브에서도 가능하지 않다고 생각합니까?

— Tom Carpenter

1

end옥타브에서도 후행 은 선택 사항입니다. 여기에는 함수 뒤에 코드가 있기 때문에 필요합니다.

— Luis Mendo

6

자바 스크립트 (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

데모

주의 : 모든 테스트 사례를 통과하려면 엔진의 기본 스택 크기를 늘려야 할 수도 있습니다.

온라인으로 사용해보십시오!

— 아르나 울드
소스

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입력이 주어지면 th 위치가 리턴 되는 무한 위치 목록을 구성합니다 n.

이 패턴 ((a:b)#(p:q))은 p개미의 현재 위치 a값과 이전 위치 값에 바인딩 됩니다 . b행 1의 위치에서 상기 어레이의 접두사 p-2및 q위치부터 무한 나머지 p+1.

우리는 다음과 같은 방식으로 재귀 호출 목록을 구성합니다. 우리 d는 p(1보다 크고 작은 p)의 제수 를 오름차순으로보고 b#(a+d:div p d:q)각각에 대해 더합니다. 즉, 현재 값 p을 나눈 값 d과 개미 이동 왼쪽에 한 단계 d가 추가됩니다 a. 그런 다음 (p:a:b)#q이 목록의 끝에 추가 하여 개미가 한 단계 오른쪽으로 이동 함을 나타냅니다.

그런 다음 목록에서 해당 재귀 호출 중 첫 번째를 가져 와서 현재 위치 앞에 붙습니다 b. 이 위치는 접두사 목록의 길이와 일치합니다 . 제수가 오름차순이므로 재귀 호출 목록에서 첫 번째를 선택하면 가장 작은 것을 사용할 수 있습니다. 또한 (p:a:b)#q목록 끝에 추가 p되므로 제수가없는 경우에만 선택 되므로 소수입니다.

편집 :
기능 목록을 내림차순에서 오름차순으로 전환하여 -2 바이트
카운터를 처리하지 않고 0 인덱싱으로 전환하여 무한 목록으로 인덱싱하는 Zgarb의 아이디어 덕분에 -12 바이트.

— 라이 코니
소스

2

카운터를 옮기는 대신 무한 목록과 색인 생성을 통해 96 바이트 .

— Zgarb

1

@ Zgarb 감사합니다! 0 인덱싱으로 전환 할 때조차 94 바이트입니다.

— Laikoni

5

TI-BASIC, 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

— 카 모로소 94
소스

당신은 떨어져 바이트를 취할 수 fPart(∟A(P)/F:와 fPart(F¹∟A(P:. 다음 줄에서도 마찬가지입니다.

— Scott Milner

@ScottMilner 항상 작동하지는 않습니다. not(fPart(7⁻¹70이지만 not(fPart(7/71입니다.

— kamoroso94

5

MATL , 41 바이트

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

출력은 1 기반입니다. 온라인 통역사의 마지막 테스트 사례에 대한 프로그램 시간이 초과되었습니다.

온라인으로 사용해보십시오!

설명

프로그램은 챌린지에 설명 된 절차를 적용합니다. 이를 위해 MATL의 수동 및 자동 클립 보드를 비정상적으로 많이 사용합니다.

가장 작은 제수는 소인수 분해의 첫 번째 항목으로 구합니다.

"분할"업데이트는 배열 A 의 해당 항목을 덮어 써서 수행됩니다 . "추가"업데이트 소자 현명한에 첨가함으로써 수행된다 원하는 위치에서를 제외하고 0을 포함하는 배열.

: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

테스트 스위트 .

— 말 티센
소스

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

— 제프 스티 그 닐슨
소스

2

파이썬 (2) , 142 (127) 바이트

Sherlock9 덕분에 15 바이트를 절약했습니다 .

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)

— Sherlock9

126 바이트

— 펠리페 나디 바티스타

@FelipeNardiBatista 불행히도, 귀하의 제안은 테스트 케이스에 적용되지 않는 것 같습니다n<=4

— Sherlock9

2

Mathematica, 118103 바이트

(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대한 표기법을 사용할 Do수 있으며 t대신 t-1(1 기반 결과) 대신 반환 할 수 있습니다 .

— Martin Ender

2

파이썬 (3) , 158 (149) 133 바이트

이것은 코드가 모든 테스트 케이스에서 작동하는지 확인하기 위해 하나 또는 두 개의 쿼크가있는 간단한 절차 구현입니다. 내가 사용 [*range(2,n+9)](를 제외하고 크기가 충분한 지 확인하기 위해 n<3, n+9충분한 이상입니다). 이 else절은 old A[p]를 d, decrements로 나눈 p다음 dnew에 추가 합니다. A[p]이는 분명히 나쁜 코딩 관행입니다. 그렇지 않으면 매우 간단합니다. 골프 제안을 환영합니다!

편집 :sympy Halvard Hummel 덕분에 -9 바이트 . Felipe Nardi Batista에서 -14 바이트, Jonathan Frech의 Python 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)

온라인으로 사용해보십시오!

— 셜록 9
소스

145 바이트

— Halvard Hummel

전체 프로그램으로 148 바이트

— Felipe Nardi Batista

if d-m:A[p]...그리고 else:p+=1바이트 저장

— 펠리페 나르디 바티스타

else명령문 을 제거하여 143 바이트

— Felipe Nardi Batista

, 제거 후 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; 리터럴 +후 삽입echo0

또는이 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

R , 123 바이트

간단한 구현. 이동 횟수를 입력으로 받아 위치 p를 반환하는 함수로 제공됩니다.

시퀀스를 반복하고 규칙에 따라 포인터를 앞뒤로 움직입니다. 출력은 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

C (GCC), 152 (148) 바이트

축소

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 () 안에 display () 선언

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();
}
```

— 사용자
소스

A를 배열로 선언하고 가능한 경우 루프 전에 루프 제어를 초기화하여 일부 바이트 를 줄일 수 있습니다 .

— Monica Monica 복원

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

"주"를 편집하는 것은 Clojure에서 이상적이지 않습니다. 더 큰 입력을 위해서는 지수를 늘려야합니다.

— 니코 니르
소스

에서 패턴 일치를 사용한 이유는 무엇 loop입니까? 그것없이 몇 바이트를 잃을 수 있어야합니다.

— clismique

또한 first사물을 some진술 로 변경할 수도 있습니다 .

— clismique

패턴 일치가 없으면 recur각 if-let분기 마다 하나씩 두 번 반복해야했습니다 . 또한 (dec i)복제됩니다. 우리가 숫자를 다룰 때 some사용할 수있는 술어가 필요 +하지만 이것은 1 자보다 깁니다 first. CMIIW

— NikoNyrh

1

자바 8, 138135 바이트

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

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 :로 변경 (first(filter ...))하여 5 바이트 저장(some ...)

Golf 2 :로 변경 (zero? ...)하여 2 바이트 저장(= ... 0)

용법:

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

Ungolfed 코드 :

(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
소스

주요 개미 🐜

Alice , 45 바이트

파이썬 2 , 120 바이트

옥타브 , 109103101 94 바이트

MATLAB, 130 123 118 117 바이트

자바 스크립트 (ES6), 91 바이트

데모

하스켈 , 108 (106) 94 바이트

TI-BASIC, 108 (103) 102 98 바이트

MATL , 41 바이트

설명

Pyth-44 바이트

PARI / GP, 87 바이트

파이썬 (2) , 142 (127) 바이트

Mathematica, 118103 바이트

파이썬 (3) , 158 (149) 133 바이트

PHP, 102 + 1 바이트

R , 123 바이트

C (GCC), 152 (148) 바이트

축소

일부 의견으로 형식화

테스트를위한 주요 기능

각 단계를 보여주기 위해

클로저, 185 바이트

자바 8, 138135 바이트

Clojure에서, 198 (193) 191 바이트

용법:

Ungolfed 코드 :