유클리드 이후, 우리는 무한히 많은 소수가 있다는 것을 알고 있습니다. 논쟁의 여지가 있습니다 : 유한하게 많은 수가 있다면 $p_1,p_2,...,p_n$ 라고합시다 . . . , 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_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

자바 스크립트 (ES6),  45  44 바이트

입력을로 취합니다 (n)(p1). 여기서 $n$ 은 0으로 색인됩니다.

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$ 주어지면 프로그램은 다음을 수행합니다.

• 무한 스트림에 대한 초기 매개 변수로 $p_1$ 로 시작하고 (첫 번째를 사용하여 생성됨 λ) 각 간섭 후에 새 용어를 생성하고이를 스트림에 추가 하는 순환 환경 을 시작 합니다.
• 제 λ현재 사용되고, 내부 순환 환경은, 그 기능을 변경 : 이제, 모든 이전에 생성 된 요소 (즉,리스트를 검색 $[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$ ), 여기서$n$ 를 나타낸다 현재 반복 번호.
• 나머지는 사소합니다. P제품을 가져옵니다 ($\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$ )>이 곱에 1을 더한fW다음 최소 소수를 검색합니다.

J , 15 바이트

마일 덕분에 -10 바이트!

@miles 덕분에 최대 n까지 시퀀스 반환 (제로 인덱스)

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

온라인으로 사용해보십시오!

J , 25 바이트

nth 항목을 반환

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

온라인으로 사용해보십시오!

파이썬 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제 입력으로하고 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`
.$

\*
,

온라인으로 사용해보십시오! 첫 번째 줄에 추가 할 새 용어 수를 입력하고 두 번째 줄에 시드 용어를 입력합니다. 참고 : 단항 인수 분해를 사용하므로 속도가 매우 느려서 관련 길이의 문자열을 작성해야합니다. 설명:

,|$
$*

시드 용어에서 쉼표를 *s로 바꾸고을 추가하십시오 *. 값의 곱 길이의 문자열에 대한 Retina 표현식을 작성합니다.

"$&"{
)`

첫 번째 입력에 의해 주어진 횟수만큼 루프를 반복하십시오.

~`.+¶
$$¶_

첫 번째 줄의 숫자를 일시적으로 a로 바꾸고 두 번째 줄 $앞에 a _를 붙인 다음 결과를 Retina 프로그램으로 평가하여 _길이가 1 인 문자열을 값의 곱보다 더합니다.

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

소수에서 가장 작은 숫자의 소수를 10 진수로 찾고 *다음 루프에 대한 준비를 추가하십시오 .

1A`

반복 입력을 삭제하십시오.

.$

마지막을 삭제하십시오 *.

\*
,

나머지 *s를 ,s로 교체하십시오 .

자바 스크립트 (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

루비 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.

Pari / GP , 47 바이트

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

온라인으로 사용해보십시오!

Stax , 9 바이트

é|G╝╓c£¼_

실행 및 디버깅

입력을 위해 (0 인덱스) 를 취 합니다. 생산 합니다.p0npn

C (gcc) , 54 53 바이트

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

온라인으로 사용해보십시오!

ceilingcat 덕분에 -1 바이트

펄 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

하스켈 , 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