प्राइम पॉवर्स ऑफ प्राइम्स

16

इस चुनौती के उद्देश्य के लिए, एक प्राइम पावर ऑफ़ प्राइम (PPP) को एक संख्या के रूप में परिभाषित किया जाता है जिसे एक अभाज्य संख्या की शक्ति के लिए एक प्रमुख संख्या के रूप में परिभाषित किया जा सकता है। उदाहरण के लिए, 9 एक पीपीपी है क्योंकि इसे 3 ^ 2 के रूप में दर्शाया जा सकता है। दूसरी ओर 81 पीपीपी नहीं है क्योंकि इसे केवल 3 ^ 4 के रूप में दर्शाया जा सकता है, और 4 अभाज्य नहीं है। पहले कुछ PPP हैं: 4, 8, 9, 25, 27, 32, 49, 121, 125, 128, 169, 243, 289, 343 ... यह OEIS अनुक्रम A053810 है

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट पूर्णांक n रिटर्न / nth पीपीपी के आउटपुट के लिए, या तो 1-अनुक्रमित या 0-अनुक्रमित, जो भी आप चाहें।

इनपुट:

किसी भी उचित विधि के माध्यम से 0 और 1,000 के बीच पूर्णांक प्राप्त होता है।

आउटपुट:

इनपुट द्वारा इंगित सूचकांक में पीपीपी।

परीक्षण के मामलों:

ये 1-अनुक्रमित हैं, और इसलिए, यदि आपका प्रोग्राम 0-अनुक्रमित इनपुट लेता है, तो उसी आउटपुट को कथित इनपुट -1 के लिए आना चाहिए। 

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

स्कोरिंग:

यह कोड-गोल्फ , बाइट्स जीत में सबसे कम स्कोर!

code-golf  sequence  primes  integer 
— Gryphon
स्रोत
इस चुनौती को सैंडबॉक्स किया
— Gryphon

जवाबों:

8

05AB1E (विरासत) ,  9  7 बाइट्स

सहेजे गए 2 बाइट @KevinCruijssen को धन्यवाद देते हैं

µ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
— Arnauld
स्रोत
ओह, मैं के उपयोग की तरह »के बजाय Jइतना 0\n1truthy के रूप में व्याख्या नहीं कर रहा है! लेकिन आप एक बाइट को 05AB1E (जिसे आपने अपने TIO में भी इस्तेमाल किया था) के लेगिट वर्जन में सेव कर सकते हैं, इसे छोड़ कर ½, क्योंकि यह µ( 05AB1E की इस टिप में दूसरी बुलेट-पॉइंट के लिए निहित है )। भी, ʒĀ}हो सकता है 0K। 7 बाइट्स
— केविन क्रूज़सेन
@ केविनक्रूजसेन कूल। धन्यवाद!
— अरनौलद
5

भूसी , 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.
— Zgarb
स्रोत
4

वास्तव में , 14 बाइट्स

श्री Xcoder के Pyth समाधान के आधार पर । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;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)
— Sherlock9
स्रोत
4

मैथेमेटिका, 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लेकिन मार्टिन एंडर के पास एक बेहतर विचार था और उसने 6 बाइट्स बचाए

गणितज्ञ, 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— J42161217
स्रोत
आप से बचने के Unionबजाय उपयोग कर सकते हैं । JoinSort
— मार्टिन एंडर
लेकिन मुझे लगता Outerहै कि एक और बाइट Array(Union@@Outer[Power,p=Prime@Range@#,p])[[#]]&
— बचती है
और Tuplesभी छोटा है:Sort[Power@@@Prime@Range@#~Tuples~2][[#]]&
— मार्टिन एंडर
4

आर + संख्या, 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

outer इस तरह के एक आसान कार्य है।

निश्चित रूप से यह हमेशा काम करेगा। जब मेरे पास समय होगा तो एक औपचारिक तर्क दूंगा।

— ग्यूसेप
स्रोत
4

हास्केल , 95 85 80 बाइट्स

-10 बाइट्स @Lynn
-5 बाइट्स के लिए धन्यवाद @WillNess को धन्यवाद

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
— SEJPM
स्रोत
f=(!!)[x|x<-[2..],or[y^e==x|y<-p x,e<-p x]]10 बाइट्स बचाता है।
— लिन
inlining द्वारा 82 बाइट्स प्राप्त कर सकते हैं f=(!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]:। शायद यह ठीक है तो गिनती नहीं है f=? (नियमों के बारे में निश्चित नहीं)।
— नेस
मुझे एक बार कहा गया था कि वास्तव में f=गिना नहीं जाना चाहिए। तो यह 80 बाइट्स के साथ होगा (!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]।
— विल नेस
4

पायथन 2 , 163 157 137 136 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जोनाथन फ्रेच
स्रोत
बाइट बचाने के लिए सूचियों का उपयोग करें: i=[]और....i+=[r]*....
— फेलिप नारदी बतिस्ता
153 बाइट्स दूसरे को हटाकरfor
— फेलिप नारदी बतिस्ता
@FelipeNardiBatista मैंने सूचियों का उपयोग नहीं किया, क्योंकि इसके पहले पुनरावृत्ति में यह कार्यक्रम एक फ़ंक्शन को परिभाषित कर रहा था। स्पॉटिंग और आगे गोल्फ के लिए धन्यवाद।
— जोनाथन फ्रीच
आप वापस नहीं लौट सकते rबजायi[p]
— ASCII-केवल
— केवल
2

अजगर , 15 बाइट्स

e.f/^FR^fP_TSZ2

यहाँ यह कोशिश करो! या अधिक परीक्षण मामलों को सत्यापित करें।

व्याख्या

एफई / ^ FR ^ fP_TSZ2 - पूर्ण कार्यक्रम। Q का मतलब इनपुट है।

 .f - सत्य परिणाम के साथ पहला क्यू इनपुट। चर Z का उपयोग करता है।
        fP_TSZ - प्रिम्स के लिए रेंज [1, Z] को फ़िल्टर करें।
       ^ 2 - कार्टेशियन वर्ग। मूल रूप से कार्टेशियन उत्पाद ही है।
    ^ FR - घातांक द्वारा प्रत्येक सूची को कम करें।
  / - ^ में Z की घटनाओं को गिनें।
ई - अंतिम तत्व।
— श्री एक्सकोडर
स्रोत
2

जावास्क्रिप्ट 137 133 बाइट्स

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]
}
— DanielIndie
स्रोत
5
उम्म, यह कोड-गोल्फ है , सबसे तेज-कोड नहीं । इसलिए, दूसरों की तुलना में आपके प्रस्तुत करने की गति महत्वपूर्ण नहीं है, क्योंकि यह बाइट काउंट द्वारा स्कोर किया जाता है। कृपया अपने उत्तर में बाइट काउंट और अपनी सबमिशन की भाषा शामिल करें।
— ग्रीफॉन
लेकिन इसकी कम से कम समय सीमा होनी चाहिए, मैं इसे गोल्फ कर सकता हूं, लेकिन 100 मीटर के समाधान से 5 सेकंड का समाधान हो जाएगा, क्या यह ठीक है?
— डेनियल आइंडी
2
समाधान चलाने के लिए किसी भी परिमित राशि ले सकता है। कोड को छोटा बनाना ही एकमात्र लक्ष्य है।
— ग्रीफॉन
2

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.
— Sherlock9
स्रोत
2

पर्ल 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 (और बहुत सारे पुर्जों) के सभी आइटम शामिल हैं।

— फिल एच
स्रोत
1

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
— जेपी स्टिग नीलसन
स्रोत
0

जावा 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 पीपी से 2 2 से 999 999 132 132 के माध्यम से गणना करता है और एक सूची में संग्रहीत करता है, फिर उस सूची को सॉर्ट करता है, और फिर nउस सूची से 'वें आइटम' प्राप्त करता है।

संपादित करें: का उपयोग कर 999 के बजाय 999 28,225 मदों की एक सूची में जो परिणाम, अब मैं का उपयोग 132 132 सिर्फ 1,024 मदों की एक सूची में जो परिणाम है। यह प्रदर्शन में काफी सुधार करता है, और पूरी तरह से स्वीकार्य है क्योंकि चुनौती बताती है कि हमें सूचकांक 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
— केविन क्रूज़सेन
स्रोत
0

जे, 21 बाइट्स

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

शून्य-अनुक्रमित अनाम फ़ंक्शन।

इसे ऑनलाइन आज़माएं!

चीजों के झूले में वापस जाने की कोशिश कर रहा हूं लेकिन मुझे लगता है कि अच्छी मोनडिक श्रृंखला बनाने के लिए सभी चालें भूल गए हैं।

संक्षिप्त व्याख्या

इनपुट प्लस 1 (0 के लिए खाते में) के सूचकांक में 0 वीं प्रधानमंत्री से प्रमुख शक्तियों की एक तालिका का निर्माण करता है। इस सूची को समतल करता है और इसे क्रमबद्ध करता है और फिर इसमें अनुक्रमित करता है। मुझे अब एहसास हुआ कि यह कुछ मूल्यों के लिए गलत परिणाम दे सकता है क्योंकि तालिका काफी बड़ी नहीं हो सकती है - उस स्थिति में मैं 1e4 जैसे हार्डकोड मूल्य में संपादित करूंगा जो कि पर्याप्त होना चाहिए। मैं इसे एक या दूसरे तरीके से साबित नहीं कर सकता (यह दिए गए परीक्षण मामलों के लिए गुजरता है), इसलिए मुझे बताएं कि क्या यह एक मुद्दा है।

इसके अलावा 21 बाइट्स

3 :'y{/:~,^/~p:i.>:y'
— गोभी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.