무한 소수 목록으로 시작한다고 가정 해보십시오.

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, ...

그런 다음 각 숫자 쌍 사이의 절대 차이를 반복적으로 가져옵니다.

[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, ...
[1, 0, 2, 2, 2, 2, 2, 2, 4, 4, 2, 2, 2, 2, 0, 4, 4, 2, ...
[1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 4, 0, 2, ...
[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

맨 앞의 숫자는 1입니다. Gilbreath의 추측 은 이것이 영원히 계속 될 것이라는 예측입니다.

선행 숫자가 1이되는 유일한 방법은 다음 숫자가 0이나 2가 아닌 경우입니다. 두 번째 숫자가 0이 아니거나 2가 아닌 유일한 방법은 그 이후의 숫자가 0 또는 2. 등등.

0이나 2가 아닌 선행 1 이외의 가장 빠른 수의 인덱스는 연속적인 시퀀스 쌍 사이에서 절대로 1 이상 내려갈 수 없습니다. 이 사실은 시퀀스가 ​​첫 번째 요소로 1을 갖지 않을 때 매우 강한 하한을 설정하는 데 사용되었습니다.

이 도전에서, 당신은 시퀀스의 인덱스를 받게 될 것이고, 당신은 그 시퀀스에서 첫 번째 숫자의 인덱스를 선행 1이 아니고 0 또는 2가 아닌 것으로 출력해야합니다.

예를 들어, 위의 네 번째 절대 차 시퀀스에서 :

[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

첫 번째 항목 이외의 0 또는 2가 아닌 첫 번째 항목은 15 번째 위치이며 14는 0입니다. 따라서 입력이 4이면 14를 출력합니다.

1에서 30까지의 입력의 경우 출력은 다음과 같아야합니다.

[3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176, 176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

이다 OEIS A000232 .

이것은 1 개의 인덱싱 된 입력과 0 개의 인덱싱 된 출력이 있다고 가정합니다. 모든 시퀀스에 해당하는 입력 범위를 허용 할 수있는 한 상수 정수에서 시작하여 입력 및 출력을 색인화 할 수 있습니다.

요구 사항 : 최대 30 분의 입력으로 솔루션을 최대 1 분 동안 실행해야합니다. 컴퓨터 사양에 따라 충분히 가까운 경우 허용됩니다.

가장 짧은 코드가 승리합니다.

젤리 , 17 바이트

ÆNạ2\Ḋ¿Ḣ’Ị
R‘ÇпL

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

입력은 2- 인덱싱입니다. 출력은 1- 인덱싱입니다.

TIO에서 모든 테스트 케이스의 총 개수는 22.309 초입니다.

매스 매 티카, 66 바이트

(For[z=1,Last@Nest[Abs@*Differences,Array[Prime,z+#],#]<3,z++];z)&

양의 정수를 인수로 사용하고 1 색인 정수를 리턴하는 순수 함수. 첫 번째 소수 목록의 반복 된 절대 차이 목록을 Nest[Abs@*Differences,Array[Prime,z+#],#]계산합니다 . 결과 목록의 마지막 요소가 적어도가 될 때까지이 계산을 반복 한 다음 출력됩니다. (알고리즘의 정확성은 Gilbreath의 추측을 가정합니다!)#z+#For[z=1,Last@...<3,z++]3z

Pyth , 32 바이트

-l.W>3h.WtHaVZtZ>QH+ZfP_TheZ.fP_

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

2- 인덱싱을 사용합니다.

MATL , 18 바이트

`@:YqG:"d|]3<A}@G-

입력 및 출력은 1 기반입니다. 각 테스트 사례에 대해 TIO에서 40 초 미만이 소요됩니다.

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

설명

이것은 반복 된 절대 연속 차이가 적어도 하나 이상의 값을 초과 할 때까지 더 긴 초기 소수 시퀀스를 계속 시도합니다 2.

`        % Do... while loop
  @:Yq   %   Array of first k primes, where k is iteration index
  G:"    %   Do this as many times as the input
    d|   %     Absolute value of consecutive differences
  ]      %   End
  3<A    %   Are they all less than 3? This is the loop condition
}        % Finally (execute before exiting loop)
  @G-    %   Push last iteration index minus input. This is the output
         % End (implicit). Continue with next iteration if top of stack is true
         % Display (implicit)

펄 6 , 136120 바이트

{->\i,\n{i??&?BLOCK(i-1,lazy
n.rotor(2=>-1).map: {abs .[1]-.[0]})!!1+n.skip.first:
:k,none 0,2}($_,grep &is-prime,2..*)}

언 골프 드 :

{   # Anonymous function with argument in $_
    sub f(\i, \n) {  # Recursive helper function
        if i != 0 {  # If we're not done,
            # Recurse on the absolute differences between adjacent entries:
            f(i - 1, lazy n.rotor(2 => -1).map: { abs .[1] - .[0] });
        } else {
            # Otherwise, return the first index after 0
            # where the value is neither 0 nor 2.
            1 + n.skip.first: :k, none 0, 2;
        }
    }
    # Call the helper function with the argument passed to the top-level
    # anonymous function (the recursion depth), and with the prime numbers
    # as the initial (infinite, lazy) list:
    f($_, grep &is-prime, 2 .. *);
}

30을 입력하면 겸손한 랩톱에서 약 4 초 안에 기능이 실행됩니다.

... 7 개월 된 Perl 6 설치를 업그레이드 한 후 1.4 초가되었습니다 ( skip첫 번째 솔루션에서 몇 바이트를 줄일 수 있는 방법 도 제공 합니다). 1에서 30까지의 모든 테스트 사례는 약 10 초가 걸립니다.

하스켈 , 94 바이트

f(a:b:r)=abs(a-b):f(b:r)
length.fst.span(<3).(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)

온라인으로 사용해보십시오! 마지막 줄은 익명 함수입니다. 바인딩 예하기 g및 전화 등g 4 . TIO에서 모든 테스트 사례가 2 초 이내에 완료됩니다.

작동 원리

[n|n<-[2..],all((>0).mod n)[2..n-1]]무한 소수 목록을 생성합니다.
f(a:b:r)=abs(a-b):f(b:r)무한 목록 요소의 절대적인 차이를 산출하는 함수입니다. 숫자를 감안할 때 n, (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)적용 f n소수의 목록에 시간을. length.fst.span(<3)요소가 더 작은 결과 목록의 접두사 길이를 계산합니다 .3.

공리, 289 바이트

g(n:PI):PI==(k:=n*10;c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)];repeat(a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)]);j:=0;c:=a;repeat(j=n=>break;j:=j+1;b:=a;a:=[abs(b.(i+1)-b.i)for i in 1..(#b-1)]);j:=2;repeat(j>#a=>break;a.j~=2 and a.j~=1 and a.j~=0=>return j-1;j:=j+1);k:=k*2))

그것을 풀고 테스트

f(n:PI):PI==
  k:=n*10
  c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)]
  repeat
    a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)])
    j:=0;c:=a
    repeat
       j=n=>break
       j:=j+1
       b:=a
       a:=[abs(b.(i+1)-b.i)  for i in 1..(#b-1)]
    j:=2
    repeat
       j>#a=>break
       a.j~=2 and a.j~=1 and a.j~=0 => return j-1
       j:=j+1
    k:=k*2

(4) -> [g(i)  for i in 1..30]
   (4)
   [3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176,
    176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

솔루션을 찾지 못하면 루프에서 2 * x의 프라임 목록을 확장하고 나머지 목록을 모두 다시 계산하십시오. 찾기 g (30)에 대해 3 초