背景

请考虑以下顺序（OEIS中为A051935）：

• 从术语开始。$2$
• 找出大于的最低整数，使为质数。2 2 + $n$$2$$2+n$
• 找到大于的最低整数，使为质数，以此类推。 Ñ 2 + Ñ + Ñ $n'$$n$$2 + n + n'$

一个更正式的定义：

序列的前几个术语是（请将其称为测试用例）：

2, 3, 6, 8, 10, 12, 18, 20, 22, 26, 30, 34, 36, 42, 44, 46, 50, 52, 60, 66, 72, 74, ...

任务

您的任务是通过以下任何一种方式生成此序列：

• 无限期输出其条件。
• 给定$n$，输出$a_{n}$（$n^{\text{th}}$项，索引为$0$或$1$）。
• 给定$n$，输出$\{a_1, a_2, \dots, a_n\}$（前$n$项）。

您可以使用任何编程语言进行竞争，并且可以通过任何标准方法接受输入并提供输出，同时请注意，默认情况下，这些漏洞是禁止的。这是代码高尔夫球，因此每种语言的最短提交（以字节为单位）将获胜。

Brachylog，13个字节

~l.<₁a₀ᵇ+ᵐṗᵐ∧

在线尝试！

输出是序列的前n个项的列表。

?~l.<₁a₀ᵇ+ᵐṗᵐ∧    Full code (? at beginning is implicit)

?~l.              Output is a list whose length is the input
    <₁            Output is an increasing list
      a₀ᵇ+ᵐ       And the cumulative sum of the output
           ṗᵐ     Consists only of prime numbers
             ∧    No further constraints on output

Explanation for a₀ᵇ+ᵐ:
a₀ᵇ               Get the list of all prefixes of the list
                  Is returned in increasing order of length
                  For eg. [2, 3, 6, 8] -> [[2], [2, 3], [2, 3, 6], [2, 3, 6, 8]]
   +ᵐ             Sum each inner list  -> [2, 5, 11, 19]

Python 2中，63 62个字节

n=f=a=b=1
while 1:
 f*=n;n+=1;a+=1
 if~f%n<a-b:print a;b=a;a=0

在线尝试！

果冻，11 9字节

0Ḥ_ÆnɗСI

这是一个完整的程序，将n作为参数并显示序列的前n个项。

在线尝试！

怎么运行的

0Ḥ_ÆnɗСI  Main link. Argument: n

0          Set the return value to 0.
      С   Accumulating iterate. When acting on a dyadic link d and called with
           arguments x and y, the resulting quicklink executes
           "x, y = d(x, y), x" n times, returning all intermediate values of x.
           Initially, x = 0 and  y = n.
     ɗ       Drei; combine the three links to the left into a dyadic chain.
 Ḥ             Unhalve; double the left argument.
  _            Subtract the right argument.
   Æn          Compute the next prime.
           This computes the partial sums of the sequence a, starting with 0.
        I  Increments; compute the forward differences.

05AB1E v2，10个字节

2λλOD₁+ÅNα

在线尝试！

这仅适用于非旧版版本，即Elixir重写。输出无限的整数流。Prime测试中的一些错误已在最新的提交中修复，但尚未在TIO上发布。但是，它确实在本地工作。这是它在我的机器上执行的GIF，已修改为输出前几项而不是整个流。

怎么运行的

2λ

定义基本情况为的递归无限序列。该结构是05AB1E非常酷的新功能之一。简而言之，它需要一个函数，将设置给定的整数参数，在这种情况下为。a （n ）a （0 ）$2$λ$a(n)$$a(0)$$2$

λO

在这部分代码中，λ的角色不同。它已经在递归环境中，而是生成所有先前结果的列表。然后，总结一下。$[a(0),a(1),\dots,a(n-1)]$O

D₁+

复制总和以供以后使用，并将到第二个副本中。$a(n-1)$

ÅN

生成最低的素数，其大于上述总和。

α

最后，获取上面计算出的素数与先前计算出的总和（所有先前迭代的总和）的第一个副本之间的绝对差。

然后，将流无限期地隐式打印到STDOUT。

Perl 6，45个字节

2,{first (*+@_.sum).is-prime,@_[*-1]^..*}...*

在线尝试！

返回一个懒惰列表，该列表生成没有结束的序列。

说明：

这使用了Sequence运算符...，该运算符将序列定义为：

2,  # The first element is 2
  {  # The next element is:
    first  # The first value that:
          (*+@_.sum).is-prime,  # When added to the sum is a prime
          @_[*-1]^..*  # And is larger than the previous element
  }
...*  # And continue the sequence indefinitely

Ruby -rprime，34个字节

2.step{|i|$.+=p(i)if($.+i).prime?}

在线尝试！

无限期输出。

JavaScript（ES6），63个字节

返回 1个索引的项。$n^{th}$

n=>(k=0,s=1,g=d=>s%d?g(d-1):d<2?--n?g(s-=k-(k=s)):s-k:g(s++))()

在线尝试！

Pyth，12 11字节

.f&P-;Z=-;Z

在线尝试！

感谢isaacg，节省了1个字节。

n使用基于1的索引生成第一个此类数字。

.f查找k从零开始满足特定条件的前整数。在这里，判据是我们计算的先前素数;加上当前数Z为素数（P）。如果是，我们还使用逻辑和函数（&）的短路行为更新最后计算的素数。不幸.f的是，默认变量是Z在更新中花费一个字节。

isaacg找出的诀窍是存储最后一个素数的取反，然后在减去当前值的基础上进行测试。在Pyth中，这很短，因为素数检查超载：在正数上查找素数分解，在负数上确定素数的正值是否为素数。

这或多或少转化为：

to_find = input()
last_prime = 0
current = 0
results = []
while to_find > 0:
    if is_prime( current + last_prime ):
        results.append( current )
        to_find -= 1
        last_prime += current
    current += 1
print results

MATL，21字节

O2hGq:"t0)yd0)+_Yqh]d

在线尝试！

输出是序列的前n个项。

说明：

构造一个素数列表（以0开头），最后找到返回值，返回列表中连续素数之间的差。

              % Implicit input, say n
O2h           % Push P = [0, 2] on the stack 
Gq:"          % for loop: 1 to n-1
  t0)           % Take the last element of P
                %  Stack: [[0, 2], [2]] (in first iteration)
  yd0)          % Take the difference between the last
                %   two elements of P
                %  Stack: [[0, 2], [2], [2]]
  +             % Add those up
                %  Stack: [[0, 2], [4]]
  _Yq           % Get the next prime higher than that sum
                %  Stack: [[0, 2], [5]]
  h             % Concatenate that to the list P
                %  Stack: [[0, 2, 5]]
]             % End for loop
d             % Get the differences between successive elements of
              %   the final list P

Haskell，67个字节

(1#1)2 2
(p#n)s k|p`mod`n>0,n-s>k=k:(p#n)n(n-s)|w<-p*n=(w#(n+1))s k

在线尝试！

(1#1)2 2是一个无需输入且输出无限列表的函数。

旧答案：

Haskell，88 83 78 76字节

原始性测试来自此答案，并通过Christian Sievers（-2字节）进行了改进。

-5个字节，感谢WW。

2#2
(p#s)n|n<1=p|w<-until(\m->mod(product[1..m-1])m>0)(+1)$s+p+1=(w-s)#w$n-1

在线尝试！

05AB1E（旧版），12个字节

0U[XN+DpiN,U

在线尝试！

说明

0U              # initialize X as 0
  [             # start an infinite loop
   XN+          # add X to N (the current iteration number)
      Dpi       # if the sum is prime:
         N,     #   print N
           U    #   and store the sum in X

有几种不同的12字节解决方案。
如果我们将一个可用变量初始化为0（而不是1和2），则该特定字节可能为10个字节。

Python 2，119字节

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)
def g(i):
 r=[2]
 for j in range(i):r+=[f(sum(r)+r[-1])-sum(r)]
 return r

在线尝试！

从该答案中获取的下一个素数函数f（）。

函数g（）接受一个非负整数i，并返回直到该索引的序列中所有项目的列表。

Python 2中，99 98个字节

def f(n,s=2,v=2):
 k=s-~v
 while any(k%i<1for i in range(2,k)):k+=1
 return n and f(n-1,k,k-s)or v

在线尝试！

送给Xcoder先生 1个字节。

Haskell，101 99 97字节

该函数不l接受任何参数，并返回一个无限列表。不像@ovs 更直接的方法那样短（我显然偷走了他们回答的某些部分），但也许还能打高尔夫球吗？

感谢@ H.PWiz -2个字节！

import Data.List
p m=mod(product[1..m-1])m>0
l=2:[until(p.(+sum a))(+1)$last a+1|a<-tail$inits l]

在线尝试！

Python 2中，82 80个字节

s=p=2
i=input()
P=n=1
while i:
 P*=n;n+=1
 if P%n>0<n-s-p:p=n-s;s=n;i-=1
print p

在线尝试！

这将输出序列的第n个数字（从0开始）。通过print在循环中移动in，可以对其进行修改以n以相同的字节数输出前几项：在线尝试！

C（gcc），100 99字节

• 多亏了ceilingcat，节省了一个字节。

p(r,i,m,a,l){for(l=m=a=0;a-r;)m+=i=p(a++);while(r*!l)for(++i,l=a=2;a-m-i;)l=(m+i)%a++?l:0;r=r?i:2;}

在线尝试！

Japt，17个字节

输出n第0个索引的th项。

@_+T j}aXÄT±X}g2ì

尝试一下