Với mục đích của thách thức này, Power Prime of Prime (PPP) được định nghĩa là một số có thể được định nghĩa là số nguyên tố với lũy thừa của số nguyên tố. Ví dụ: 9 là một PPP vì nó có thể được biểu diễn dưới dạng 3 ^ 2. Mặt khác, 81 không phải là một PPP vì nó chỉ có thể được biểu diễn dưới dạng 3 ^ 4 và 4 không phải là số nguyên tố. Một vài PPP đầu tiên là: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... Đây là chuỗi OEIS A053810

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm cho số nguyên đầu vào n trả về / xuất ra PPP thứ n, 1-index hoặc 0-index, tùy theo bạn thích.

Đầu vào:

Một số nguyên từ 0 đến 1.000, nhận được thông qua bất kỳ phương pháp hợp lý nào.

Đầu ra:

PPP tại chỉ số được chỉ định bởi đầu vào.

Các trường hợp thử nghiệm:

Đây là 1 chỉ mục, và do đó, nếu chương trình của bạn có đầu vào 0 chỉ mục, thì đầu ra tương tự sẽ được đưa ra cho đầu vào đã nêu - 1.

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

Ghi điểm:

Đây mã golf , điểm số thấp nhất trong byte thắng!

05AB1E (di sản) ,  9  7 byte

Đã lưu 2 byte nhờ @KevinCruijssen

µNÓ0Kp»

Hãy thử trực tuyến!

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

!fȯṗ§*ELpN

Hãy thử trực tuyến!

Giải trình

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

Trên thực tế , 14 byte

Dựa trên giải pháp Pyth của ông Xcoder . Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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

Toán học, 48 byte

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

Hãy thử trực tuyến!

nhưng Martin Ender có ý tưởng tốt hơn và tiết kiệm được 6 byte

Toán học, 42 byte

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

Hãy thử trực tuyến!

Thạch , 12 11 10 byte

1 byte nhờ Dennis.

ÆN€*þ`FṢị@

Hãy thử trực tuyến!

Số R +, 57 byte

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

Hãy thử trực tuyến!

outer là một chức năng tiện dụng như vậy.

Khá chắc chắn điều này sẽ luôn luôn làm việc. Sẽ đưa ra một lập luận chính thức khi tôi có thời gian.

Haskell , 95 85 80 byte

-10 byte nhờ @Lynn
-5 byte nhờ @WillNess

Dựa trên 0

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

Hãy thử trực tuyến!

Giải trình

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

• Đã lưu sáu byte bằng cách sử dụng input()thay vì xác định hàm.
• Lưu bốn byte nhờ Felipe Nardi Batista ; hợp nhất hai vòng.
• Đã lưu mười sáu byte chỉ nhờ ASCII .
• Đã lưu một byte nhờ 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

Hãy thử trực tuyến!

Bình thường , 15 byte

e.f/^FR^fP_TSZ2

Hãy thử nó ở đây! hoặc Xác minh thêm các trường hợp thử nghiệm.

Giải trình

ef / ^ FR ^ fP_TSZ2 - Chương trình đầy đủ. Q có nghĩa là đầu vào.

 .f - Đầu vào Q đầu tiên có kết quả trung thực. Sử dụng biến Z.
        fP_TSZ - Lọc phạm vi [1, Z] cho các số nguyên tố.
       ^ 2 - Quảng trường Cartesian. Về cơ bản là sản phẩm của Cartesian với chính nó.
    ^ FR - Giảm từng danh sách theo cấp số nhân.
  / - Đếm số lần xuất hiện của Z trong ^.
e - Yếu tố cuối cùng.

Javascript 137 133 byte

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

** thuật toán bình thường (kết quả 100ms) 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 mở rộng) , 15 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

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

Lý do cho 24 và 7028 là giá trị lớn nhất (n = 1000) là 49378729, là 7027 ^ 2, và công suất nguyên tố lớn nhất là 2 phù hợp với điều đó là 23. Vì vậy, bao gồm 2,7027 ^ 2 .. 23 bao gồm tất cả các mục trong 1000 đầu tiên (và rất nhiều phụ tùng).

Pyth - 13 byte

e.f&P_lPZ!t{P

Phòng thử nghiệm .

PARI / GP, 48 byte

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

Nếu bạn không đếm f(n)=phần, đó là 43 byte.

Một cách tiếp cận khác mà không có ký hiệu đặt mà không kiểm tra rất nhiều trường hợp không cần thiết:

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

Java 8, 211 byte

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

Phương pháp rất không hiệu quả .. Về cơ bản, nó tính toán tất cả các PPP từ 2 ² đến 999 ⁹⁹⁹ 132 ¹³² và lưu trữ nó trong Danh sách, sau đó sắp xếp Danh sách đó và sau đó lấyn mục thứ nhất từ ​​Danh sách đó.

EDIT: Thay vì sử dụng 999 ⁹⁹⁹ dẫn đến Danh sách 28.225 mặt hàng, giờ đây tôi sử dụng 132 ¹³² dẫn đến Danh sách chỉ có 1.024 mặt hàng. Điều này cải thiện hiệu suất khá nhiều và hoàn toàn chấp nhận được vì các trạng thái thách thức chúng ta nên hỗ trợ đầu vào từ chỉ số 0 đến 1.000. (Tuy nhiên, việc thay đổi 1e3thành 132không ảnh hưởng đến số byte.)

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Hàm ẩn danh không có chỉ mục.

Hãy thử trực tuyến!

Cố gắng để quay trở lại vào vòng xoáy của mọi thứ nhưng tôi dường như đã quên tất cả các thủ thuật để tạo ra chuỗi đơn sắc tốt.

Giải thích ngắn

Xây dựng bảng các số nguyên tố từ số nguyên tố 0 đến số nguyên tố tại chỉ số của đầu vào cộng 1 (để chiếm 0). Làm phẳng danh sách này và sắp xếp nó và sau đó lập chỉ mục vào nó. Bây giờ tôi nhận ra rằng điều này có thể cho kết quả không chính xác đối với một số giá trị vì bảng có thể không đủ lớn - trong trường hợp đó tôi sẽ chỉnh sửa theo giá trị được mã hóa cứng như 1e4. Tôi không thể chứng minh bằng cách này hay cách khác (nó vượt qua cho các trường hợp thử nghiệm được đưa ra), vì vậy hãy cho tôi biết nếu đây là một vấn đề.

Ngoài ra 21 byte

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