Für den Zweck dieser Herausforderung wird eine Primzahlkraft eines Prims (PPP) als eine Zahl definiert, die als Primzahl zur Potenz einer Primzahl definiert werden kann. Beispielsweise ist 9 ein PPP, da es als 3 ^ 2 dargestellt werden kann. 81 hingegen ist kein PPP, da es nur als 3 ^ 4 dargestellt werden kann und 4 keine Primzahl ist. Die ersten PPPs sind: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Dies ist die OEIS-Sequenz A053810

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, die für eine Ganzzahl n den n-ten PPP zurückgibt / ausgibt, entweder 1-indiziert oder 0-indiziert, je nachdem, was Sie bevorzugen.

Eingang:

Eine Ganzzahl zwischen 0 und 1.000, die mit einer angemessenen Methode empfangen wird.

Ausgabe:

Die PPP am vom Eingang angegebenen Index.

Testfälle:

Diese sind 1-indiziert. Wenn Ihr Programm also eine 0-indizierte Eingabe verwendet, sollte dieselbe Ausgabe für die angegebene Eingabe - 1 erzielt werden.

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

Wertung:

Dieser Code-Golf , niedrigste Punktzahl in Bytes gewinnt!

05AB1E (Legacy) ,  9  7 Bytes

2 Bytes dank @KevinCruijssen gespeichert

µNÓ0Kp»

Probieren Sie es 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

Schale , 10 Bytes

!fȯṗ§*ELpN

Probieren Sie es online!

Erläuterung

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

Eigentlich 14 Bytes

Basierend auf der Pyth-Lösung von Mr. Xcoder . Golfvorschläge sind willkommen. Probieren Sie es 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&,{#,#}]][[#]]&   

Probieren Sie es online!

aber Martin Ender hatte eine bessere Idee und sparte 6 Bytes

Mathematica, 42 Bytes

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

Probieren Sie es online!

Jelly , 12 11 10 Bytes

1 Byte danke an Dennis.

ÆN€*þ`FṢị@

Probieren Sie es online!

R + Zahlen, 57 Bytes

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

Probieren Sie es online!

outer ist so eine praktische Funktion.

Ziemlich sicher, dass dies immer funktionieren wird. Ich werde ein formelles Argument vorbringen, wenn ich Zeit habe.

Haskell , 95 85 80 Bytes

-10 Bytes dank @Lynn
-5 Bytes dank @WillNess

0-basiert

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

Probieren Sie es online!

Erläuterung

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

• Sechs Bytes gespart, input()indem eine Funktion verwendet und nicht definiert wurde.
• Vier Bytes gespart dank Felipe Nardi Batista ; Zusammenführen von zwei Schleifen.
• Dank nur ASCII 16 Bytes gespart .
• Dank ArBo ein Byte gespeichert .

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

Probieren Sie es online!

Pyth , 15 Bytes

e.f/^FR^fP_TSZ2

Probieren Sie es hier aus! oder Überprüfen Sie weitere Testfälle.

Erläuterung

ef / ^ FR ^ fP_TSZ2 - Volles Programm. Q bedeutet Eingabe.

 .f - Erste Q-Eingaben mit wahrheitsgemäßen Ergebnissen. Verwendet die Variable Z.
        fP_TSZ - Filter den Bereich [1, Z] für Primzahlen.
       ^ 2 - Kartesisches Quadrat. Grundsätzlich ist das kartesische Produkt mit sich.
    ^ FR - Reduziert jede Liste durch Potenzierung.
  / - Zähle die Vorkommen von Z in ^.
e - Letztes Element.

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

** normaler Algorithmus (100ms Ergebnis) 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 Byte

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es 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

Die Gründe für die 24 und 7028 sind, dass der größte Wert (n = 1000) 49378729 ist, was 7027 ^ 2 ist, und die größte Primzahl von 2, die darunter passt, 23 ist. 23 enthält alle Elemente der ersten 1000 (und viele Ersatzteile).

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]

Wenn Sie den f(n)=Teil nicht zählen , sind dies 43 Byte.

Ein anderer Ansatz ohne die eingestellte Notation, der nicht so viele unnötige Fälle überprüft:

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

Sehr ineffiziente Methode. Sie berechnet im Grunde genommen alle PPPs von 2 ² bis 999 ⁹⁹⁹ 132 ¹³² und speichert sie in einer Liste, sortiert dann diese Liste und erhält dann das n'te Element aus dieser Liste.

BEARBEITEN: Anstatt 999 ^{999 zu verwenden,} was zu einer Liste von 28.225 Elementen führt, verwende ich jetzt 132 ^132, was zu einer Liste von nur 1.024 Elementen führt. Dies verbessert die Leistung erheblich und ist durchaus akzeptabel, da laut Challenge eine Eingabe von Index 0 bis 1.000 unterstützt werden sollte. (Der Wechsel 1e3zu hat 132jedoch keinen Einfluss auf die Anzahl der Bytes.)

Erläuterung:

Probieren Sie es hier aus.

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

Anonyme Funktion ohne Index.

Probieren Sie es online!

Ich habe versucht, wieder in Schwung zu kommen, aber anscheinend habe ich alle Tricks vergessen, um gute monadische Ketten zu machen.

Kurze Erklärung

Erstellt eine Tabelle mit Primzahlen von der 0. Primzahl bis zur Primzahl am Index der Eingabe plus 1 (um 0 zu berücksichtigen). Reduziert diese Liste, sortiert sie und indiziert sie anschließend. Mir ist jetzt klar, dass dies für einige Werte zu falschen Ergebnissen führen kann, da die Tabelle möglicherweise nicht groß genug ist. In diesem Fall würde ich einen fest codierten Wert wie 1e4 eingeben, der ausreichen sollte. Ich kann es nicht auf die eine oder andere Weise beweisen (es gilt für die angegebenen Testfälle). Lassen Sie mich also wissen, ob dies ein Problem ist.

Auch 21 Bytes

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