Desde Euclides, hemos sabido que hay infinitos números primos. El argumento es por contradicción: si solo hay muchos, digamos , entonces seguramente no es divisible por ninguno de estos primos, por lo que su factorización prima debe producir un nuevo primo que no estaba en la lista. Entonces, la suposición de que solo existen primos finitos es falsa.$p_1,p_2,...,p_n$$m:=p_1\cdot p_2\cdot...\cdot p_n+1$

Ahora supongamos que es el único primo. El método de arriba produce como un nuevo (posible) primo. Aplicar el método nuevamente produce , y luego , luego , entonces ambos 13 y 139 son primos nuevos, etc. En el caso de que obtengamos un número compuesto, simplemente tomamos el primo menos nuevo. Esto da como resultado 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$

Reto

Dado un primer $p_1$ y un entero $n$ calcular el $n$ -ésimo término $p_n$ de la secuencia definida como sigue:

Estas secuencias se conocen como secuencias de Euclid-Mullin .

Ejemplos

Para :$p_1 = 2$

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

Para ( A051308 ):$p_1 = 5$

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

Para ( A051330 )$p_1 = 97$

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

JavaScript (ES6),  45  44 bytes

Toma la entrada como (n)(p1), donde está indexada a 0.$n$

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

Pruébalo en línea!

Comentado

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 bytes

Esto produce un flujo de salida infinito.

λλP>fW

Pruébalo en línea! (el enlace incluye una versión ligeramente modificada λ£λP>fW, que en su lugar genera los primeros términos)$n$

Explicación

Muy sencillo Dado y , el programa hace lo siguiente:$p_1$$n$

• Comienza con como parámetro inicial para la secuencia infinita (que se genera utilizando la primera ) y comienza un entorno recursivo que genera un nuevo término después de cada interacción y lo agrega a la secuencia.$p_1$λ
• El segundo λ, que ahora se usa dentro del entorno recursivo, cambia su funcionalidad: ahora, recupera todos los elementos generados previamente (es decir, la lista ), donde representa el número de iteración actual.$[\lambda_0, \lambda_1, \lambda_2, \ldots, \lambda_{n-1}]$$n$
• El resto es trivial: Ptoma el producto ( $\lambda_0\lambda_1\lambda_2 \cdots \lambda_{n-1}$ ), >agrega uno a este producto y fWrecupera el factor primo mínimo.

J , 15 bytes

-10 bytes gracias a millas!

Devolviendo la secuencia hasta n (indexado a cero) - gracias a @miles

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

Pruébalo en línea!

J , 25 bytes

Devuelve el nelemento th

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

Pruébalo en línea!

Python 2 , 56 bytes

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

Pruébalo en línea!

Comentado

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

Pruébalo en línea!

Jalea , 8 bytes

P‘ÆfṂṭµ¡

$P_0$$n$$P_0$$P_n$n=0

Pruébalo en línea!

¿Cómo?

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 bytes

GDˆ¯P>fß

$n$$p$

$n\geq9$$p=2$$p=5$f

Explicación:

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 bytes

Luchó por hacer esto bien, por lo que puede haberse perdido algo que se puede jugar al golf.

Toma ncomo la primera entrada y p1, como una matriz singleton, como la segunda. Devuelve los primeros ntérminos. Cambie ha gpara devolver el ntérmino indexado th 0 en su lugar.

@Z×Ä k Î}hV

Intentalo

@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 bytes

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

\*
,

Pruébalo en línea! Toma datos como el número de términos nuevos que se agregarán en la primera línea y los términos semilla en la segunda línea. Nota: Se vuelve muy lento ya que usa factorización unaria, por lo que necesita crear una cadena de la longitud relevante. Explicación:

,|$
$*

Reemplace las comas en los términos semilla con *sy agregue a *. Esto crea una expresión Retina para una cadena de longitud del producto de los valores.

"$&"{
)`

Repita el bucle el número de veces dado por la primera entrada.

~`.+¶
$$¶_

Reemplace temporalmente el número en la primera línea con a $y anteponga a _a la segunda línea, luego evalúe el resultado como un programa Retina, agregando así una cadena de _s de longitud 1 más que el producto de los valores.

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

Encuentre el factor no trivial más pequeño del número en decimal y agregue un *listo para el siguiente ciclo.

1A`

Eliminar la entrada de iteración.

.$

Eliminar el último *.

\*
,

Reemplace los *s restantes con ,s.

JavaScript (Node.js) , 54 bytes

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

Pruébalo en línea!

Sin golf

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 bytes

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

TIO

Ruby 2.6, 51 bytes

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

(2..), el rango infinito a partir de 2, todavía no es compatible con TIO.

Esta es una función recursiva que toma un valor inicial s(puede ser primo o compuesto), lo devuelve cuando n = 0 (editar: tenga en cuenta que esto significa que está indexado a cero), devuelve el menor número lque es mayor que 1 y se divide -(s+1)cuando n = 1, y de lo contrario se repite con s=l*sy n=n-1.

APL (Dyalog Extended) , 15 bytes

Esta es una aplicación bastante sencilla del algoritmo que utiliza extendidas de factores primos muy votos orden interna, ⍭. Pruébalo en línea!

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

Explicación

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

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

Pruébalo en línea!

Stax , 9 bytes

é|G╝╓c£¼_

Ejecutar y depurarlo

Toma y (indexado a cero) para la entrada. Produce .p0npn

C (gcc) , 54 53 bytes

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

Pruébalo en línea!

-1 byte gracias a ceilingcat

Perl 6 , 33 32 bytes

-1 byte gracias a nwellnhof

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una lista perezosa.

Explicación:

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

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

Pruébalo en línea!

Devuelve la secuencia infinita como una lista perezosa.

Explicación:

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