假设我们从质数的无限列表开始：

[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。吉尔布雷思的猜想预言着这种情况将永远存在。

前导数字将停止为1的唯一方法是在其后的下一个数字既不是0也不是2。第二个数字将不是0或2的唯一方法是如果此后的数字也不是0 0或2。依此类推。

除前导1以外，最早的数字的索引既不是0也不是2，在连续的一对序列之间绝不能下降超过1。这个事实已被用来为序列（如果有的话）的第一个元素可能不具有1的下限设置非常强的下限。

在此挑战中，将为您提供序列的索引，并且您必须输出该序列中第一个数字的索引，该数字不是前导1，也不是0或2。

例如，在上面的第4个绝对差序列中：

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

除第一个条目外，第一个既不为零也不为2的条目是第15个位置，索引为14。因此，如果输入为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 s。

Mathematica，66个字节

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

以正整数为参数并返回1索引整数的纯函数。Nest[Abs@*Differences,Array[Prime,z+#],#]计算#第一个z+#素数列表的迭代绝对差列表。For[z=1,Last@...<3,z++]循环进行此计算，直到结果列表的最后一个元素至少为3，然后z输出。（请注意，算法的正确性假定了吉尔布雷斯的猜想！）

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)

Perl 6的，136 120个字节

{->\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时，该功能在我普通的笔记本电脑上运行约四秒钟。

...这在升级我使用七个月的Perl 6安装后变为1.4秒（这也为我提供了skip使我可以从第一个解决方案中删除几个字节的方法）。从1到30的所有测试用例大约需要十秒钟。

Haskell，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的素数列表，然后重新计算所有剩余列表。3秒找到g（30）