Para o objetivo deste desafio, um Poder Primário de um Primário (PPP) é definido como um número que pode ser definido como um número primo à potência de um número primo. Por exemplo, 9 é um PPP porque pode ser representado como 3 ^ 2. 81 por outro lado, não é um PPP, porque só pode ser representado como 3 ^ 4 e 4 não é primo. As primeiras PPPs são: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Esta é a sequência O0IS A053810

Sua tarefa:

Escreva um programa ou função que, para um número inteiro de entrada n, retorne / produza a enésima PPP, indexada em 1 ou indexada em 0, conforme sua preferência.

Entrada:

Um número inteiro entre 0 e 1.000, recebido por qualquer método razoável.

Resultado:

A PPP no índice indicado pela entrada.

Casos de teste:

Eles são indexados em 1 e, portanto, se o seu programa receber entrada indexada em 0, a mesma saída deverá ser alcançada para a entrada declarada - 1.

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

Pontuação:

Esse código de golfe , a menor pontuação em bytes, ganha!

05AB1E (herdado) ,  9  7 bytes

Guardado 2 bytes graças a @KevinCruijssen

µNÓ0Kp»

Experimente online!

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

Casca , 10 bytes

!fȯṗ§*ELpN

Experimente online!

Explicação

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

Na verdade , 14 bytes

Baseado na solução Pyth do Sr. Xcoder . Sugestões de golfe são bem-vindas. Experimente online!

;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&,{#,#}]][[#]]&   

Experimente online!

mas Martin Ender teve uma ideia melhor e salvou 6 bytes

Mathematica, 42 bytes

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

Experimente online!

Geléia , 12 11 10 bytes

1 byte graças a Dennis.

ÆN€*þ`FṢị@

Experimente online!

Números R +, 57 bytes

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

Experimente online!

outer é uma função tão útil.

Bastante certo de que isso sempre funcionará. Farei um argumento formal quando tiver tempo.

Haskell , 95 85 80 bytes

-10 bytes graças a @Lynn
-5 bytes graças a @WillNess

Baseado em 0

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

Experimente online!

Explicação

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

• Salvo seis bytes usando input() vez de definir uma função.
• Economizou quatro bytes graças a Felipe Nardi Batista ; mesclando dois loops.
• Economizou dezesseis bytes graças ao ASCII-only .
• Guardou um byte graças ao 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

Experimente online!

Pitão , 15 bytes

e.f/^FR^fP_TSZ2

Experimente aqui! ou Verifique mais casos de teste.

Explicação

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

 .f - Primeiras entradas Q com resultados verdadeiros. Usa a variável Z.
        fP_TSZ - Filtre o intervalo [1, Z] para números primos.
       ^ 2 - Quadrado cartesiano. Basicamente, o produto cartesiano consigo mesmo.
    ^ FR - Reduza cada lista por exponenciação.
  / - Conte as ocorrências de Z em ^.
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⍭⍳⍵}

Experimente online!

Explicação

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

Experimente online!

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

As razões para 24 e 7028 são que o maior valor (n = 1000) é 49378729, que é 7027 ^ 2, e a maior potência primária de 2, que se encaixa abaixo disso, é 23. Portanto, cobrindo 2..7027 ^ 2. 23 inclui todos os itens nos primeiros 1000 (e muitas peças de reposição).

Pitão - 13 bytes

e.f&P_lPZ!t{P

Conjunto de Teste .

PARI / GP, 48 bytes

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

Se você não contar a f(n)=parte, isso é 43 bytes.

Outra abordagem sem a notação de conjunto que não verifica tantos casos desnecessários:

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 muito ineficiente. Ele basicamente calcula todos os PPPs de 2 ² a 999 ⁹⁹⁹ 132 ¹³² e o armazena em uma Lista, depois classifica essa Lista e, em seguida, obtém o n'ésimo item dessa Lista.

EDIT: Em vez de usar 999 ⁹⁹⁹ que resulta em uma lista de 28.225 itens, agora uso 132 ¹³² que resulta em uma lista de apenas 1.024 itens. Isso melhora bastante o desempenho e é perfeitamente aceitável, pois o desafio afirma que devemos apoiar uma entrada do índice 0 a 1.000. (Mudando 1e3para132Porém, não afeta a contagem de bytes.

Explicação:

Experimente aqui.

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.@>:

Função anônima indexada a zero.

Experimente online!

Tentando voltar às coisas, mas parece que esqueci todos os truques para criar boas cadeias monádicas.

Breve explicação

Constrói uma tabela de potências primárias do 0º prime ao prime no índice da entrada mais 1 (para contabilizar 0). Nivela esta lista, classifica-a e depois indexa-a. Agora percebo que isso pode dar resultados incorretos para alguns valores, já que a tabela pode não ser grande o suficiente - nesse caso, eu editaria em um valor codificado como 1e4, o que deve ser suficiente. Não posso provar isso de um jeito ou de outro (ele passa nos casos de teste fornecidos), então, deixe-me saber se isso é um problema.

Também 21 bytes

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