Giả sử chúng ta bắt đầu với danh sách vô hạn các số nguyên tố:

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

Sau đó, chúng tôi lấy sự khác biệt tuyệt đối giữa mỗi cặp số, lặp đi lặp lại:

[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, ...

Lưu ý rằng số hàng đầu là 1 mỗi lần. Phỏng đoán của Gilbreath là dự đoán rằng điều này sẽ tiếp tục là trường hợp mãi mãi.

Cách duy nhất mà số đứng đầu sẽ dừng là 1 là nếu số tiếp theo sau nó không phải là 0 hay số 2. Cách duy nhất số thứ hai sẽ không là 0 hoặc 2 là nếu số sau đó không phải là số 0 0 cũng không phải là 2. Và cứ thế.

Chỉ số của số sớm nhất, ngoại trừ số 1 đứng đầu, không phải là 0 hay 2, không bao giờ có thể giảm hơn 1 giữa một cặp chuỗi liên tiếp. Thực tế này đã được sử dụng để đặt giới hạn dưới rất mạnh vào thời điểm, nếu có, một chuỗi có thể không có 1 là phần tử đầu tiên.

Trong thử thách này, bạn sẽ được cung cấp chỉ số của một chuỗi và bạn phải xuất chỉ mục của số đầu tiên trong chuỗi đó không phải là số 1 đứng đầu và không phải là 0 hoặc 2.

Chẳng hạn, trong chuỗi khác biệt tuyệt đối thứ 4 ở trên:

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

Mục nhập đầu tiên không phải là số 0 hay số hai, trừ mục nhập đầu tiên, là vị trí thứ 15, 14 không được lập chỉ mục. Vì vậy, nếu đầu vào là 4, bạn sẽ xuất 14.

Đối với đầu vào từ 1 đến 30, đầu ra phải là:

[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]

Đây là OEIS A000232 .

Điều này giả sử bạn có 1 đầu vào được lập chỉ mục và 0 đầu ra được lập chỉ mục. Bạn có thể lập chỉ mục đầu vào và đầu ra của mình bắt đầu từ bất kỳ số nguyên không đổi nào, miễn là bạn có thể chấp nhận phạm vi đầu vào tương ứng với tất cả các chuỗi.

Yêu cầu: Giải pháp của bạn phải chạy tối đa 1 phút với đầu vào tối đa 30. Nếu nó đủ gần, tùy thuộc vào thông số kỹ thuật của máy tính, điều đó được cho phép.

Mã ngắn nhất sẽ thắng.

Thạch , 17 byte

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

Hãy thử trực tuyến!

Đầu vào là 2 chỉ mục. Đầu ra là 1 chỉ mục.

Trên TIO, tất cả các testcase tổng cộng mất 22.309 giây.

Toán học, 66 byte

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

Hàm thuần túy lấy một số nguyên dương làm đối số và trả về số nguyên 1 chỉ mục. Nest[Abs@*Differences,Array[Prime,z+#],#]tính toán #danh sách khác biệt tuyệt đối lặp lại của danh sách các z+#số nguyên tố đầu tiên . For[z=1,Last@...<3,z++]lặp lại tính toán này cho đến khi phần tử cuối cùng của danh sách kết quả ít nhất 3, và sau đó zlà đầu ra. (Lưu ý rằng tính chính xác của thuật toán giả định phỏng đoán của Gilbreath!)

Bình thường , 32 byte

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

Hãy thử trực tuyến!

Sử dụng 2 chỉ mục.

MATL , 18 byte

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

Đầu vào và đầu ra là 1 dựa trên. Mất ít hơn 40 giây trong TIO cho mỗi trường hợp thử nghiệm.

Hãy thử trực tuyến!

Giải trình

Điều này tiếp tục thử các chuỗi số nguyên tố ban đầu dài hơn cho đến khi các khác biệt liên tiếp tuyệt đối lặp đi lặp lại cho ít nhất một giá trị vượt quá 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)

Perl 6 , 136 120 byte

{->\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..*)}

Ung dung:

{   # 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 .. *);
}

Với đầu vào là 30, chức năng sẽ chạy trong khoảng bốn giây trên máy tính xách tay khiêm tốn của tôi.

... Sẽ trở thành 1,4 giây sau khi nâng cấp cài đặt Perl 6 bảy tháng tuổi của tôi (cũng cung cấp cho tôi skipphương thức cho phép tôi loại bỏ một vài byte khỏi giải pháp đầu tiên của mình). Tất cả các trường hợp thử nghiệm từ 1 đến 30 mất khoảng mười giây.

Haskell , 94 byte

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

Hãy thử trực tuyến! Dòng cuối cùng là một chức năng ẩn danh. Ràng buộc để ví dụ gvà gọi như thế g 4. Tất cả các trường hợp thử nghiệm kết hợp mất ít hơn 2 giây trên TIO.

Làm thế nào nó hoạt động

[n|n<-[2..],all((>0).mod n)[2..n-1]]tạo ra một danh sách vô hạn các số nguyên tố.
f(a:b:r)=abs(a-b):f(b:r)là một hàm mang lại sự khác biệt tuyệt đối của các yếu tố của một danh sách vô hạn. Cho một số n, (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)áp dụng f nthời gian cho danh sách các số nguyên tố. length.fst.span(<3)tính độ dài của tiền tố của danh sách kết quả trong đó các phần tử nhỏ hơn 3.

Tiên đề, 289 byte

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

ungolf nó và kiểm tra

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]

nếu không tìm thấy giải pháp, hãy mở rộng danh sách chính của 2 * x trong một vòng lặp và tính toán lại tất cả các danh sách còn lại. 3 giây để tìm g (30)