Bu zorluğun amacı için, Bir Başbakanın Asal Gücü (PPP), asal sayının gücüne asal sayı olarak tanımlanabilecek bir sayı olarak tanımlanır. Örneğin, 9 bir PPP'dir, çünkü 3 ^ 2 olarak temsil edilebilir. Öte yandan 81 bir PPP değildir, çünkü sadece 3 ^ 4 olarak temsil edilebilir ve 4 asal değildir. İlk birkaç PPP: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Bu OEIS dizisi A053810

Senin görevin:

N giriş tamsayısı için n-PPP'yi (1 dizinli veya 0 dizinli) döndüren / çıkaran (hangisini tercih ederseniz edin) bir program veya işlev yazın.

Giriş:

Makul bir yöntemle alınan 0 ile 1,000 arasında bir tam sayı.

Çıktı:

Girdi tarafından belirtilen dizindeki PPP.

Test Durumları:

Bunlar 1 dizinli ve bu nedenle programınız 0 dizinli girdi alıyorsa, belirtilen girdi - 1 için aynı çıktıya ulaşılmalıdır.

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

puanlama:

Bu kod-golf , bayt cinsinden en düşük puan kazanır!

05AB1E (eski) ,  9  7 bayt

@KevinCruijssen'e 2 bayt kaydedildi

µNÓ0Kp»

Çevrimiçi deneyin!

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

Kabuk , 10 bayt

!fȯṗ§*ELpN

Çevrimiçi deneyin!

açıklama

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

Aslında 14 bayt

Dayanarak Bay Xcoder en Pyth çözümü . Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

ama Martin Ender daha iyi bir fikre sahipti ve 6 bayt kurtardı

Mathematica, 42 bayt

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

Çevrimiçi deneyin!

Jöle , 12 11 10 bayt

Dennis'e 1 bayt teşekkürler.

ÆN€*þ`FṢị@

Çevrimiçi deneyin!

R + sayıları, 57 bayt

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

Çevrimiçi deneyin!

outer çok kullanışlı bir işlevdir.

Bunun her zaman işe yarayacağından oldukça emin. Zamanım olduğunda resmi bir tartışma yapacak.

Haskell , 95 85 80 bayt

@Lynn sayesinde -10 bayt @WillNess
sayesinde -5 bayt

0 tabanlı

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

Çevrimiçi deneyin!

açıklama

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

• input()Bir işlevi tanımlamak yerine altı bayt kaydetti .
• Felipe Nardi Batista sayesinde dört bayt tasarruf etti ; iki döngüyü birleştiriyor.
• Yalnızca ASCII sayesinde on altı bayt tasarruf etti .
• ArBo sayesinde bir bayt kaydetti .

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

Çevrimiçi deneyin!

Pyth , 15 bayt

e.f/^FR^fP_TSZ2

Burada deneyin! veya Daha fazla test vakası doğrulayın.

açıklama

ef / ^ FR ^ fP_TSZ2 - Tam program. Q giriş anlamına gelir.

 .f - Doğru sonuçlar veren ilk Q girdileri. Z değişkenini kullanır.
        fP_TSZ - Asal değerler için [1, Z] aralığını filtreleyin.
       ^ 2 - Kartezyen kare. Temelde kendisi ile Kartezyen ürün.
    ^ FR - Her listeyi üs ile azaltın.
  / - ^ cinsinden Z oluşumlarını sayın.
e - Son öğe.

JavaScript 137 133 bayt

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

** normal algoritma (100 ms sonuç) 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 (Genişletilmiş Dyalog) , 15 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

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

24 ve 7028'in nedenleri, en büyük değerin (n = 1000) 7027 ^ 2 olan 49378729 ve 2'nin altında kalan en büyük 2 ana gücünün 23 olmasıdır. 23 ilk 1000 (ve bir sürü yedek) tüm öğeleri içerir.

Pyth - 13 bayt

e.f&P_lPZ!t{P

Test Takımı .

PARI / GP, 48 bayt

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

Parçayı saymazsanız f(n)=, bu 43 bayttır.

Çok fazla gereksiz vakayı kontrol etmeyen set notasyonu olmayan başka bir yaklaşım:

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

Java 8, 211 bayt

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

Çok verimsiz bir yöntem .. Temelde 2 ² ile 999 ⁹⁹⁹ 132 ¹³² arasındaki tüm PPP'leri hesaplar ve bir Listede saklar, sonra bu Listeyi sıralar ve sonra nbu listeden 'th' öğesini alır .

DÜZENLEME: 28.225 öğenin bir listesi ile sonuçlanan 999 ⁹⁹⁹ yerine, şimdi sadece 132 ürün içeren bir ¹³² sonuç 132 ¹³² kullanıyorum . Bu, performansı biraz geliştirir ve meydan okuma 0'dan 1.000'e kadar bir girdiyi desteklememiz gerektiğini belirttiğinden mükemmel kabul edilebilir. (Değişen 1e3için 132olsa bayt sayısını etkilemez.)

Açıklama:

Burada deneyin.

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 bayt

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

Sıfır indeksli anonim işlev.

Çevrimiçi deneyin!

Şeylerin salınımına geri dönmeye çalışıyorum ama iyi monadik zincirler yapmak için tüm hileleri unutmuşum gibi görünüyor.

Kısa açıklama

Girdi artı 1'in dizininde (0'ı hesaba katmak için) 0'ın başından prime kadar bir ana güçler tablosu oluşturur. Bu listeyi düzleştirir ve sıralar ve ardından dizine ekler. Tablo yeterince büyük olmayabilir çünkü bu bazı değerler için yanlış sonuçlar verebilir şimdi fark - Bu durumda yeterli 1e4 gibi sabit kodlanmış bir değerde düzenlemek istiyorum. Bunu şu ya da bu şekilde kanıtlayamıyorum (verilen test durumları için geçiyor), bu yüzden bunun bir sorun olup olmadığını bana bildirin.

Ayrıca 21 bayt

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