Aux fins de ce défi, une puissance première d'un nombre premier (PPP) est définie comme un nombre qui peut être défini comme un nombre premier à la puissance d'un nombre premier. Par exemple, 9 est un PPP car il peut être représenté par 3 ^ 2. 81 d'autre part n'est pas un PPP car il ne peut être représenté que par 3 ^ 4, et 4 n'est pas premier. Les premiers PPP sont: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Il s'agit de la séquence OEIS A053810

Ta tâche:

Écrivez un programme ou une fonction qui, pour un entier d'entrée n, retourne / sort le nième PPP, indexé 1 ou indexé 0, selon votre préférence.

Contribution:

Un entier compris entre 0 et 1 000, reçu par toute méthode raisonnable.

Production:

Le PPP à l'index indiqué par l'entrée.

Cas de test:

Ceux-ci sont indexés 1, et donc, si votre programme prend une entrée indexée 0, la même sortie doit être obtenue pour l'entrée indiquée - 1.

3  -> 9
6  -> 32
9  -> 125

Notation:

Ce code-golf , le score le plus bas en octets gagne!

05AB1E (hérité) ,  9  7 octets

Enregistré 2 octets grâce à @KevinCruijssen

µNÓ0Kp»

Essayez-le en ligne!

µ           # while counter_variable != input:
 N          #   push iteration counter                       e.g. 125
  Ó         #   get prime exponents                          -> [0, 0, 3]
   0K       #   filter out zeros                             -> [3]
     p      #   is prime?                                    -> [1]
      »     #   join with newlines: we use » instead of J
            #   so that [0,1] is not interpreted as truthy   -> 1
            #   implicit: if 1, increment counter_variable

Husk , 10 octets

!fȯṗ§*ELpN

Essayez-le en ligne!

Explication

!fȯṗ§*ELpN  Implicit input.
 f       N  Filter the natural numbers by this function:
  ȯṗ§*ELp    Argument is a number, say 27.
        p    Prime factors: [3,3,3]
       L     Length: 3
      E      Are all elements equal: 1
    §*       Multiply last two: 3
  ȯṗ         Is it prime? Yes, so 27 is kept.
!           Index into remaining numbers with input.

En fait , 14 octets

Basé sur la solution Pyth de M. Xcoder . Suggestions de golf bienvenues. Essayez-le en ligne!

;ur♂P;∙⌠iⁿ⌡MSE

Ungolfing

                Implicit input n
;ur             Duplicate and push [0..n]
   ♂P           Push the 0th to nth primes
     ;∙         Push Cartesian square of the primes
       ⌠iⁿ⌡M    Reduce each list in the Cartesian square by exponentiation
            SE  Sort the list and get the nth index (0-indexed)

Mathematica, 48 octets

Sort[Join@@Array[(p=Prime)@#^p@#2&,{#,#}]][[#]]&   

Essayez-le en ligne!

mais Martin Ender a eu une meilleure idée et a économisé 6 octets

Mathematica, 42 octets

Sort[Power@@@Prime@Range@#~Tuples~2][[#]]&   

Essayez-le en ligne!

Gelée , 12 11 10 octets

1 octet merci à Dennis.

ÆN€*þ`FṢị@

Essayez-le en ligne!

Numéros R +, 57 octets

function(n,x=numbers::Primes(2*n))sort(outer(x,x,"^"))[n]

Essayez-le en ligne!

outer est une fonction très pratique.

Assez certain que cela fonctionnera toujours. Fera un argument formel quand j'aurai le temps.

Haskell , 95 85 80 octets

-10 octets grâce à @Lynn
-5 octets grâce à @WillNess

Basé sur 0

(!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]

Essayez-le en ligne!

Explication

(!!)                    -- point-free expression, partially evaluate index-access operator
[x|x<-[2..]             -- consider all integers x>=2
,p<-                    -- let p be the list of all primes <=x
[[                      -- list of a list so p ends up as a list
i|i<-[2..x],            -- consider all i<=x to be potentially prime
all((>)2.gcd i)[2..i-1] -- if the gcd of i with all smaller integers is
                        -- smaller than 2 then this i is actually prime
 ]],or                  -- if any of the following list entries is true
[y^e==x|                -- the condition y^e==x holds for x with ...
e<-p,y<-p]              -- y and e being prime, i.e. x is a PPP,
]                       -- then add this x to the output sequence / list

Python 2 , 163 157 137 136 octets

• Enregistré six octets en utilisant input()plutôt qu'en définissant une fonction.
• Enregistré quatre octets grâce à Felipe Nardi Batista ; fusion de deux boucles.
• Seize octets enregistrés grâce à ASCII uniquement .
• Enregistré un octet grâce à ArBo .

p=input();r=i=0;e=lambda p:all(p%d for d in range(2,p))
while~-i<p:
 r+=1
 for x in range(r*r):y=x%r;x/=r;i+=x**y==r>e(x)>0<e(y)
print r

Essayez-le en ligne!

Pyth , 15 octets

e.f/^FR^fP_TSZ2

Essayez-le ici! ou Vérifiez plus de cas de test.

Explication

ef / ^ FR ^ fP_TSZ2 - Programme complet. Q signifie entrée.

 .f - Premières entrées Q avec des résultats véridiques. Utilise la variable Z.
        fP_TSZ - Filtre la plage [1, Z] pour les nombres premiers.
       ^ 2 - Carré cartésien. Fondamentalement, le produit cartésien avec lui-même.
    ^ FR - Réduisez chaque liste par exponentiation.
  / - Comptez les occurrences de Z dans ^.
e - Dernier élément.

Javascript 137 133 octets

P=n=>{for(p=[i=2];j=++i<n*9;j^i&&p.push(i))
for(;j*j<=i;)j=i%++j?j:i
x=[]
for(i of p)
for(j of p)
x[i**j]=1
return Object.keys(x)[n]}

console.log(P(1000))
console.log(P(800))
console.log(P(9))
console.log(P(5))

** algorithme normal (résultat 100 ms) P = n => {

  for(p=[i=2];f=++i<=n*10;!f||p.push(i))
    for(j=0;f&&(x=p[j++])*x<=i;)
      f=i%x
  x=[]
  T=0
  for(i of p)
  for(j of p)
  {
    l= i**j
    if(++T>n &&x.length<l )
    break
    x[l] = 1
  }
  return Object.keys(x)[n]
}

APL (Dyalog Extended) , 15 octets

{⍵⌷∧∊∘.*⍨¯2⍭⍳⍵}

Essayez-le en ligne!

Explication

{⍵⌷∧∊∘.*⍨¯2⍭⍳⍵}

              ⍵   Right argument. Our input.
{              }  Wraps the function in dfn syntax which allows us to use ⍵.
             ⍳     Range [1..⍵].
          ¯2⍭     Get the n-th prime for each n in the range.
      ∘.*⍨        Get the prime powers of each prime.
     ∊            Flatten the list.
    ∧             In Extended, this is monadic sort ascending.
 ⍵⌷               Get the input-th index of the list of prime powers of primes.

Perl 6 , 50 octets

{(sort [X**] (^7028,^24)>>.grep(&is-prime))[$_-1]}

Essayez-le en ligne!

  (^7028,^24)            # create 2 ranges from 0
     >>.grep(&is-prime)  # grep for primes in both
 [X**] ...               # calc each exponential pair (2^2, 2^3, 2^5...)
(sort ... )[$_-1]        # sort and get value at index n-1

Les raisons des 24 et 7028 sont que la plus grande valeur (n = 1000) est 49378729, ce qui est 7027 ^ 2, et la plus grande puissance principale de 2 qui rentre en dessous est 23. Donc, couvrant 2..7027 ^ 2 .. 23 comprend tous les articles des 1000 premiers (et beaucoup de pièces de rechange).

Pyth - 13 octets

e.f&P_lPZ!t{P

Suite de tests .

PARI / GP, 48 octets

f(n)=[x|x<-[1..4^n],isprime(isprimepower(x))][n]

Si vous ne comptez pas la f(n)=partie, c'est 43 octets.

Une autre approche sans la notation d'ensemble qui ne vérifie pas autant de cas inutiles:

f(n)=c=0;i=1;while(c<n,i++;isprime(isprimepower(i))&&c++);i

Java 8, 211 octets

import java.util.*;n->{List l=new Stack();for(int a=2,b;a<132;a++)for(b=2;b<132;b++)if(p(a)*p(b)>0)l.add(Math.pow(a,b));Collections.sort(l);return l.get(n);}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Méthode très inefficace. Elle calcule essentiellement tous les PPP de 2 ² à 999 ⁹⁹⁹ 132 ¹³² et les stocke dans une liste, puis trie cette liste, puis obtient le n'e élément de cette liste.

EDIT: Au lieu d'utiliser 999 ^999, ce qui donne une liste de 28 225 éléments, j'utilise maintenant 132 ^132, ce qui donne une liste de 1 024 éléments seulement. Cela améliore considérablement les performances et est parfaitement acceptable car le défi indique que nous devons prendre en charge une entrée de l'index 0 à 1000. (Changement 1e3en132 n'affecte pas le nombre d'octets, cependant.)

Explication:

Essayez-le ici.

import java.util.*;           // Required import for List, Stack and Collections

n->{                          // Method with integer as parameter and Object as return-type
  List l=new Stack();         //  List to store the PPPs in
  for(int a=2,b;a<132;a++)    //  Loop (1) from 2 to 1,000 (exclusive)
    for(b=2;b<132;b++)        //   Inner loop (2) from 2 to 1,000 (exclusive)
      if(p(a)*p(b)>0)         //    If both `a` and `b` are primes:
        l.add(Math.pow(a,b)); //     Add the power of those two to the List
                              //   End of loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  Collections.sort(l);        //  Sort the filled List
  return l.get(n);            //  Return the `n`'th item of the sorted List of PPPs
}                             // End of method

int p(int n){                 // Separated method with integer as parameter and return-type
  for(int i=2;                //  Index integer (starting at 2)
      i<n;                    //  Loop from 2 to `n` (exclusive)
    n=n%i++<1?                //   If `n` is divisible by `i`:
       0                      //    Change `n` to 0
      :                       //   Else:
       n                      //    Leave `n` the same
  );                          //  End of loop
  return n;                   //  Return `n` (which is now 0 if it wasn't a prime)
}                             // End of separated method

J, 21 octets

{[:/:~@,[:^/~p:@i.@>:

Fonction anonyme zéro indexée.

Essayez-le en ligne!

En essayant de revenir dans le swing des choses, mais il me semble avoir oublié toutes les astuces pour faire de bonnes chaînes monadiques.

Brève explication

Construit un tableau des puissances premières du 0e premier au premier à l'indice de l'entrée plus 1 (pour tenir compte de 0). Aplatit cette liste et la trie, puis l'indexe. Je me rends compte maintenant que cela pourrait donner des résultats incorrects pour certaines valeurs car la table n'est peut-être pas assez grande - dans ce cas, je modifierais une valeur codée en dur comme 1e4, ce qui devrait suffire. Je ne peux pas le prouver dans un sens ou dans l'autre (il passe pour les cas de test donnés), alors faites-moi savoir si c'est un problème.

Aussi 21 octets

3 :'y{/:~,^/~p:i.>:y'