Los primos recursivamente primos son una secuencia de primos tales que

p(1) = 2
p(n) = the p(n-1)th prime

Aquí hay un ejemplo de cómo se podría calcular el 4º Recursively Prime Prime.

p(4) = the p(3)th prime
p(3) = the p(2)th prime
p(2) = the p(1)th prime
p(1) = 2
p(2) = the 2nd prime
p(2) = 3
p(3) = the 3rd prime
p(3) = 5
p(4) = the 5th prime
p(4) = 11

Debe escribir un programa o función que, cuando se le da n, genera el enésimo Recursively Prime Prime.

Puede elegir usar indexación basada en 0 si lo desea, en cuyo caso debe indicarlo en su respuesta.

Este es el código de golf, por lo que el objetivo es minimizar el recuento de bytes.

Casos de prueba

1 -> 2
2 -> 3
3 -> 5
4 -> 11
5 -> 31
6 -> 127
7 -> 709
8 -> 5381
9 -> 52711

Entrada relevante de OEIS: OEIS A007097

Oasis , 3 bytes

El programa está indexado a 0 . Código:

<q2

Utiliza la fórmula: a (n) = nth_prime (a (n-1) - 1) , con el caso base a (0) = 2 .

Explicación del código:

  2   = a(0)

<     # Decrement a(n - 1) to get a(n - 1) - 1
 q    # prime(a(n - 1) - 1)

Pruébalo en línea!

En realidad , 7 bytes

1@⌠DP⌡n

Pruébalo en línea!

Explicación:

1@⌠DP⌡n
1        push 1
 @       swap 1 with n
  ⌠DP⌡n  do the following n times:
   DP      decrement, prime at index

Mathematica, 16 bytes

Nest[Prime,1,#]&

Función anónima. Toma un número como entrada y devuelve un número como salida.

Jalea , 5 4 bytes

1 byte gracias a @Dennis.

1ÆN¡

Pruébalo en línea!

Explicación

1        Starting with n = 1,
 ÆN      replace n by the nth prime
   ¡     (input) times.

JavaScript (ES6), 71 bytes

p=(n,x=1)=>n?p(n-1,(N=y=>x?N(++y,x-=(P=z=>y%--z?P(z):z==1)(y)):y)(1)):x

Ungolfed, tienes tres funciones recursivas separadas:

P=(n,x=n)=>n%--x?P(n,x):x==1
N=(n,x=1)=>n?N(n-P(++x),x):x
p=(n,x=1)=>n?p(n-1,N(x)):x

• Pdetermina si nes primo;
• Nencuentra el nth prime;
• pSe ejecuta recursivamente Nen 1 ntiempos de entrada .

MATL , 6 bytes

1i:"Yq

Pruébalo en línea!

Explicación

1      % Push 1
i      % Input n
:      % Range [1 2 ... N]
"      % For each (that is, do the following N times)
  Yq   %   k-th prime, where k is the input
       % End for each (implicit)
       % Display stack (implicit)

R, 98 93 bytes

5 bytes gracias a @smci

Aquí hay una solución recursiva horriblemente ineficiente:

f<-function(m,n=1){j<-1;for(i in 1:n){j<-numbers::nextPrime(j)};a<-ifelse(m==0,j,f(m-1,j));a}

Prueba de salida:

f(6)
[1] 127

f(10)        ### takes almost a minute... YIKES!!!
[1] 648391

Bash + utilidades comunes, 55

Como estamos haciendo primos recursivos, aquí hay una respuesta recursiva:

((SHLVL-2<$1))&&primes 2|sed -n "`$0 $1`{p;q}"||echo 1

Dado que el recuento de niveles de recursión se basa en la $SHLVLvariable incorporada, la respuesta puede estar desactivada si ya tiene unos pocos niveles de shell. Esta es probablemente la razón por la cual esta respuesta no funciona en TIO.

Si eso no es bueno, entonces aquí hay una respuesta más convencional:

Bash + utilidades comunes, 58

for((i=$1;i--;));{
n=`primes 2|sed -n "$n{p;q}"`
}
echo $n

Pruébalo en línea .

Haskell , 58 bytes

1 indexado

f 1=2;f n=[x|x<-[2..],all((>)2.gcd x)[2..x-1]]!!(f(n-1)-1)

Pruébalo en línea!

Explicación:

Utiliza el mismo truco de acceso a la lista principal indexado en 0 que la respuesta de Adnan .
Esencialmente directo sigue la especificación de lo contrario.

f 1=2; -- base case
f n= -- main case
    [x|x<-[2..],all((>)2.gcd x)[2..x-1]]             -- list of all primes
    [x|x<-[2..],                                     -- consider all numbers
                               [2..x-1]              -- consider all smaller numbers
                all((>)2.gcd x)                      -- is coprime with them?
                    (>)2.                            -- 2 is greater than
                         gcd x                       -- gcd(x,lambda input)
                                        !!(f(n-1)-1) -- access the
                                                     -- f(n-1)-th 1-indexed prime

05AB1E , 4 bytes

ÎF<Ø

Pruébalo en línea!

Explicación

ÎF<Ø
Î    # Push 0 and input
 F   # Do input times...
  <   # Decrement
   Ø  # Get the nth prime (0-indexed) with n being the top of the stack

Maravilla , 23 bytes

p\.{1\2@:^(- p -#0 1)1P

1 indexado. Uso:

p\.{1\2@:^(- p -#0 1)1P}; p 3

Explicación

p\.{                #. Pattern matching syntax
  1\2               #. Base case p(1)=2
  @:^(- p -#0 1)1P  #. Other cases p(n)=nthprime(p(n-1)-1)
                    #. nthprime is 0-indexed
}                   #. Trailing bracket is optional in this case