이 과제의 목적을 위해, PPP (Prime Power of a Prime)는 소수의 거듭 제곱에 대한 소수로 정의 될 수있는 숫자로 정의됩니다. 예를 들어, 9는 3 ^ 2로 표시 될 수 있으므로 PPP입니다. 반면에 81은 PPP가 아닙니다. 3 ^ 4로만 표현 될 수 있고 4는 소수가 아닙니다. 처음 몇 PPP는 다음과 같습니다. 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... 이것은 OEIS 시퀀스 A053810입니다.

당신의 작업 :

입력 정수에 대해 n이 n 번째 PPP를 1- 인덱스 또는 0- 인덱스 중 원하는 방식으로 리턴 / 출력하는 프로그램 또는 함수를 작성하십시오.

입력:

합리적인 방법으로받은 0에서 1,000 사이의 정수입니다.

산출:

입력에 의해 표시되는 인덱스의 PPP

테스트 사례 :

이들은 1- 인덱싱되므로 프로그램이 0- 인덱스 입력을받는 경우 명시된 입력-1에 대해 동일한 출력에 도달해야합니다.

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

채점 :

이 코드 골프 , 가장 낮은 바이트 점수가 이깁니다!

05AB1E (레거시) ,  9  7 바이트

@KevinCruijssen 에게 2 바이트를 절약했습니다.

µNÓ0Kp»

온라인으로 사용해보십시오!

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

껍질 , 10 바이트

!fȯṗ§*ELpN

온라인으로 사용해보십시오!

설명

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

실제로 14 바이트

Mr. Xcoder의 Pyth 솔루션을 기반으로 합니다 . 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

;ur♂P;∙⌠iⁿ⌡MSE

언 골핑

                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)

매스 매 티카, 48 바이트

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

온라인으로 사용해보십시오!

그러나 Martin Ender는 더 나은 아이디어를 가지고 6 바이트를 절약했습니다.

수학, 42 바이트

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

온라인으로 사용해보십시오!

젤리 , 12 11 10 바이트

Dennis 덕분에 1 바이트.

ÆN€*þ`FṢị@

온라인으로 사용해보십시오!

R + 숫자, 57 바이트

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

온라인으로 사용해보십시오!

outer 그런 편리한 기능입니다.

분명히 이것은 항상 작동 할 것입니다. 내가 시간이 있으면 공식적인 논쟁을 할 것이다.

하스켈 , 95 85 80 바이트

@Lynn 덕분에 -10 바이트 @WillNess 덕분에
-5 바이트

0 기반

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

온라인으로 사용해보십시오!

설명

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

파이썬 (2) , 163 (157) 137 136 바이트

• input()함수를 정의하는 대신 6 바이트를 절약했습니다 .
• Felipe Nardi Batista 덕분에 4 바이트를 절약 했습니다 . 두 개의 루프를 병합합니다.
• ASCII 전용으로 16 바이트를 절약했습니다 .
• 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

온라인으로 사용해보십시오!

Pyth , 15 바이트

e.f/^FR^fP_TSZ2

여기 사용해보십시오! 또는 더 많은 테스트 사례를 확인하십시오.

설명

ef / ^ FR ^ fP_TSZ2-전체 프로그램. Q는 입력을 의미합니다.

 .f-진실한 결과를 가진 첫 번째 Q 입력. 변수 Z를 사용합니다.
        fP_TSZ-소수에 대한 범위 [1, Z]를 필터링합니다.
       ^ 2-데카르트 광장. 기본적으로 직교 곱이 있습니다.
    ^ FR-지수로 각 목록을 줄입니다.
  /-^에서 Z의 발생 횟수를 센다.
e-마지막 요소

자바 스크립트 137133 바이트

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

** 정상 알고리즘 (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 Extended) , 15 바이트

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

온라인으로 사용해보십시오!

설명

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

펄 6 , 50 바이트

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

온라인으로 사용해보십시오!

  (^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와 7028의 이유는 가장 큰 값 (n = 1000)이 49378729 (7027 ^ 2)이고 그에 맞는 2의 가장 큰 제곱이 23이기 때문에 2..7027 ^ 2.입니다. 23은 처음 1000 개의 모든 항목 (및 많은 여분)을 포함합니다.

Pyth-13 바이트

e.f&P_lPZ!t{P

테스트 스위트 .

PARI / GP, 48 바이트

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

당신이 계산하지 않으면 f(n)=부품을 43 바이트입니다.

너무 많은 불필요한 경우를 확인하지 않는 집합 표기법이없는 또 다른 접근법 :

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

자바 8, 211 바이트

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

매우 비효율적 인 방법. 기본적으로 2 ² ~ 999 ⁹⁹⁹ 132 ¹³² 의 모든 PPP를 계산합니다. 다음 목록은 다음을 얻을 수 있음을 정렬하고 저장합니다 목록에서를n 목록 것과 번째의 항목을 선택합니다.

편집 : 28,225 항목의 목록을 생성하는 999 ⁹⁹⁹ 를 사용하는 대신 이제 1,024 항목의 목록을 생성 하는 132 ¹³² 를 사용 합니다. 이것은 성능을 상당히 향상 시키며, 인덱스 0에서 1,000까지의 입력을 지원해야하는 문제 상태이므로 완벽하게 수용 가능합니다. (변경해도 바이트 수에는 영향 1e3을 132미치지 않습니다.)

설명:

여기에서 시도하십시오.

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 바이트

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

색인이없는 익명 함수.

온라인으로 사용해보십시오!

물건의 스윙으로 돌아 가려고하지만 좋은 모나 딕 체인을 만들기위한 모든 트릭을 잊어 버린 것 같습니다.

간단한 설명

입력 지수에 0을 더하기 위해 0의 소수부터 소수까지의 소수 거듭 제곱 테이블을 구성합니다. 이 목록을 병합하여 정렬 한 다음 색인으로 만듭니다. 테이블이 충분히 크지 않을 수 있기 때문에 이것이 일부 값에 대해 잘못된 결과를 줄 수 있음을 알았습니다.이 경우 1e4와 같은 하드 코딩 된 값으로 편집하면 충분합니다. 어떤 식 으로든 증명할 수 없으므로 (주어진 테스트 케이스에 통과) 이것이 문제인지 알려주세요.

또한 21 바이트

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