Da Euclide, sappiamo che ci sono infiniti numeri primi. L'argomento è per assurdo: se ci sono solo un numero finito, diciamo $p_1,p_2,...,p_n$ , quindi sicuramente $m:=p_1\cdot p_2\cdot...\cdot p_n+1$ non è divisibile per nessuno di questi numeri primi, quindi la sua scomposizione in fattori primi deve produrre un nuovo numero primo non presente nell'elenco. Quindi il presupposto che esistano solo numeri primi fini è falso.

Ora supponiamo che $2$ sia l'unico primo. Il metodo di cui sopra produce $2+1=3$ come nuovo (possibile) primo. Applicare nuovamente il metodo produce $2\cdot 3+1=7$ , quindi $2\cdot 3\cdot 7+1=43$ , quindi $2\cdot 3\cdot 7\cdot 43+1=13\cdot 139$ , quindi sia $13$ che $139$sono nuovi numeri primi, ecc. Nel caso in cui otteniamo un numero composto, prendiamo solo il primo nuovo. Ciò si traduce in A000945 .

Sfida

Dato un primo $p_1$ e un numero intero $n$ calcolare il $n$ termine -esimo $p_n$ della sequenza definita come segue:

Queste sequenze sono note come conseguenze di Euclide-Mullin .

Esempi

Per $p_1 = 2$ :

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

Per $p_1 = 5$ ( A051308 ):

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

Per $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 byte

Accetta input come (n)(p1), dove è indicizzato 0.$n$

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

Provalo online!

Commentate

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 byte

Questo produce un flusso di output infinito.

λλP>fW

Provalo online! (il link include una versione leggermente modificata λ£λP>fW, che invece genera i primi termini)$n$

Spiegazione

Molto semplice. Dati e , il programma procede come segue:$p_1$$n$

• Inizia con come parametro iniziale per lo stream infinito (che viene generato utilizzando il primo ) e inizia un ambiente ricorsivo che genera un nuovo termine dopo ogni interazione e lo aggiunge allo stream.$p_1$λ
• Il secondo λ, ora utilizzato all'interno dell'ambiente ricorsivo, cambia la sua funzionalità: ora recupera tutti gli elementi precedentemente generati (ovvero l'elenco ), dove rappresenta il numero di iterazione corrente.$[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$$n$
• Il resto è banale: Pprende il prodotto ( ), ne aggiunge uno a questo prodotto e recupera il fattore primo minimo.$\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$>fW

J , 15 byte

-10 byte grazie alle miglia!

Restituendo la sequenza fino a n (indicizzato zero) - grazie a @miles

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

Provalo online!

J , 25 byte

Restituisce l' nelemento th

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

Provalo online!

Python 2 , 56 byte

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

Provalo online!

Commentate

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

Provalo online!

Gelatina , 8 byte

P‘ÆfṂṭµ¡

Un programma completo (che utilizza l'indicizzazione zero) che accetta e che stampa una rappresentazione Jelly dell'elenco di su incluso. (Come collegamento diadico, con ci verrà restituito un numero intero, non un elenco.)$P_0$$n$$P_0$$P_n$n=0

Provalo online!

Come?

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 byte

GDˆ¯P>fß

Il primo input è , il secondo è prime .$n$$p$

Provalo online o molti altri casi di test (nella suite di test mancano i casi di test per , perché per e l'integrato impiega troppo tempo).$n\geq9$$p=2$$p=5$f

Spiegazione:

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 byte

Lottato per ottenere questo giusto quindi potrebbe aver perso qualcosa che può essere giocato a golf.

Prende ncome primo input e p1, come matrice singleton, come secondo. Restituisce i primi ntermini. Passare ha gper restituire ninvece il termine con indice 0.

@Z×Ä k Î}hV

Provalo

@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

Retina , 56 byte

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

\*
,

Provalo online! Prende l'input come numero di nuovi termini da aggiungere nella prima riga e come termine (i) iniziale (i) nella seconda riga. Nota: diventa molto lento poiché utilizza la fattorizzazione unaria, quindi deve creare una stringa della lunghezza pertinente. Spiegazione:

,|$
$*

Sostituisci le virgole nei termini seed con se *aggiungi a *. Questo crea un'espressione Retina per una stringa di lunghezza del prodotto dei valori.

"$&"{
)`

Ripeti il ​​ciclo il numero di volte dato dal primo input.

~`.+¶
$$¶_

Sostituire temporaneamente il numero sulla prima riga con a $e anteporre _a alla seconda riga, quindi valutare il risultato come un programma Retina, aggiungendo così una stringa di _s di lunghezza 1 in più rispetto al prodotto dei valori.

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

Trova il più piccolo fattore non banale del numero in decimale e aggiungi un *pronto per il ciclo successivo.

1A`

Elimina l'input dell'iterazione.

.$

Elimina l'ultimo *.

\*
,

Sostituisci le rimanenti *s con ,s.

JavaScript (Node.js) , 54 byte

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

Provalo online!

Ungolfed

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 byte

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

TIO

Ruby 2.6, 51 byte

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

(2..), l'intervallo infinito a partire da 2, non è ancora supportato su TIO.

Questa è una funzione ricorsiva che accetta un valore iniziale s(può essere un numero primo o un composto), lo restituisce quando n = 0 (modifica: nota che ciò significa che è indicizzato a zero), restituisce il numero minimo lmaggiore di 1 e divide -(s+1)quando n = 1, e altrimenti ricorre con s=l*se n=n-1.

APL (Dyalog Extended) , 15 byte

Questa è un'implementazione abbastanza semplice dell'algoritmo che utilizza i fattori primi molto utili incorporati di Extended ⍭. Provalo online!

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

Spiegazione

{⍵,⊃⍭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 byte

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

Provalo online!

Stax , 9 byte

é|G╝╓c£¼_

Esegui ed esegui il debug

Prende e (indicizzato zero) per l'input. Produce .p0npn

C (gcc) , 54 53 byte

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

Provalo online!

-1 byte grazie a ceilingcat

Perl 6 , 33 32 byte

-1 byte grazie a nwellnhof

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

Provalo online!

Blocco di codice anonimo che accetta un numero e restituisce un elenco pigro.

Spiegazione:

{                              }  # 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 byte

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

Provalo online!

Restituisce la sequenza infinita come un elenco pigro.

Spiegazione:

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