ユークリッド以来、私たちは素数が無限にあることを知っています。引数は矛盾によるものです：有限数しかない場合、たとえば場合、は、これらの素数なので、その素因数分解はリストにない新しい素数を生成する必要があります。したがって、有限の素数のみが存在するという仮定は誤りです。$p_1,p_2,...,p_n$$m:=p_1\cdot p_2\cdot...\cdot p_n+1$

ここで、が唯一の素数であると仮定しましょう。上記のメソッドは、新しい（可能な）プライムとしてを生成します。メソッドを再度適用すると、得られ、次に、次にとなり、両方ともおよびは新しい素数などです。合成数を取得する場合は、最も新しい素数を取得します。これにより、A000945が生成されます。$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$

チャレンジ

素数と整数与えられた場合、次のように定義されたシーケンスの番目の項を計算します。$p_1$$n$$n$$p_n$

これらのシーケンスは、ユークリッドマリンシーケンスとして知られています。

例

以下のための$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）

1 97
2 2
3 3
4 11
5 19
6 7
7 461
8 719
9 5

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

05AB1E、6バイト

これにより、無限の出力ストリームが生成されます。

λλP>fW

オンラインでお試しください！（リンクにはわずかに変更されたバージョンが含まれてλ£λP>fWいますが、代わりに最初の用語が出力されます）$n$

説明

とても簡単です。与えられたおよび、プログラムは次の処理を行います。$p_1$$n$

• 始まる（最初を使用して生成される無限のストリームのための初期パラメータとして）と始まる再帰環境各interation後に新しい用語を生成し、ストリームに追加します。$p_1$λ
• 2番目λは、再帰環境内で使用されるようになり、その機能が変更されました。今では、以前に生成されたすべての要素（つまり、リスト）を取得します。ここで現在の反復数を表します。$[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$$n$
• 残りは簡単です。P積（）を取り、この積に1を加算し、最小素因数を取得します。$\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$>fW

J、15バイト

マイルのおかげで-10バイト！

nまでのシーケンスを返す（ゼロインデックス）– @milesのおかげ

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

オンラインでお試しください！

J、25バイト

n番目のアイテムを返します

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

オンラインでお試しください！

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

オンラインでお試しください！

ゼリー、8バイト

P‘ÆfṂṭµ¡

$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

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)

Japt、12 11 バイト

これを正しくするのに苦労したので、ゴルフをすることができる何かを見逃したかもしれません。

かかるn第1の入力として及び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

網膜、56バイト

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

\*
,

オンラインでお試しください！1行目に追加する新しい用語の数として入力を取り、2行目にシード用語を入力します。注：単項分解を使用するため、非常に遅くなり、関連する長さの文字列を作成する必要があります。説明：

,|$
$*

シード用語のコンマを*sに置き換え、aを追加し*ます。これにより、値の積の長さの文字列に対してRetina式が作成されます。

"$&"{
)`

最初の入力で指定された回数だけループを繰り返します。

~`.+¶
$$¶_

一時的との最初の行の番号を交換$し、先頭に追加_次いでこうして列付加、網膜プログラムとして結果を評価し、第二のラインに_複数の値の積よりも長さ1秒。

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

10進数で数値の最も重要な要因を見つけて*、次のループの準備をします。

1A`

反復入力を削除します。

.$

最後のを削除し*ます。

\*
,

残り*のsを,sに置き換えます。

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

bash + GNU coreutils、89バイト

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

TIO

Ruby 2.6、51バイト

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

(2..)、2から始まる無限の範囲はTIOではまだサポートされていません。

これは、開始値s（素数または複合値）を取り、n = 0のときにそれを返します（編集：インデックスが0であることを意味することに注意してください）、l1より大きい最小数を返し、-(s+1)n = 1、それ以外で再帰s=l*sとn=n-1。

APL（Dyalog Extended）、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.

パリ/ GP、47バイト

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

オンラインでお試しください！

スタックス、9 バイト

é|G╝╓c£¼_

実行してデバッグする

入力用に（ゼロインデックス）を取ります。を生成します。p0npn

C（gcc）、54 53バイト

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

オンラインでお試しください！

ceilingcatのおかげで-1バイト

Perl 6の、33の 32バイト

nwellnhofのおかげで-1バイト

{$_,{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

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