自从欧几里得以来，我们知道有无限多个素数。这个论点是矛盾的：如果只有有限个，假设 $p_1,p_2,...,p_n$ ，那么肯定 $m:=p_1\cdot p_2\cdot...\cdot p_n+1$ 是不是由这些素数整除，所以它的因式分解必须产生新总理，这不是在列表中。因此，仅存在有限素数的假设是错误的。

现在，假设 $2$ 是唯一的质数。从上面的方法可以得出 $2+1=3$ 作为新的（可能的）素数。应用该方法再次产生 $2\cdot 3+1=7$ ，然后 $2\cdot 3\cdot 7+1=43$ ，那么 $2\cdot 3\cdot 7\cdot 43+1=13\cdot 139$ ，所以无论 $13$ 和 $139$ 是新的素数，等等。在我们得到一个复合数的情况下，我们只取最少的新素数。结果为A000945。

挑战

给定一个质数 $p_1$ 和一个整数 $n$ 计算定义的序列的第 $n$ 个项 $p_n$ ，如下所示：

p_{n} := min (primefactors (p_{1} \cdot p_{2} \cdot . . . \cdot p_{n - 1} + 1))

$p_n := \min(\operatorname{primefactors}(p_1\cdot p_2\cdot ... \cdot p_{n-1} + 1))$

这些序列被称为欧几里得-穆林序列。

例子

对于 $p_1 = 2$ ：

1 2
2 3
3 7
4 43
5 13
6 53
7 5
8 6221671
9 38709183810571

对于 $p_1 = 5$ （A051308）：

1 5
2 2
3 11
4 3
5 331
6 19
7 199
8 53
9 21888927391

对于 $p_1 = 97$ （A051330）

— 瑕疵
source

10

JavaScript（ES6）， 45 44字节

将输入作为(n)(p1)，其中为0索引。 $n$

n=>g=(p,d=2)=>n?~p%d?g(p,d+1):--n?g(p*d):d:p

在线尝试！

已评论

n =>                // n = 0-based index of the requested term
  g = (             // g is a recursive function taking:
    p,              //   p = current prime product
    d = 2           //   d = current divisor
  ) =>              //
    n ?             // if n is not equal to 0:
      ~p % d ?      //   if d is not a divisor of ~p (i.e. not a divisor of p + 1):
        g(p, d + 1) //     increment d until it is
      :             //   else:
        --n ?       //     decrement n; if it's still not equal to 0:
          g(p * d)  //       do a recursive call with the updated prime product
        :           //     else:
          d         //       stop recursion and return d
    :               // else:
      p             //   don't do any recursion and return p right away

— Arnauld
source

9

05AB1E，6个字节

这产生了无限的输出流。

λλP>fW

在线尝试！（链接包含略作修改的版本λ£λP>fW，它会输出前词） $n$

说明

非常简单。给定和，程序将执行以下操作： $p_1$ $n$

从开始作为无限流（使用first生成）的初始参数，然后开始一个递归环境，该环境在每次插入后都会生成一个新项并将其附加到流中。 $p_1$ λ
第二λ，现在正在使用内部递归环境，改变其功能：现在，它检索所有先前生成的元素（即，列表），其中表示当前的迭代次数。 $[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$ $n$
其余的内容很微不足道：P取乘积（），将乘积加到该乘积上，然后检索最小素因数。 $\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$ >fW

— Xcoder先生
source

6

J，15个字节

-10个字节感谢英里！

返回序列直到n（零索引）–感谢@miles

(,0({q:)1+*/)^:

在线尝试！

J，25个字节

返回n第一个项目

_2{((],0{[:q:1+*/@])^:[])

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

1

(,0({q:)1+*/)^:15字节，返回序列直到n（零索引）

— 英里

@miles谢谢！

— Galen Ivanov

非常好。@miles那里到底发生了什么语法？我们将动词和连词放在一起，并得到二元动词。我以为verb conj 产生了副词。

— 约拿

1

@乔纳，这是我从打高尔夫球中学到的技巧。我认为这是仍然有效的旧解析规则之一

— 英里

@miles我刚刚意识到这是一个副词（或副词）。它修饰的名词，以它的左侧，其中“武官”到右面^:，然后是成为一个适用于右ARG动词。我认为这就是语法上的变化。

— 约拿

5

Python 2，56个字节

i=input();k=1
while 1:
 k*=i;print i;i=2
 while~k%i:i+=1

在线尝试！

已评论

i=input() # the initial prime
k=1       # the product of all previous primes
while 1:  # infinite loop
 k*=i     # update the product of primes
 print i  # output the last prime
 i=2      # starting at two ...
 while~k%i: # find the lowest number that divides k+1
  i+=1
            # this our new prime

在线尝试！

— ovs
source

我刚开始用Python，但你需要int(input())，否则i是str？

— 安东尼

2

在Python 3中，这是正确的，因为input()总是返回字符串。在Python 2中，input()尝试评估输入。在这种情况下，我使用的是Python 2，因为生成的代码略短。对于真实代码，您应该尝试使用Python 3，因为它是Python的更新和受支持的版本。

— ovs

n个步骤后，它如何终止？

— sintax

@sintax会按照默认序列规则的规定，无限期地输出给定p1的序列。

— ovs

4

果冻，8字节

P‘ÆfṂṭµ¡

接受和的完整程序（使用零索引），该程序会打印到含列表的Jelly表示形式。（作为二元链接，我们将得到一个整数，而不是列表。） $P_0$ $n$ $P_0$ $P_n$ n=0

在线尝试！

怎么样？

P‘ÆfṂṭµ¡ - Link: integer, p0; integer n
      µ¡ - repeat the monadic chain to the left n times, starting with x=p0:
P        -   product of x (p0->p0 or [p0,...,pm]->pm*...*p0)
 ‘       -   increment
  Æf     -   prime factors
    Ṃ    -   minimum
     ṭ   -   tack
         - implicit print

— 乔纳森·艾伦
source

3

05AB1E，8 个字节

GDˆ¯P>fß

第一个输入为，第二个输入为质数。 $n$ $p$

在线尝试或使用更多测试用例（测试套件缺少，因为对于和，内置花费的时间太长）。 $n\geq9$ $p=2$ $p=5$ f

说明：

G         # Loop (implicit input) n-1 amount of times:
 Dˆ       #  Add a copy of the number at the top of the stack to the global array
          #  (which will take the second input p implicitly the first iteration)
   ¯      #  Push the entire global array
    P     #  Take the product of this list
     >    #  Increase it by 1
      f   #  Get the prime factors of this number (without counting duplicates)
       ß  #  Pop and only leave the smallest prime factor
          # (after the loop: implicitly output the top of the stack as result)

— 凯文·克鲁伊森
source

我有λλP>fW（6个字节）的输出作为一个无限列表，λ£λP>fW而前项的输出为（7个字节）。但是，获取应该是9个字节...如果仅我们有一个标志，但最后一个元素！

n

$n$

n^{th}

$n^{\text{th}}$ £

— Xcoder先生

@ Mr.Xcoder“ 如果只有一个标记，£但是最后一个元素！ ”，就像.£？;）编辑：其实，这是行不通的完全一样£的列表..使用像一个列表[1,2]有.£两个松散的项目与最后1个2项结果（即12345成为[5,45]代替[45,3]或[3,45]与12S.£）..

— 凯文Cruijssen

嗯，不，我不知道λ.£应该如何工作。我在与关联的其他功能中使用了flagλ（请参阅与Adnan的对话）。我基本上想要一些标志è，以便在运行λè...}时将生成第n个元素，而不是无限流（就像λ£生成第一个n个元素一样）。

— Xcoder先生

@ Mr.Xcoder抱歉，您已使用£递归环境。是的，那λ.£确实是行不通的，我不好。不错的6乘，无论如何。现在，您只需要等待@flawr的响应即可（无论是否允许）。

— 凯文·克鲁伊森

3

Japt，12 11 字节

努力做到这一点，所以可能错过了可以打高尔夫球的东西。

将n作为第一个输入p1，将作为单例数组作为第二个。返回第一n项。更改h为g以返回n第0个索引的项。

@Z×Ä k Î}hV

试试吧

@Z×Ä k Î}hV     :Implicit input of integer U=n & array V=[p1]
@               :Function taking an array as an argument via parameter Z
 Z×             :  Reduce Z by multiplication
   Ä            :  Add 1
     k          :  Prime factors
       Î        :  First element
        }       :End function
         hV     :Run that function, passing V as Z, and
                : push the result to V.
                : Repeat until V is of length U

— 毛茸茸
source

3

视网膜，56字节

,|$
$*
"$&"{~`.+¶
$$¶_
)`\b(__+?)\1*$
$.1$*
1A`
.$

\*
,

在线尝试！将输入作为要在第一行添加的新术语的数量以及在第二行添加的种子术语的数量。注意：由于使用一元分解，因此速度非常慢，因此需要创建相关长度的字符串。说明：

,|$
$*

将种子词中的逗号替换为*s并附加一个*。这将为值乘积的长度字符串创建Retina表达式。

"$&"{
)`

将第一个输入给出的次数重复循环一次。

~`.+¶
$$¶_

临时用a替换第一行上的数字，$并_在第二行前添加a，然后作为Retina程序评估结果，从而在字符串的末尾附加一个_长度为s的字符串，而不是值的乘积。

\b(__+?)\1*$
$.1$*

在十进制中找到最小的非平凡因数，并*为下一个循环添加准备。

1A`

删除迭代输入。

.$

删除最后一个*。

\*
,

将其余*的替换为,。

— 尼尔
source

2

JavaScript（Node.js），54字节

f=(p,n,P=p,F=n=>-~P%n?F(n+1):n)=>--n?f(p=F(2),n,P*p):p

在线尝试！

不打高尔夫球

F=(p,n=2)=>            // Helper function F for finding the smallest prime factor
  p%n                  //   If n (starting at 2) doesn't divide p:
    ?F(n+1)            //     Test n+1 instead
    :n                 //   Otherwise, return n
f=(p,n,P=p)=>          // Main function f:
  --n                  //   Repeat n - 1 times:
    ?f(p=F(P+1),n,P*p) //     Find the next prime factor and update the product
    :p                 //   Return the last prime

— 赫尔曼·L
source

2

bash + GNU coreutils，89个字节

IFS=\*;n=$1;shift;for((;++i<n;));{ set $@ `factor $["$*+1"]|cut -d\  -f2`;};echo ${@: -1}

蒂奥

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

2

Ruby 2.6，51个字节

f=->s,n{[s,l=(2..).find{|d|~s%d<1}][n]||f[l*s,n-1]}

(2..)，TIO尚不支持从2开始的无限范围。

这是一个递归函数，它采用一个起始值s（可以是素数或复合值），在n = 0时返回它（编辑：请注意，这意味着它的索引为零），返回l大于1 的最小数字并-(s+1)在n时除以= 1，否则以s=l*s和递归n=n-1。

— 历史学家
source

1

您可能应该提到您正在执行零索引；我替换(2..)为2.step（仅增加了1个字节），以使其可以在TIO上工作，并且一切都变了。在线尝试！

— 价值墨水

2

APL（Dyalog扩展），15字节

这是算法的相当简单的实现，它使用内置的Extended非常有用的素因子⍭。在线尝试！

{⍵,⊃⍭1+×/⍵}⍣⎕⊢⎕

说明

{⍵,⊃⍭1+×/⍵}⍣⎕⊢⎕

             ⊢⎕  First get the first prime of the sequence S from input.
{         }⍣⎕    Then we repeat the code another input number of times.
     1+×/⍵       We take the product of S and add 1.
    ⍭            Get the prime factors of product(S)+1.
   ⊃             Get the first element, the smallest prime factor of prod(S)+1.
 ⍵,              And append it to S.

— 神探洛克9
source

1

Pari / GP，47字节

(p,n)->s=1;for(i=2,n,s*=p;p=divisors(s+1)[2]);p

在线尝试！

— Alephalpha
source

1

Stax，9 个字节

é|G╝╓c£¼_

运行并调试

取和（零索引）作为输入。产生。p₀np_n

— 递归的
source

1

C（gcc），54 53字节

p;f(x,n){for(p=x;--n;p*=x)for(x=1;~p%++x;);return x;}

在线尝试！

-1个字节，感谢ceilingcat

— 浪费
source

1

Perl 6的，33 32个字节

-1字节感谢nwellnhof

{$_,{1+(2...-+^[*](@_)%%*)}...*}

在线尝试！

带有一个数字并返回一个惰性列表的匿名代码块。

说明：

{                              }  # Anonymous codeblock
                           ...*   # That returns an infinite list
 $_,                              # Starting with the input
    {                     }       # Where each element is
     1+(2...             )          # The first number above 2
                      %%*           # That cleanly divides
               [*](@_)                # The product of all numbers so far
            -+^                       # Plus one

— 乔·金
source

1

-+^[*](@_)保存一个字节。

— nwellnhof

0

Haskell，49个字节

g 1
g a b=b:g(a*b)([c|c<-[2..],1>mod(a*b+1)c]!!0)

在线尝试！

返回无限序列作为惰性列表。

说明：

g 1                                            -- Initialise the product as 1
g a b=                                         -- Given the product and the current number
       b:                                      -- Return the current number, followed by
         g                                     -- Recursively calliong the function with
          (a*b)                                -- The new product
               (                             ) -- And get the next number as
                [c|c<-[2..],             ]!!0  -- The first number above 2
                            1>mod       c      -- That cleanly divides
                                 (a*b+1)       -- The product plus one

— 乔·金
source