Les nombres premiers récursivement sont une séquence de nombres premiers tels que

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

Voici un exemple de la façon dont on pourrait calculer le 4ème Prime Prime récursivement.

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

Vous devez écrire un programme ou une fonction qui, lorsque n est donné, génère le nième Prime Prime récursivement.

Vous pouvez choisir d'utiliser l'indexation basée sur 0 si vous le souhaitez, auquel cas vous devez l'indiquer dans votre réponse.

Il s'agit de code-golf , l'objectif est donc de minimiser le nombre d'octets.

Cas de test

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

Entrée OEIS pertinente: OEIS A007097

Oasis , 3 octets

Le programme est indexé 0 . Code:

<q2

Utilise la formule: a (n) = nth_prime (a (n-1) - 1) , avec le cas de base a (0) = 2 .

Explication du code:

  2   = a(0)

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

Essayez-le en ligne!

En fait , 7 octets

1@⌠DP⌡n

Essayez-le en ligne!

Explication:

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

Mathematica, 16 octets

Nest[Prime,1,#]&

Fonction anonyme. Prend un nombre en entrée et renvoie un nombre en sortie.

Gelée , 5 4 octets

1 octet grâce à @Dennis.

1ÆN¡

Essayez-le en ligne!

Explication

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

JavaScript (ES6), 71 octets

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

Non golfé, vous avez trois fonctions récursives distinctes:

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

• Pdétermine si nest premier;
• Ntrouve le ne premier;
• pfonctionne récursivement Nsur les 1 ntemps d' entrée .

MATL , 6 octets

1i:"Yq

Essayez-le en ligne!

Explication

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 octets

5 octets grâce à @smci

Voici une solution récursive horriblement inefficace:

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}

Sortie de test:

f(6)
[1] 127

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

Bash + utilitaires communs, 55

Puisque nous faisons des nombres premiers récursifs, voici une réponse récursive:

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

Étant donné que le comptage des niveaux de récursivité est basé sur la $SHLVLvariable intégrée, la réponse peut être désactivée si vous avez déjà quelques niveaux de shell en profondeur. C'est probablement pourquoi cette réponse ne fonctionne pas sur TIO.

Si ce n'est pas bon, voici une réponse plus conventionnelle:

Bash + utilitaires communs, 58

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

Essayez-le en ligne .

Haskell , 58 octets

1 indexé

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

Essayez-le en ligne!

Explication:

Utilise la même astuce d'accès à la liste principale indexée 0 que la réponse d'Adnan .
Sinon, le rectangle suit la spécification autrement.

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 octets

ÎF<Ø

Essayez-le en ligne!

Explication

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

Wonder , 23 octets

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

1 indexé. Usage:

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

Explication

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