Para el propósito de este desafío, una potencia primaria de una prima (PPP) se define como un número que se puede definir como un número primo de la potencia de un número primo. Por ejemplo, 9 es un PPP porque se puede representar como 3 ^ 2. 81 por otro lado no es un PPP porque solo se puede representar como 3 ^ 4, y 4 no es primo. Las primeras PPP son: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Esta es la secuencia OEIS A053810

Tu tarea:

Escriba un programa o función que, para un número entero de entrada, n devuelva / produzca el enésimo PPP, ya sea 1 indexado o 0 indexado, lo que prefiera.

Entrada:

Un entero entre 0 y 1,000, recibido a través de cualquier método razonable.

Salida:

El PPP en el índice indicado por la entrada.

Casos de prueba:

Estos están indexados en 1 y, por lo tanto, si su programa toma una entrada indexada en 0, se debe llegar a la misma salida para la entrada establecida: 1.

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

Puntuación:

¡Este código de golf , gana la puntuación más baja en bytes!

05AB1E (legado) ,  9  7 bytes

Guardado 2 bytes gracias a @KevinCruijssen

µNÓ0Kp»

Pruébalo en línea!

µ           # 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

Casco , 10 bytes

!fȯṗ§*ELpN

Pruébalo en línea!

Explicación

!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.

Realmente , 14 bytes

Basado en la solución Pyth del Sr. Xcoder . Sugerencias de golf bienvenidas. Pruébalo en línea!

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

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

Pruébalo en línea!

pero Martin Ender tuvo una mejor idea y ahorró 6 bytes

Mathematica, 42 bytes

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

Pruébalo en línea!

Jalea , 12 11 10 bytes

1 byte gracias a Dennis.

ÆN€*þ`FṢị@

Pruébalo en línea!

Números R +, 57 bytes

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

Pruébalo en línea!

outer Es una función tan útil.

Bastante seguro de que esto siempre funcionará. Haré una discusión formal cuando tenga tiempo.

Haskell , 95 85 80 bytes

-10 bytes gracias a @Lynn
-5 bytes gracias a @WillNess

Basado en 0

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

Pruébalo en línea!

Explicación

(!!)                    -- 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 bytes

• Se guardaron seis bytes utilizando en input()lugar de definir una función.
• Guardado cuatro bytes gracias a Felipe Nardi Batista ; fusionando dos bucles.
• Ahorró dieciséis bytes gracias a ASCII solo .
• Guardado un byte gracias a 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

Pruébalo en línea!

Pyth , 15 bytes

e.f/^FR^fP_TSZ2

Pruébalo aquí! o Verificar más casos de prueba.

Explicación

ef / ^ FR ^ fP_TSZ2 - Programa completo. Q significa entrada.

 .f - Primeras entradas Q con resultados verdaderos. Utiliza la variable Z.
        fP_TSZ - Filtra el rango [1, Z] para primos.
       ^ 2 - Cuadrado cartesiano. Básicamente el producto cartesiano consigo mismo.
    ^ FR - Reduce cada lista por exponenciación.
  / - Cuenta las ocurrencias de Z en ^.
e - Último elemento.

Javascript 137 133 bytes

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))

** algoritmo normal (resultado de 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 bytes

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

Pruébalo en línea!

Explicación

{⍵⌷∧∊∘.*⍨¯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 bytes

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

Pruébalo en línea!

  (^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

Las razones para el 24 y 7028 son que el valor más grande (n = 1000) es 49378729, que es 7027 ^ 2, y la mayor potencia prima de 2 que se ajusta por debajo es 23. Entonces, cubriendo 2..7027 ^ 2 .. 23 incluye todos los artículos en los primeros 1000 (y muchos repuestos).

Pyth - 13 bytes

e.f&P_lPZ!t{P

Test Suite .

PARI / GP, 48 bytes

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

Si no cuentas el f(n)= parte, son 43 bytes.

Otro enfoque sin la notación establecida que no verifica tantos casos innecesarios:

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

Java 8, 211 bytes

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étodo muy ineficiente. Básicamente, calcula todos los PPP del 2 ² al 999 ⁹⁹⁹ 132 ¹³² y los almacena en una Lista, luego los ordena y luego obtiene eln 'ítem de esa Lista.

EDITAR: en lugar de usar 999 ⁹⁹⁹ que da como resultado una Lista de 28,225 artículos, ahora uso 132 ¹³² que da como resultado una Lista de solo 1,024 artículos. Esto mejora bastante el rendimiento y es perfectamente aceptable ya que el desafío establece que debemos admitir una entrada del índice 0 al 1,000. (Sin embargo, cambiar 1e3a 132no afecta el recuento de bytes).

Explicación:

Pruébalo aquí

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 bytes

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

Función anónima indexada a cero.

Pruébalo en línea!

Intento volver al ritmo de las cosas, pero parece que he olvidado todos los trucos para hacer buenas cadenas monádicas.

Explicación breve

Construye una tabla de potencias primarias desde la prima 0 hasta la prima en el índice de la entrada más 1 (para dar cuenta de 0). Aplana esta lista, la ordena y luego la indexa. Ahora me doy cuenta de que esto podría dar resultados incorrectos para algunos valores, ya que la tabla podría no ser lo suficientemente grande; en ese caso, editaría en un valor codificado como 1e4 que debería ser suficiente. No puedo probarlo de una forma u otra (pasa por los casos de prueba dados), así que avíseme si esto es un problema.

También 21 bytes

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