用户：M.F.Hasler/相邻项的质数和

相邻项的质数和

引言

本页讨论了表单序列的一个系列（或者说两个系列）：

对于所有人n个≥o个，确实有N个和a中的素数(n个+我)+a个(n个+j个)，0≤我<j个<M（M）:S公司(N、 M；o个)是词典学上第一个这样的不同数字序列≥a吗(o个)=o个.

根据o=0或1，我们可以得到以（0）=0开头的“非负变量”或以（1）=1开头的“正变量”。

两者似乎都是排列（参见。部分Surjectivity（满意感）（见下文）N个={0，1，2，…}分别。N个*={1，2，3，…}兼容的的值N个和M（M），请参阅下一小节。

将“非负”变量限制为N个*（即正指数和值）是N个*，但不一定首先是词典：只针对某些特定情况(N、 M（M）)我们确实有S(N、 M；1） =S(N、 M；0）\{0}（略带符号滥用）：

S（2,3；1）=S（2,3,0）\{0}=A329411飞机 ; S（4,4,0）=S（4,1）U{0}=A329449型；S（6,5；0）=S（6,1）U{0}=A329425型.

有趣的是，在这些情况下N个=N个_最大值（M） ，最大可能值（参见下一小节）。然而，对于M（M）=6和N个= 9 =N个_最大值（6） ，序列S(N、 M（M）;0）和S(N、 M（M）;1） 非常不同。

当情况并非如此时(即，秒(N、 M（M）;0）和S(N、 M（M）;1） “从一开始就不同”），那么这两个变体通常在以后的任何时候都不会合并，这一点乍一看非常令人惊讶。我们只知道两个例外，即：

A329333飞机\{0}=S（1,3；1）=（1,2,7,3,6,4，…）等于S（1,3,0）=（0,1,3,6，2,7,4，..）N个* \ {1, 2, 3, 4, 5}.

S（7,6；0）等于N个* \ {5, 6; 11, 12}:

n |0，1，2，3，4，5, 6，7，8，9，10，11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, ...------------+------------------------------------------------------------------------------------------------------------S（7,6；0）（n）|0，1，2，3，4，8, 5, 11, 26, 15, 9,32, 14, 17, 20, 21, 27, 10, 16, 19,  7, 12, 13, 24,  6, 23, 35, 25, ...S（7,6；1）（n）|-1，2，3，4，5, 8, 11, 26, 15, 9,14、32, 17, 20, 21, 27, 10, 16, 19,  7, 12, 13, 24,  6, 23, 35, 25, ...

兼容（N、M）

使用M（M）连续值，我们有M（M）(M（M）+1） /2两两总和。然而，具有相同奇偶性的项不能产生质数和。制定细节后，我们发现最多可以N个_最大值≤地板(M（M）/2） ·天花板(M（M）/2） 质数和。取决于M（M），这将产生以下最大值N个和相应的序列：

  M（M）   N个最大值   o个= 0o个= 12    1128280英镑        A055265号更简单的定义：a（n）+a（n+1）是所有n的素数。3    2A329411飞机U{0}A329411飞机4    4A329449型        A329449型\ {0}5    6A329425型        329425美元\ {0}6    9A329569型        329568英镑与上述两个相反，这里的S（9,6；1）与S（9,1；0）非常不同！7   12A329572型        A329573型8   16       ?              ?       已知的是329581美元（N=11），A329580型（N=10）。

序列

方阵表格

N | M=2 3 4 5 6 7 8 9 10=M | N-----+-----------+----------+----------+----------+----------+----------+----------+----------+----------+--------+-----   12  |                                                        #A329572型*                                            12 12  |                                                        #A329573型*                                            12 11年|-A329581型°                                 1110|（此处N>N最大值:  -----------A329580型°                                 109|不可能。）--#A329569型°A329579型°                                             99  |                            -          -     #A329568型*                                                        9 8 |-87|°表示o=0------------A329567型°A329577型°76|*表示o=1-#A329425型平方米A329566型°*S（7,7,1）=（1..6,89,8,7,9..11，…）6 5|²表示两者-A329564型°A329565型°55|#表示N最大值-----------A329563型*                                                                   54  |                 -     #A329449型平方米A329456飞机°                                                                   4 3  |                 -A329454型°A329455型°                                                                   33  |      -     -----------A329417飞机*3个 2  |      -     #A329411飞机平方米A329452型°A329453型°                                                                   22  | -----------#A329411飞机平方米A329412型*A329413型*A329414飞机*A329415飞机*A329416飞机*2个 1  | #A128280号°A329333飞机²                                                                                         1    1  | #A055265号*A329333飞机平方米A329406型*A329407型*A329408型*A329409型*329410美元*            1 0  |A253074型°A329450型“（做？）（做。。。00  |A055266号*A329405型*（做？）（做-----+-----------+----------+----------+----------+----------+----------+----------+----------+----------+--------+-----   N | M=2 3 4 5 6 7 8 9 10=M | N

表作为列表

这里我们通过减少N（素数和的数量）的值，然后增加M（连续项的数量）来对序列进行排序。在某种意义上，这意味着首先是“最不平凡的”序列：素数和数量多的序列计算起来不那么简单，但随着连续项数量的增加，它们越来越容易计算（和“平滑”）。

A329574型（N=12，M=7；1），（M=7的Nmax；o=0变量未知）A329581型（N=11，M=8；0），对于其他M，贪婪计算块在N=。。。A329580型（N=10，M=8；0），--//--A329569型（N=9，M=6；0），A329568型（N=9，M=6；1），（M=6时的Nmax）,A329579型（N=9，M=7；0）-（N=8，M=6；0），329577美元（N=7，M=7；0），A329425型（N=6，M=5；0和1)（M=5时的Nmax）,A329566型（N=6，M=6；0），A329564型（N＝5，M＝5；0），A329563型（N=5，M=5；1），A329565型（N=5，M=6；0），A329449型（N=4，M=4；0），（M=4时的Nmax）,A329456飞机（N=4，M=5，0），A329417飞机（N=3，M=4；1），A329454型（N=3，M=4,0），329455美元（N=3，M=5,0），A329411飞机（N=2，M=3；1和0)A329452型（N=2，M=4；0），A329412型（N=2，M=4；1），A329453型（N=2，M=5；0），A329413型（N=2，M=5；1），A329414飞机（2，M＝6；1），A329415飞机（2，M=7；1），A329416飞机（2，M=10；1），A128280号（N=1，M=2；0），A055265号（N=1，M=2；1），A329333飞机（N=1，M=3；0和1):S（1，3；0）=（0，1，3，6，2，7，4，…）除非一个人在“素数”前面加上“奇数”：那么他后面跟着0乘以S（1，3；1）=（1，2，7，3，6，4，…）。从（6..）=（4，5，8，10，11，9，12，…）开始，两者相等。A329406型（N=1，M=4；1），A329407型(1, 5; 1),A329408型(1, 6; 1),A329409型(1, 7; 1),A329410型(1, 10; 1);A253074型（N＝0，M＝2；0）＝0，A055266号(0, 2; 1);A329450型(0, 3; 0),A329405型（0，3；1）：此处不素数必须出现！

备用表格：按A编号

A055265号（N=1，M=2；1），A055266号（N=0，M=2；1）；128280英镑（N=1，M=2；0），A253074型（N=0，M=2；0）;A329333飞机（N=1，M=3；0/1）；.A329405型(0, 3; 1),A329406型(1, 4; 1),A329407型(1, 5; 1),329408美元(1, 6; 1),A329409型(1, 7; 1),A329410型(1, 10; 1);A329411飞机(2, 3; 1/0),A329412型(2, 4; 1),A329413型(2, 5; 1),A329414飞机（2、6；1），A329415飞机(2, 7; 1),A329416飞机（2，10；1）；A329417飞机（3，4；1），---（回收）A329425型(6, 5; 0/1);.A329449型(4, 4; 0),A329450型(0, 3; 0)，（-51:回收）329452美元(2, 4; 0),A329453型(2, 5; 0),A329454型(3, 4, 0),A329455型(3, 5, 0),A329456飞机(4, 5, 0).  [此范围结束！].A329563型（5，5；1），A329564型(5, 5, 0);A329565型(5, 6, 0)A329566型(6, 6; 0),A329567型(7, 6, 0),A329568型(8, 6; 0),A329569型(9, 6; 0)，-70/-71:拉马努詹A329572型(10, 7, 0)A329573型(11, 7, 0)A329574型(12, 7, 1),A329575型(9, 6; 1),A329576型(7, 6; 1),A329577型(7, 7; 0),329578英镑：回收利用！A329579型(9, 7; 0),A329580型(10, 8; 0),A329581型(11, 8; 0),

关于存在等

所有n≥o是否都存在序列？

如果序列是以贪婪的方式计算的，这意味着对于给定的n，我们假设给定

P（n）：={a（n-1），…，a（n-M+1）}，因此n（n）:=#{（x，y）in P（n

其可以取{0，…，N}中的值。我们必须找到一个（n），这样我们在a（n）+P（n）中正好有n-n（n）个素数。（P（n）有M-1个不同的元素，所以对于a（n）+P（n

很容易证明，当N-N（N）=0或1时，这总是可能的。当需要更多素数时，不能无条件地知道上面指定的a（n）是否存在。例如，这需要（和/或暗示）孪生素数猜想或模拟，取决于与给定P（n）兼容的素数星座。然而，如果n≥M，那么至少我们知道P（n）是一个“可接受的”星座，在这个意义上，我们已经使用相同的集合P（n。

然而，序列不需要以贪婪的方式计算。也就是说，如果对于给定的P（n），不存在a（n）使得a（n。考虑到这种自由度，这些序列精确到无穷大的可能性似乎很大。

不贪婪的可计算变量

使用较大的M（M）和N个接近N个_最大值贪婪地选择一个术语是不正确的，因为它阻止了序列无限期地继续。通常，

• 这发生得很早，大多在M（M）初始条款，
• 在错误的选择后，或在M（M）初始值。
• 一旦初始条件通过，贪婪的选择对所有条件都是正确的，或者至少是数百个。

必须排除的选项列表

以下是必须排除的选项列表（“手动”或使用回溯），以便计算各个序列。
（它们被给定为a（i）≠{…}或简单地表示为[i，x_我]对于a（i）≠x_我.)

• S（5,5；0）:[5,4]，而S（5,1）是直截了当的。
• S（8,6；0）：[5,5]。
• S（9,7；1）:[7,7]，而S（9,1；0）是直截了当的。
• S（10,7；0）：a（6）∉{6,7}，a（37）≠19，a（58）≠46。。。[这种延迟回溯的需求非常特殊！]
• S（11,7,0）：a（5）∉｛5，6｝。
• S（12,7,1）：a（5），a（6）∉{5..8}。
• S（12,7,0）：a（3）{3,4}（=>a（3。

[要计算序列，只需知道各自a（i）的最终值就足够了，但如果不排除，将要进行的选择列表包含更多信息。]

一些人想出了例子

我们实际上有这样的序列的例子不贪婪地计算，就在一开始。例如，

S（5，5；1）=（1，2，3，4，5，8，9，14，6，23，17，7，12，24，10，13，19，16，18，25，22，15，28，21，26，32，75，…）

非常容易计算。然而，如果我们尝试从o=0开始，那么我们正确地找到了a（0..4）=（0，1，2，3，6），但将使用4作为下一项a（5）。事实上，{1,2,3,6,4}正好有5对{x，y}和为素数。然而，当一个（6）被加到{2，3，6，4}上时，必须给出另外3个素数，因为它已经有两对素数和对{2，3}和{3，4}。但这显然是不可能的。因此，我们必须使用较大的a（5）=5来获得

S（5，5；0）=（0，1，2，3，6，5，8，11，7，12，29,18, 19,4,13, 9, 22, 10, 21, 14,57,16, 15, 17, ...)

没有更多问题。[我们强调了两个较大的值出现得相对较早，而“4”出现得较晚。]

让我们注意到，S（N，M；0）的存在意味着S（N、M；1）的存在及其“上限”，因为前者对正指数的限制产生了一个可能的（不一定是字典最小的）解。但反过来，通常不可能在S（N，M；1）前加一个零，并且使用前M项在两两和中具有所需数量的素数。

类似地（但与偏移量相反），我们有

S（9,7；0）=329579英镑= (0, 1, 2, 3, 4, 5, 20, 9, 10, 8, 33, 11, 6, 50, 21, 17, 56, 12, 47, 14, 26, 7, 125, 15, 24, ...)

直截了当地说，但如果我们从o=1开始，我们就会在

1,2,3,4,5,6,7,?

并且必须使用a（7）=8，然后继续计算而不存在已知问题，从而得到

S（9,7；1）=1，2，3，4，5，6，8，9，14，15，11，23，18，218，20，21，10，33，51，12，38，46，7,76, 25, 55, 16, 17, 24, 13, 28, 19, 43, ...)

（注意，很大的a（14）=214，后面的a（23）=7。）

还有更多类似的例子。[待办事项：“完成”列表？例如：

S（12,7,1）：需要施加a（5）>8，a（6）>8。

然而，在大多数情况下，一旦初始项固定，贪婪计算将无限期工作，或至少对数百个项工作。[更精确地说：除了下面的例子，它在哪里停止？]

一个值得注意的例外是序列

S（10,7,0）=（0，1，2，3，4，5，8，9，10，14，33，15，20，27，26，11，32，16，41，21，57，116，22，51，38，23，50，63，86，6，17，…）

这里，不仅要排除（i，x（i））={（6，6），（6，7）}，还要排除{（37，19），（58，46），…}才能继续计算。

Surjectivity（满意感）

看起来序列实际上是排列各自的域{0，1，2，…}。{1，2，3，…}，即。，所有正整数最终都会出现。到目前为止，我们还没有正式的证据证明这一点，但至少有以下论点：

如果数字m永远不会出现，这意味着对于某些n*以外的所有n（见下文），集合P（n）={a（n-1），…，a（n-m+1}}是从未这样m+P（n）将包含所需数量的n-n（n）素数，尽管对于这些P（n做有那么多素数。这似乎极不可能，因为根据k元组猜想，这些P（n）中相同的素数生成模式将无限频繁地重复。

（如果m是从未出现的最小数，则上述n*是所有n<m都出现的点。在该点之前，如果a（n）的数量较小，且a（n”+P（n）具有所需的素数，则m不出现是正常的。）

程序

计算序列的PARI代码

以下计算n个序列S的项(N、 M；o个)[注意第一个参数n个在参数前面N、 M；o个 !], 以开始(o个)=o个; 因此，高达(n个−1+o个). 其他可选参数(对,单位, ...) 如下所述。

S（n，n=3，M=4，o=0，p=[]，u=o，u=vecsum（[1<<（p-u）|p<-p]））={向量（n，n，if（n>#p+1/*正常情况：超出初始值*/，如果（o>u，/*孔保持*/u+=1<<（o-u），/*其他*/u>>=-u+u+=估值（u+2，2））；/*使用价值记账*/p=连接（如果（#p>=M-1，p[^1]，p），o）；/*将o附加到前面的术语列表中，如果向量已满，则删除最旧的术语*/my（c=N和（i=2，#p，和（j=1，i-1，i素数（p[i]+p[j]））；/*分别计算素数和的个数。需要多少*/如果（#p<M-1/*还没有M-1的过去值：可以接受任何数量的<=c附加素数，我们将完成*/，对于（k=u，oo，bitest（u，k-u）||vecsum（[isprime（p+k）|p<-p]）>c||[o=k，break]）/*。。。下一个学期*/，对于（k=u，oo，bitest（u，k-u）||vecsum（[isprime（p+k）|p<-p]）=c||[o=k，break]）/*否则我们正好需要c素数*/)，#p，n>1||p=连接（p，o）；o=p[n]；n<#p||p=p[^n]/*p已给定（否则，无需执行任何操作：已设置o）*/)/*如果n>p+1，则结束。如果函数没有返回，请在此处输入“print（o”，“）”以显示进度（在某个n处的无限k循环）*/;o） /*结束向量*/+print（[u]）}/*在计算结束时打印未使用的最小数字*/

可用于调整计算的其他可选参数：

• 向量对持有M（M）−1个过去的值，因此可以开始计算o个，遵循中给出的值对。程序将初始化位图U型相应地，请参见下文。[注：该程序可以不给予超过M（M）-1初始值对（加上值o个=：a(n个)).]

此选项可用于在给定点恢复计算，已知值a（n）=o，前面加上M-1项p=（a（n-M+1）。。。，a（n-1））。但如果其他更大的值出现得更早，那么U型（参见下文）必须手动初始化。

• 变量单位等于最小未使用到目前为止的值（在对，但在使用之前o个). 只有条款≥单位将在搜索解决方案时考虑，较小的值是“禁止的”。
• U型存储值≥的位掩码单位之前使用过的，因此被排除在外。这里有点j个≥0对应于该值单位+j个，参见。被咬（…）在代码中。

变体

参数对,U型和单位允许绕过贪婪计算将阻塞的点。但如下面的示例所示，这有点麻烦。因此，我们还实现了一种不同的机制，通过“排除列表”X={(i、 x个_我)}. 例如，X={（2,3），（3,4）}表示值a（n）=3在第二项中被禁止，值a（n）=4在第三项中被禁用。[由于PARI向量从索引1开始，我们忘记了偏移量，因此当序列从偏移量0开始时，我们必须使用i=n+1。]

此外，我们可以替换vecsum（[i素数（x+k）|x<-p]）稍微短一些，速度更快一些#[0|x<-p，i素数（x+k）].

我们还可以结合两条中心线，这两条线的差异仅在于“>”与“！=”，这取决于大n的一般情况或n<M的特殊情况，或者更确切地说，当仍在初始项内时，质数和的总数可能小于目标值n。为此，我们注意到条件N（…）≤c可以写成N（……）-c≤0或c-N（…）≥0，但绝对不能为负。为了允许#p<M-1的不等式，我们可以取c-N（…）和（如果#p<M-1，取0；如果#p>=M-1，取1）的最小值：这是

• 如果c<N（…），则为负值，
• 当c=N（…）或c>N（……）且#p<M-1时为零，
• 如果c>N（…）且#p>=M-1，则严格为正。

因此，我们需要精确地将其始终为零，数字“0或1 if…”只是#p>=M-1的艾弗森括号：

SX（n，n=3，M=4，o=0，X=[]，p=[]，u=o，u=vecsum（[1<<（X-u）|X<-p]），LIM=199/*或：oo*/）={向量（n，n，如果（n>p+1/*正常情况：超出初始值*/，如果（o>u，/*孔保持*/u+=1<<（o-u），/*其他*/u>>=-u+u+=估值（u+2，2））；/*使用价值记账*/p=连接（如果（#p>=M-1，p[^1]，p），o）；/*将o附加到前面的术语列表中，如果向量已满，则删除最旧的术语*/my（c=N和（i=2，#p，和（j=1，i-1，isprime（p[i]+p[j]）），T=#p>=M-1）；/*计算素数，以及需要多少*/对于（k=u，u+指数（u+1）+LIM，位测试（u，k-u）||min（c-#[0|x<-p，isprime（x+k）]，T）||setsearch（x，[n，k]）||[o=k，break]）；o==p[#p]&&p=[u=o=LIM=u=-3]/*未找到项：这些设置将用-3填充矢量的其余部分*/，#p，n>1||p=连接（p，o）；o=p[n]；n<#p||p=p[^n]/*p已给定（否则，无需执行任何操作：已设置o）*/)/*如果n>p+1，则结束。如果函数没有返回，请在此处输入“print（o”，“）”以显示进度（在某个n处的无限k循环）*/;o） /*结束向量*/+打印（[u]）}/*在计算结束时打印最小的未使用数（忽略最后一项）*/

待办事项：实现回溯，以防循环阻塞。一种简单的（？）方法可以包括以下内容：

• 修复搜索限制LIM大于常规“gaps”=>完成！
• 只执行“for（k=…）”循环，直到LIM+到目前为止使用的最大值，即指数（U）+U.=>完成！
• 如果到那里没有发现任何东西，则将上一个值p[#p]＝a（n-1）增加到下一个可能的值，

[这有点复杂！需要重建u、u和p的早期值（如何…？？！！）；

-使用“同一个循环”来查找上一个术语的替换项；

-需要使其在向量中可见，例如，在a（n-1）的替换值周围使用[.]。。。

=>必须放弃当前结构S（…）=向量（n，n，…）：对（n-1）的试验可能会很快填充向量。]

• 如果在LIM中没有发现替换值，请再后退一步，以此类推。。。

示例用法

程序通常会用正确的初始值填充向量p，以便满足N个质数和为第一个M（M）条款。但是，如果为a（n）选择了一个明显可能的值，那么默认的贪婪计算可能会被阻止，而该值后来被证明是不可能继续的，囊性纤维变性。上面的不贪婪的可计算示例S（5,5；0）。在这种情况下，可以通过第4个自变量来施加a（n）的正确值o个，并给出前面的内容M（M）-1个值在对，以及的正确值（未使用的最小数字）单位. 例如，为了避免在尝试计算S（5,5；0）时陷入困境：

S（30,5,5,5，[1,2,3,6]，4）\\第四个参数o=5迫使a（4）=5，而不是较小的可能性4阻塞。

我们必须在这里给出一个（1..4）才能得到索引5（但可以不给出（0..4）！），即使默认情况下这些值计算正确。这将返回

[1, 2, 3, 6, 5, 8, 11, 7, 12, 29, 18, 19, 4, 13, 9, 22, 10, 21, 14, 57, 16, 15, 17,...],

它是序列S（5,5；0）没有其首字母0.

在上面的例子中，我们已经将p=a（1..4）“手工”。要获得由S（.）计算的这些初始值，只需输入n=M+1项：

S（6,5,5）=[0,1,2,3,6,4]

到目前为止，这是“正确的”（即满足约束条件），可以使用

向量（#%-4，n，n（%[n..n+4]））\\与小节中给出的函数n（）#其他代码在下面

我们可以肯定，该程序做出了尽可能少的选择，所以我们知道a（4）≥6我们必须设法找到解决办法对=[1,2,3,6]和单位=4，但一些较大的o=a（5）。如果这不可能，我们需要尝试使用一些较大的a（4）>6作为对.

使用程序的第二个变量，我们得到了相同的结果包括首字母a₀= 0简单一点

SX（30.5,5,0，[[6,4]）\\其中X=[[6,4]表示“禁止第6项使用值4”（=a（5），但PARI向量从索引1开始）。

再加上额外的改进，当没有找到任何项时，程序不会被卡住（而是用虚拟值填充向量），这使得通过试错法在非贪婪情况下找到解决方案变得更加容易。

第二个示例：S（8,7；0）和S（8,1；1）

让我们计算S（8,7；0），即7项的8素数和。贪婪的方法给出

P=S（7,8,7）\\=[0,1,2,3,4,5,90]

N（P）=8

即，（0，1，2，3，4，5，90，…），其中{0，…，5}已经有8个素数和，而90没有给出任何额外的素数和。

但这样就不可能继续下去了，这相当于用另一项替换0以保持相同的计数：

对于（n=69999，P[1]=n；n（P）==8&&return（n））\\没有结果

事实上，如果没有0，{1,2,3,4,5,90}中就有5个素数和(N（P[^1]）/*=5*/)，并且不可能通过添加一个x项来获得更多3个：

• 如果它是一个偶数x，那么x+1、x+3和x+5必须产生一个素数，这对于x≠2是不可能的：如果x+3不能被3整除，则x+1或x+5可以被3整掉。
• 用奇数x也不可能得到三个素数和x+2、x+4和x+90：前两个表示{x+2，x+4}={5，7}（mod 6），即x=3（mod6），但x+90可以被3整除。

因此90是不可能的，但我们发现91也是一个解决方案：

P[1]=0；对于（n=6199，P[7]=n；n（P）==8&&print1（n“，”））\\=>90，91，114，115，116，117。。。

并允许继续：

S（8，8，7，91，[0..5]，6）\\=[0，1，2，3，4，5，91，6]

但当我们试图超越8个术语时，它会被阻止。我们可以“作弊”，看看下面91个术语的下一个更大的选择（>6）：

S（8，8，7，91，[0.5]，7）\\=[0，1，2，3，4，5，91，10]

实际上可以使用更大的n个例如。，S（88、8、7、91、[0..5]、7），让人惊喜的是，计算不再阻塞。（但这些术语是不正确的，因为我们非法禁止了术语6。）

我们还可以通过上面的循环找到这10个以及更大的选项，

P[7]=91；对于（n=7199，P[1]=n；n（P）==8&&print1（n“，”））\\=>10，12，16，18，36，40，58，66，100。。。

现在要得到正确的继续，

S（99，8，7，10，[1,2,3,4,5,91]，6）\\=[1，2，3，4，5，91，10，9，8，33，6，7，11，20，12，23，13，30，24，29，16，15，14，17，26，…]

我们已经知道[0..5，91]是可以的，请仔细检查其余部分：

向量（#%-6，n，n（%[n..n+6]））\\只有8个！

请注意，这是从0开始的序列，没有初始的0！从1开始的序列将进行：

P=S（7，8，7，1）\\=[1，2，3，4，5，6，19]

这也阻止了n=7以外的数据：我们再次检查是否没有可能的延续。

对于（n=7999，P[1]=n；n（P）==8&&return（n））\\n没有结果！因此，让我们禁止19：

S（7，8，7，6，[1..5]，0，2^19）\\=[1，2，3，4，5，6，20]\\让我们试试这个20：

S（77、8、7、20、[1..6]、7）\\=[1、2、3、4、5、6、20、9、8、11、7、10、12、19、18、16、21、13…]

这是o=1的最小解，我们可以用向量（#%-6，n，n（%[n..n+6]））.

关于使用的备注血管与sum（）

这些是等效的：vecsum（[…p.…|p<-p]）=总和（i=1，#p，…p[i]…）前者分配一个辅助向量，但实际上速度更快。旁注：如果对只在里面出现一次。。。，否则vecsum更短。但由于OEIS在每个“，”后插入空格总和（…）,vecsum（）无论如何，将提供更短的代码。

如果我们只是二进制/布尔值的和{0,1}，那么通过装箱一个只有这些项的向量，只计算（非零）项的数量可能会更快。（旁注：法向量中的非零元素占用了大量空间！请考虑sizebyte（Vec（0100））与sizebyte（[1|x<-[0..99]]）来个（不太好的）惊喜！）因此：

和（i=1，#p，isprime（p[i]））=>更好：vecsum（[isprime，p<-p]）=>更好：#[0|p<-p，isprim（p）]

其他代码

以下函数（用于上述）计算给定集合P的素数对{x，y}⊂P的总数：

N（P）=总和（i=2，#P，总和（j=1，i-1，i素数（P[i]+P[j]））

（通过“对{x，y}⊂P”，我们的意思是“（x，y）∈P×P和x<y”，即x≠y并且不计算素数和x+y=y+x的两倍（在x=y的情况下，只有x=y=1可以给出素数，但我们想明确排除所有此类病态。）。在上述代码中，P可以是无序列表或向量，但它不应该有重复的元素；否则，如果这些元素贡献素数和，则使用相应的重数计算它们，例如，N（[1,1,2,2]）=5表示1+1=2，2×2=4乘以1+2=3。当然，如果素数和以两种方式出现，我们确实想数两次，比如[3，5，12，14]中的17=3+14=5+12。）

参考文献

• 埃里克·安吉利尼，来自邻近条款的优惠金额，个人博客“Cinquante signes”（并发布到SeqFan列表），2019年11月11日。
• 埃里克·安吉利尼，来自邻近条款的优惠金额，SeqFan列表，2019年11月11日。

作者

M.F.Hasler，用户：M._F._Hasler/Prime_sums_from_neighboring_terms.-来自整数序列在线百科全书®（OEIS®）wiki。可在https://oeis.org/wiki/User:M._F._Hasler/Prime_sums_from_neighboring_terms。

2019年11月23日编写的初始版本，使用按顺序发布的材料A329333飞机,A329452型2019年11月12日至15日。

MFH于2020年2月9日至11日追加捐款。