प्राइम पावर स्विच
इनपुट: एक सकारात्मक पूर्णांक n=p^qजहां pऔर qकर रहे हैं प्रधानमंत्री ।
आउटपुट: आउटपुट का परिणामq^p
टेस्ट केस (इन, आउट):
4, 4
8, 9
25, 32
27, 27
49, 128
121, 2048
125, 243
343, 2187
1331, 177147
3125, 3125,
16807, 78125,
823543, 823543
161051, 48828125
19487171, 1977326743
स्कोरिंग:
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम कोड जीत सकते हैं! इनपुट और आउटपुट शायद आपकी भाषा के लिए उपयुक्त किसी भी उचित प्रारूप में हो।
संबंधित:
प्राइम पावर से पावर रिकवर करें प्राइम पावर से प्राइम को
रिकवर करें
जवाब
05AB1E , 5 बाइट्स
ÓOsfm
इसे ऑनलाइन आज़माएं!
टिप्पणी की:
# implicit input 25
Ó # prime factor exponents [0, 0, 2]
O # sum 2
s # swap (with input) 25, 2
f # unique prime factors [5], 2
m # power [32]
पायथन 2 , 56 बाइट्स
n=input()
p=2
while n%p:p+=1
P=p**n-1
print(n**n/P%P)**p
इसे ऑनलाइन आज़माएं!
हम पहले प्रधानमंत्री को ढूंढते हैं$p\$किसके लिए \ _$n=p^q\$बढ़ाकर \ _$p\$हम जब तक पर एक भाजक प्राप्त \$n\$। उसके बाद, हम प्रतिपादक लगता है \$q\$गणितीय चाल के साथ पहली बार Sp3000 द्वारा खोजा गया और अनार्की गोल्फ पर परफेक्ट पावर लॉगरिथम में इस्तेमाल किया गया ।
हमने ध्यान दिया कि $$ \frac{n-1}{p-1} = \frac{p^q-1}{p-1} = 1 + p + p^2 \dots+p^{q-2}+p^{q-1}$$काम कर रहे modulo \$p-1\$, हमारे पास \ _$p \equiv 1\$, में से प्रत्येक के इतने \$q\$ दाहिने हाथ की ओर समन 1 के बराबर है, और इसी तरह: $$ \frac{n-1}{p-1} \equiv q \space \bmod (p-1)$$
अब हम एक्सट्रेक्ट करना चाहेंगे \ _$q\$। हम %(p-1)बाएं हाथ की ओर मापांक ऑपरेटर को लागू करके वहां पहुंचना चाहते हैं। लेकिन यह है कि आवश्यकता है \$q<p-1\$, जिसकी गारंटी नहीं है, या हमें अलग मूल्य मिलेगा q%(p-1)।
सौभाग्य से, हम इसे एक और चाल के साथ प्राप्त कर सकते हैं। हम बदल सकते हैं \$n\$\ के साथ$n^c\$और \$p\$\ के साथ$p^c\$कुछ सकारात्मक संख्या के लिए \$c\$, और अभी भी है \$n^c=(p^c)^q\$। प्रतिपादक के बाद से \$q\$संबंधित उन्हें अपरिवर्तित है, हम इसे ऊपर के रूप में निकाल सकते हैं, लेकिन इसे ऐसा बनाते हैं कि \$q<p^c-1\$। इस के लिए, \$c=n\$ पर्याप्त से अधिक और गोल्फ के लिए कम है, हालांकि यह बड़े परीक्षण मामलों को समय से बाहर कर देता है।
बैश + लिनक्स के बर्तन, 17
factor|dc -e?zr^p
factorइनपुट के रूप में एक संख्या लेता है और इसे कारक बनाता है। आउटपुट इनपुट नंबर है, जिसके बाद एक कोलन होता है, उसके बाद सभी प्रमुख कारकों की एक अलग-अलग सूची होती है।- इस सूची को पाइप किया गया है
dcजो निम्नलिखितeएक्सप्रेशन का मूल्यांकन करता है :?पूरी लाइन को इनपुट के रूप में पढ़ता है। dc बृहदान्त्र द्वारा पीछा इनपुट संख्या को पार्स नहीं कर सकता है, इसलिए यह इसे अनदेखा करता है। फिर यह सभी अंतरिक्ष-अलग-अलग प्रमुख कारकों को पार्स करता है और उन्हें स्टैक पर धकेल देता है।zस्टैक पर वस्तुओं की संख्या (प्रमुख कारकों की संख्या) लेता है और स्टैक पर धकेलता हैrस्टैक पर शीर्ष दो आइटम उलट देता है^आवश्यक जवाब दे रहा है, घातांकpइसे प्रिंट करता है।
इसे ऑनलाइन आज़माएं!
MATL , 8 5 बाइट्स
-3 बाइट्स @LuisMendo का धन्यवाद
&YFw^
इसे ऑनलाइन आज़माएं!
जे , ९ tes बाइट्स
2^~/@p:]
इसे ऑनलाइन आज़माएं!
2 p: ]primes और उनके प्रतिपादकों की सूची देता है।^~/@फिर तर्कों और प्रतिपादक को स्वैप करें
पायथन 2 , 62 बाइट्स
n=input()
p=2
q=-1
while n%p:p+=1
while n:n/=p;q+=1
print q**p
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) -lm , 47 बाइट्स
p;f(n){for(p=1;n%++p;);p=pow(log(n)/log(p),p);}
इसे ऑनलाइन आज़माएं!
ब्रेकीलॉग , 6 बाइट्स
ḋ⟨l^h⟩
इसे ऑनलाइन आज़माएं! मुख्य अपघटन ḋ(जैसे [5, 5]) पर, l ^पहले तत्व की लंबाई h।
एक अच्छे और अधिक Brachylog- y समाधान, जो एक बाइट लंबा है:
~^ṗᵐ↔≜^
इसे ऑनलाइन आज़माएं! ~^दो नंबर प्राप्त करने के लिए उल्टा करें , [A,B]ताकि Input = A^Bदोनों प्रमुख हों ṗᵐ। ↔करने के लिए सूची फ्लिप [B,A], वास्तव में संख्या ≜और उत्पादन पाते हैं B^A।
जाप , 6 बाइट्स
k
ÊpUg
कोशिश करो
k\nÊpUg :Implicit input of integer U
k :Prime factors
\n :Reassign to U
Ê :Length
p :Raised to the power of
Ug :First element of U
आर , 37 बाइट्स
log(n<-scan(),p<-(b=2:n)[!n%%b][1])^p
इसे ऑनलाइन आज़माएं!
मेरा सबसे अच्छा प्रयास, दुख की बात है कि शीआन के ज्यादा चतुर आर जवाब की तुलना में 1-बाइट लंबा है , लेकिन प्रतिस्पर्धी भावना में वैसे भी पोस्ट करना।
प्राइम फैक्टर ( p<-(b=2:n)[!n%%b][1]) को खोजने के लिए सरल दृष्टिकोण का उपयोग करता है , फिर एक्सपोनेंट ( log(n,p)) और अंत में एक्सपोनेंट को कारक की शक्ति तक बढ़ाता है ( log(n,p)^p)।
आर 36 28 1 36 बाइट्स
इस तथ्य का उपयोग करना कि वास्तव में pशक्तियों के nकारक हैं n^p:
sum(a<-!max(b<-2:scan())%%b)^b[a][1]
इसे ऑनलाइन आज़माएं!
लेकिन फंक्शन डेफिनेशन का उपयोग करना बेहतर होता है ( function(m)हेडर पार्ट पर जाकर !)
f=function(m)
sum(a<-!m%%(b<-2:m))^b[a][1]
इसे ऑनलाइन आज़माएं!
लंबाई तर्क में अंतिम सुधार के साथ (1 बाइट!) फ़ंक्शन तर्क के रूप में सब कुछ परिभाषित करके निर्मित (ट्राई इट ऑनलाइन के हेडर में)।
f=function(m,b=2:m,a=!m%%b,d=sum(a)^b[a][1]) d
लेकिन यह कोड गोल्फ भावना के साथ नहीं है!
हास्केल , 42 , 39 बाइट्स
f x|r<-[2..x]=[z^w|z<-r,w<-r,w^z==x]!!0
इसे ऑनलाइन आज़माएं!
- 3 बाइट्स @xnor द्वारा सहेजे गए
रूबी , 56 बाइट्स
n=gets.to_i
p=2
p+=1while n%p>0
w=p**n-1
p (n**n/w%w)**p
पोर्ट ऑफ ज़्नोर के पायथन 3 का उत्तर।
इसे ऑनलाइन आज़माएं! (हेडर्स और फूटर्स के सौजन्य से: ओ। डी।)
वोल्फ्राम भाषा (गणितज्ञ) , 24 बाइट्स
#2^#&@@@FactorInteger@#&
इसे ऑनलाइन आज़माएं!
रिटर्न {q^p}, एक सिंगलटन सूची।
FactorInteger@# (* {{p,q}} *)
#2^#&@@@ (* { q^p } *)
रेटिना , 59 बाइट्स
.+
*
~`(?=(__+?)\1*$)((?=(_+)(\3+)$)\4)+
_+¶$$.($.1*$($#2$*
इसे ऑनलाइन आज़माएं! लिंक में तेजी से परीक्षण के मामले शामिल हैं। स्पष्टीकरण:
.+
*
इनपुट को unary में बदलें।
(?=(__+?)\1*$)((?=(_+)(\3+)$)\4)+
सबसे पहले, सबसे छोटा nontrivial कारक ढूंढें, जो आवश्यक रूप से होगा p। दूसरे, qउस समय की संख्या की गणना करें जिसे nइसके सबसे बड़े उचित कारक से बदला जा सकता है। (उचित कारक n/pपहले पास पर होगा और अंततः घट जाएगा 1जो कि बेजोड़ है लेकिन यह परिणाम को प्रभावित नहीं करता है।)
_+¶$$.($.1*$($#2$*
एक रेटिना चरण जो लेता उत्पन्न nइनपुट और गणना (दशमलव में) के रूप में गुणा करने का परिणाम 1द्वारा q pबार, इस प्रकार की गणना q^p।
~`
परिणामी कोड का मूल्यांकन करें, इस प्रकार वांछित परिणाम की गणना करें।
स्काला , 63 बाइट्स
n=>2 to n find(n%_<1)map{p=>import math._;pow(log(n)/log(p),p)}
इसे ऑनलाइन आज़माएं!
का पहला कारक ढूँढता है n, जो होना चाहिए pक्योंकि nएक प्रमुख शक्ति है, फिर \$\log_p(n)^p\$। रिटर्न एक है Option[Double]कि Some[Double]अगर इनपुट वैध है।
जेली , 6 बाइट्स
ÆFẎṪ*$
इसे ऑनलाइन आज़माएं!
जेली , 6 बाइट्स
ÆFẎ*@Ɲ
इसे ऑनलाइन आज़माएं!
जेली , 6 बाइट्स
ÆfL*ḢƊ
इसे ऑनलाइन आज़माएं!
5-बेटर संभव लगता है ...
जे , 8 बाइट्स
2^~/@p:]
इसे ऑनलाइन आज़माएं!
J में एक अंतर्निहित है जो किसी दिए गए पूर्णांक के अभाज्य गुणन को प्रधान-प्रतिपादक रूप में देता है। फिर यह ^~दो नंबरों के बीच में एक्सप्रेशन को लागू करने की बात है ।
( जोनाह के उत्तर के समान ही होता है ; उत्तर प्रस्तुत करने से पहले किसी तरह ध्यान नहीं दिया ...)
क्योंकि यह भी f&.g("अंडर" का उपयोग करके हल करने योग्य है ; एक्शन जी; एक्शन एफ करें, फिर एक्शन जी को पूर्ववत करें), यहाँ कुछ दिलचस्प हैं:
10 बाइट्स
|.&.(2&p:)
2&p: Prime factorization into prime-exponent form
|. Swap the prime and exponent
&. Undo `2&p:`; evaluate the "prime" raised to "exponent"
इसे ऑनलाइन आज़माएं!
10 बाइट्स
({.##)&.q:
q: Prime factorization into plain list of primes
{. Head (prime)
# Copies of
# Length (exponent)
{.## Essentially swap the role of prime and exponent
&. Undo `q:`; product of all "primes"
इसे ऑनलाइन आज़माएं!
जावास्क्रिप्ट (ईएस 7), 47 46 44 बाइट्स
एक पुनरावर्ती फ़ंक्शन का उपयोग करता है जो पहले सबसे छोटे भाजक के लिए दिखता है \$k\ge2\$के \$n\$और फिर गिना जाता है कि कितनी बार \ _$n\$द्वारा विभाजित किया जा सकता है \$k\$। परिणाम की घात है \$k\$।
n=>(k=2,g=_=>n%k?n>1&&g(k++):1+g(n/=k))()**k
इसे ऑनलाइन आज़माएं!
टिप्पणी की गई
n => ( // main function taking n
k = 2, // start with k = 2
g = _ => // g is a recursive function ignoring its input
n % k ? // if k is not a divisor of n:
// this point of the code is reached during the first step
// of the algorithm; but it's also reached on the last
// iteration when n = 1, which is why ...
n > 1 && // ... we test whether n is greater than 1 ...
g(k++) // ... in which case we do a recursive call with k + 1
: // else (k has been found):
1 + // add 1 to the final result
g(n /= k) // and do a recursive call with n / k
)() // initial call to g
** k // raise the result to the power of k
ऐलिस , 13 बाइट्स
/ \f~#oE/
i@
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण:
/ Switch to Ordinal mode
i Push the input as a string
\ Switch to Cardinal mode
f Pop n, implicitly convert n to an integer,
and push the prime factors of n as pairs of prime and exponent
~ Swap the top two elements of the stack
# Skip the next command
E Pop y, pop x. If y is non-negative, push x ^ y
/ Switch to Ordinal mode
o Pop s, then output s as a string.
~ Swap the top two elements of the stack.
\ Switch to Cardinal mode
@ Terminate the program
फोर्थ (gforth) , 85 बाइट्स
: f dup 2 do dup i mod 0= if i leave then loop tuck swap s>f fln s>f fln f/ s>f f** ;
इसे ऑनलाइन आज़माएं!
नूडल 9 के सी उत्तर की तरह काम करता है । पूर्णांक लेता है और एफपी स्टैक पर एक फ्लोटिंग-पॉइंट नंबर देता है।
यह काम किस प्रकार करता है
: f ( n -- float )
dup 2 do \ loop from i = 2..n-1
dup i mod 0= if \ if n % i == 0
i leave \ ( n p ) we found p; leave the loop
then \ end if
loop \ end loop
tuck swap \ ( p p n )
s>f fln s>f fln \ ( p F:ln(n) F:ln(p) )
f/ \ ( p F:q ) q = ln(n)/ln(p)
s>f f** \ ( F:q**p )
;
पायथ , 7 6 बाइट्स
-1 बाइट के लिए @FryAmTheEggman को धन्यवाद
^lPQhP
इसे ऑनलाइन आज़माएं!
व्याख्या
^lPQhP
l # length of
PQ # prime factors of input
^ # raised to power of
hP # first element in prime factors of input
आईओ , 57 55 बाइट्स
फिक्स्ड एक बग कृपया @DominicvanEssen द्वारा बताया गया
method(i,p :=2;while(i%p>0,p=p+1);i log(p)floor pow(p))
इसे ऑनलाइन आज़माएं!
APL (NARS2000 0.5.14),
9 वर्ण
8 वर्ण (APL Orchard में गुरु के लिए धन्यवाद):
(⍴*1∘↑)π
यह काम किस प्रकार करता है:
उदाहरण के रूप में इनपुट 8 को लें। πमुख्य कारकों के वेक्टर में 8 टूट जाता है 2 2 2। कांटा ⍴*1∘↑ से एक तत्व लेता 2 2 2प्रतिपादक के रूप में, वेक्टर की लंबाई को यह लागू होता है 2 2 2जो है 3, दे रही है 3^2 = 9।
डेसमोस , 61 10 + 38 = 48 बाइट्स
l=log_m(n)
\sum_{m=2}^{n-1}(sign(l-ceil(l))+1)l^m
इसे ऑनलाइन देखें (ध्यान दें कि बड़े मान विफल हो सकते हैं क्योंकि डेसमोस बड़ी संख्या को अच्छी तरह से संभाल नहीं पाता है)
मैंने इसे फिर से शुरू करने का फैसला किया क्योंकि मुझे ऐसा महसूस हुआ कि मैं खुद को आउटगोल्फिंग कर रहा हूं, और मुझे याद है कि यह संभावित अक्षमताएं हैं। मैं केवल एक सुधार पा सकता था, लेकिन यह संपादन के लिए पर्याप्त पर्याप्त था।
इनपुट nदूसरी चर के माध्यम से चर , आउटपुट के माध्यम से है। यदि एक चर के माध्यम से इनपुट लेना गलत लगता है, तो एक के लिए दो बाइट्स जोड़ने के लिए स्वतंत्र महसूस करें n=।
बुरी तरह से कुशलता से गोल्फ नहीं। लगभग 70% कोड सिर्फ एक कारक खोजने के लिए समर्पित है, और निश्चित रूप से Desmos में कारक संख्याओं के लिए एक अधिक कुशल तरीका है, लेकिन मुझे अभी तक एक नहीं मिला है, और Desmos में कारक या अभाज्य संख्याओं से संबंधित अंतर्निहित कमी है ।
इसके बजाय, हम बस देख सकते हैं कि जब से \$p\$और \$q\$प्राइम हैं, फिर \ _$p*p...*p\$का केवल गुणन होना चाहिए \$n\$जिसे पूर्णांक मानों के साथ दर्शाया जा सकता है, क्योंकि \ की सूची$p\$s को किसी अन्य समूह में भी विभाजित नहीं किया जा सकता है। इसलिए, हम केवल सभी पूर्णांकों के माध्यम से अंतर कर सकते हैं \$m \in 2,3,...,n-1\$और मूल्य संतोषजनक पाते हैं \$log_mn \in \mathbb{Z}\$(पूर्णांकों का समुच्चय)। हम कोड का उपयोग करते हुए ऐसा करते हैं sign(log_m(n)-ceil(log_m(n)))+1, जो पूर्णांक और 0 नहीं होने पर हमें 1 अच्छा देता है। हम log_m(n)^mहमें अपना नया मूल्य देने के लिए गुणा करते हैं , और उत्तर के लिए एकल 1 से n-1 के माध्यम से सभी मान 2 के लिए परिणाम जोड़ते हैं।
भूसी , 5 बाइट्स
§^←Lp
इसे ऑनलाइन आज़माएं!