给定一个非空列表大号整数大于的1，我们定义d（L）为最小的正整数，使得N + d（L）是复合每个Ñ在大号。

我们定义的顺序一个_Ñ为：

• 一个₀ = 2
• a _{i + 1}是大于a _i的最小整数，使得d（a ₀，...，a _i，a _{i + 1}）> d（a ₀，...，a _i）

你的任务

您可以：

• 取整数N并返回序列的第N个项（0索引或1索引）
• 取整数N并返回序列的前N个项
• 不输入任何内容并永久打印序列

这是代码高尔夫球，因此最短答案以字节为单位！

如果您的代码随着N的增大而变慢，那是可以的，但是它至少应该在2分钟内找到20个第一项。

第一学期

• a ₀ = 2和d（2）= 2（我们需要加2以便2 + 2是合成的）
• a ₁ = 3，因为d（2，3）= 6（我们需要加6以便2 + 6和3 + 6合成）
• a ₂ = 5，因为d（2，3，5）= 7（我们需要加7以便2 + 7、3 + 7和5 + 7都是合成的），而d（2，3，4）仍然是等于6
• 等等

以下是序列的前100个字词（发布时在OEIS上未知）。

  2,   3,   5,   6,  10,  15,  17,  19,  22,  24,
 30,  34,  35,  39,  41,  47,  51,  54,  56,  57,
 70,  79,  80,  82,  92,  98, 100, 103, 106, 111,
113, 116, 135, 151, 158, 162, 165, 179, 183, 186,
191, 192, 200, 210, 217, 223, 226, 228, 235, 240,
243, 260, 266, 274, 277, 284, 285, 289, 298, 307,
309, 317, 318, 329, 341, 349, 356, 361, 374, 377,
378, 382, 386, 394, 397, 405, 409, 414, 417, 425,
443, 454, 473, 492, 494, 502, 512, 514, 519, 527,
528, 560, 572, 577, 579, 598, 605, 621, 632, 642

Pyth，24个字节

Pu+GfP_+Tf!fP_+ZYG)eGQ]2

示范

基本上，我们从开始[2]，然后通过交替查找d，然后添加一个元素，一次添加元素1 。输出n序列的第一个元素。

在重复应用循环内的第一个整数过滤器内的第一个整数过滤器内包含一个过滤器。

说明：

Pu+GfP_+Tf!fP_+ZYG)eGQ]2
 u                   Q]2    Starting with `[2]`, do the following as many times
                            as the input
         f        )         Starting from 1 and counting upward, find d where
          !f     G          None of the elements in the current list
            P_+ZY           plus d give a prime.
    f              eG       Starting from the end of the current list and counting
                            upward, find the first number which
     P_+T                   plus d gives a prime.
  +G                        Append the new number to the current list
P                           Trim the last element of the list

在两个“添加并检查是否为素数”调用之间，显然需要反复努力，但是我不确定如何消除它。

果冻，31个字节

ṛ,;1+ÆPẸṆʋ1#ⱮẎ</
Ḷ߀‘Ṫç1#ƊḢƲ2⁸?

在线尝试！

果冻吮吸复发序列。：/

视网膜，74字节

K`__;
"$+"{/;(?!(__+)\1+\b)/+`;
;_
.+$
$&¶$&
)/;(__+)\1+$/+`.+$
_$&_
%`\G_

在线尝试！0索引。说明：

K`__;

i工作区中的每一行都包含两个一元值aᵢ;d+aᵢ。我们从a₀=2和开始d+a₀=0（因为它是高尔夫球手）。

"$+"{
...
)

重复循环N时间。

/;(?!(__+)\1+\b)/+`

重复至少一个非复合数字。

;
;_

增量d。

.+$
$&¶$&

复制最后一行，复制aᵢ₋₁到aᵢ。

/;(__+)\1+$/+`

重复，同时d+aᵢ是复合的。

.+$
_$&_

增量aᵢ。

%`\G_

将结果转换为十进制。

干净，138个 130 128字节

import StdEnv
$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2])

在线尝试！

展开：

$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1
$l=until(                                         )inc 1  // first value from 1 upwards where _
         \v=all(                                )l        // _ is true for everything in l
                \n=any(              )[2..n+v-1]          // any of [2,3..n+v-1] match _
                             gcd(n+v)                     // the gcd of (n+v) and ^
                           o                              // (composed) ^ is _
                       (<)1                               // greater than 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2]) 
map hd(                                                 ) // the first element of each list in _
       iterate(                                     )[2]  // infinite repeated application of _ to [2]
               \l=hd[                              ]      // the head of _
                     [n:l]                                // n prepended to l
                          \\n<-[hd l..]                   // for every integer n greater than the head of l
                                       | $[n:l]> $l       // where d(n0..ni+1) > d(n0..ni)

朱莉娅0.6，145个 130字节

~L=(x=1;while any(map(m->all(m%i>0 for i=2:m-1),L+x));x+=1;end;x)
!n=n<1?[2]:(P=!(n-1);t=P[end]+1;while ~[P;t]<=~P;t+=1;end;[P;t])

在线尝试！

（使用我的新的和改进的高尔夫技巧可减少-15个字节-运算符重载，将条件替换为三进制，从而删除return关键字。）

展开式：

function primecheck(m)
    all(m%i>0 for i∈2:m-1)
end

function d(L)
    x = 1
    while any(map(primecheck, L+x))
        x += 1
    end
    return x
end

function a(n)
    n > 0 || return [2]
    Prev = a(n-1)
    term = Prev[end] + 1
    while d([Prev;term]) ≤ d(Prev)
        term += 1
    end
    return [Prev;term]
end