संपूर्ण-संख्या शक्तियाँ

Question

कुछ संख्याओं 64को कई तरीकों से पूरी-संख्या शक्ति के रूप में व्यक्त किया जा सकता है:

64 ^ 1
 8 ^ 2
 4 ^ 3
 2 ^ 6

संभव के [1,2,3,6]रूप में कुछ बाइट्स में सभी संभव ऐसी शक्तियों (यहाँ, ) के एक क्रमबद्ध सरणी आउटपुट ।

---

इनपुट

एक सकारात्मक पूरी संख्या जो 1 से अधिक और 10000 से कम है।

---

उत्पादन

संपूर्ण-संख्या शक्तियों की एक सरणी p(शामिल 1) जिसके लिए इनपुट को a^pसंपूर्ण-संख्या के साथ व्यक्त किया जा सकता हैa । आउटपुट में दशमलव हो सकते हैं, जब तक कि वे क्रम में हों।

किसी भी फ्लोटिंग पॉइंट इश्यू को प्रोग्राम द्वारा हैंडल किया जाना चाहिए।

---

उदाहरण

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

Input: 81
Output: [1, 2, 4]

Input: 729
Output: [1, 2, 3, 6]

---

स्कोरबोर्ड

आपके स्कोर बोर्ड पर दिखाई देने के लिए, यह इस प्रारूप में होना चाहिए:

# Language, Bytes

स्ट्राइकथ्रू समस्या का कारण नहीं होना चाहिए।

function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/<strike>.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+"").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58047,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;

body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 30px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="scores-cont"><h2>Scores</h2><table class="score-table"><thead> <tr><td></td><td>User</td><td>Language</td><td>Score</td></tr></thead> <tbody id="scores"></tbody></table></div><table style="display: none"> <tbody id="score-template"><tr><td>{{RANK}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td></tr></tbody></table>

Comments

मेरा जवाब [1 2 3 6]आखिरी टेस्ट केस के लिए प्रिंट करता है। यह भी मुद्रित कर सकते हैं [6 3 2 1], [1.0 2.0 3.0 6.0]या [6.0 3.0 2.0 1.0]?

— डेनिस

इनपुट आकार और फ्लोटिंग-पॉइंट अंकगणित के बारे में हम क्या मान सकते हैं? यह उस समाधान को प्रभावित करता है जहां आप संख्या की जड़ों को लेने की कोशिश करते हैं और देखते हैं कि परिणाम पूर्णांक है।

— xnor

मुझे लगता है कि जड़ों के संदर्भ सभी को भ्रमित कर रहे थे, इसलिए मैंने इसे शक्तियों के संदर्भ में फिर से लिखा। चीजों को वापस बदलने के लिए स्वतंत्र महसूस करें।

— xnor

मैं संपादन की सराहना करता हूं! सुझावों और संशोधनों का हमेशा स्वागत है, बशर्ते वे मेरे प्रश्न की गुणवत्ता में सुधार करें (जो मुझे विश्वास है कि आपने किया था)। मैंने हाल ही में इस विशेष नेटवर्क पर सवाल पूछना शुरू किया है, और आमतौर पर स्वागत करने वाले समुदाय को ढूंढता हूं। आलोचना और सुधार की बहुत सराहना की जाती है! @ एक्सनोर

— जैच गेट्स

बस सबसे बड़ी वैध शक्ति का पता लगाएं और फिर उसके कारकों को सूचीबद्ध करें!

— सुपरजेडी २२४

Answer 1

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

f}Q^RTSQSQ

प्रदर्शन

प्रत्येक पावर के लिए, यह उस पावर पर लिए गए इनपुट तक सभी नंबरों की सूची जेनरेट करता है, और फिर चेक करता है कि इनपुट लिस्ट में है या नहीं।

Answer 2

हास्केल, ३ 38

f n=[b|b<-[1..n],n`elem`map(^b)[1..n]]

बहुत सीधा। सूची की समझ उन मूल्यों को खोजती है bजिनके लिए इनपुट nबीच में दिखाई देता है [1^b, 2^b, ..., n^b]। यह bसीमा में जाँच करने के लिए पर्याप्त है [1..n]।

Answer 3

पायथन 2, 53

lambda n:[i/n for i in range(n*n)if(i%n+1)**(i/n)==n]

Brute [0, n-1] और [1, n] में ठिकानों में घातांक के सभी संयोजनों को बल देता है।

Answer 4

पायथन 3, 56 बाइट्स

lambda n:[i for i in range(1,n)if round(n**(1/i))**i==n]

यह वास्तव में अनाड़ी है। टेस्ट यदि प्रत्येक संभावित i-th रूट इसे पूर्णांक बनाकर, इसकी शक्ति लेकर i, और यह जाँचता है कि यह मूल के बराबर है , तो पूर्णांक देता है ।

सीधे जाँच कर रहा है कि जड़ एक पूरी संख्या है, मुश्किल है क्योंकि फ़्लोटिंग पॉइंट जैसी चीज़ें देते हैं 64**(1/3) == 3.9999999999999996। इसे पूर्णांक तक राउंडिंग करते हुए देखें कि पावर मूल रिटर्न पर ले जाता है या नहीं। यह सुझाव के लिए ypercube के लिए धन्यवाद, 1 बाइट की बचत।

feersum में एक छोटा और अधिक चतुर समाधान होता है । आप सभी को वास्तव में इसे उभारना चाहिए।

Comments

अगर आपने जाँच की तो क्या यह सही नहीं होगा round(n**(1/i),0)**i==n?

— ypercube y

@ypercube 0गोल के लिए डिफ़ॉल्ट सटीकता होने के साथ-साथ अच्छा कॉल, यह एक बाइट बचाता है।

— xnor

Answer 5

अजगर, 11 10 12 बाइट्स

fsmqQ^dTSQSQ

शक्तियों के सभी संभावित संयोजनों की जाँच करता है। बहुत धीमी गति से।

Answer 6

सीजेएम, 23 बाइट्स

rimF{1=:E){E\d%!},}%:&p

यह n का मुख्य गुणनखंडन ले कर काम करता है और सभी घातांक के विभाजकों के प्रतिच्छेदन की गणना करता है।

यह मेरे अन्य समाधान की तुलना में थोड़ा लंबा है , लेकिन मुझे उम्मीद है कि 2 से 2 ^{63 के} बीच सभी पूर्णांकों के लिए काम करना (और तुरंत समाप्त करना) - 1 ।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

ri                       Read an integer from STDIN.
  mF                     Push its prime factorization.
    {             }%     For each [prime exponent]:
     1=:E                  Retrieve the exponent and save it in E.
         ){     },         Filter; for each I in [0 ... E]:
           E\d%              Compute E % Double(I).
                             (Casting to Double is required to divide by 0.)
               !             Push the logical NOT of the modulus.
                           Keep I if the result is truhty, i.e., if I divides E.
                    :&   Intersect all resulting arrays of integers.
                      p  Print the resulting array.

Answer 7

एपीएल, 17 बाइट्स

(X=⌊X←N*÷⍳N)/⍳N←⎕

मेरा पहला एपीएल कार्यक्रम; गोल्फ सुझाव की सराहना की है।

              N←⎕  ⍝ Store input into N
             ⍳     ⍝ The list [1 2 ... N]
            /      ⍝ Select the elements A for which
      N*÷⍳N)       ⍝ N^(1/A)
(X=⌊X←             ⍝ equals its floor (that is, is an integer)

Comments

कृपया छद्मकोड / स्पष्टीकरण जोड़ें। लेकिन एपीएल का उपयोग करने के लिए +1 (अभी वोट नहीं कर सकता है) - ( शांत होने से पहले ही इसका उपयोग किया जा रहा है ) :-)

— mınxoma15

इसके अलावा +1, एपीएल के लिए बहुत प्यार है। परम गोल्फ वाहन।

छद्मकोश के आधार पर, यह काम करने की संभावना नहीं है (जब तक कि एपीएल एक अनुमानित फ्लोटिंग-पॉइंट समानता परीक्षण नहीं करता है)। उदाहरण के लिए, pow(pow(7,3),1./3))मैं 6.99999999999999सी या पायथन में मिलता हूं । ऐसा इसलिए है क्योंकि 1 / A की गणना करते समय सटीकता खो जाती है।

— feersum

@ Faersum मुझे ऑफ़लाइन दुभाषियों के बारे में नहीं पता है, लेकिन 3 की सभी शक्तियां tryapl.org पर सही ढंग से काम करती हैं।

— 15

@ThomasKwa ऐसा लगता है कि एक समानता समानता परीक्षण वास्तव में उपयोग किया जाता है। dyalog.com/uploads/documents/Papers/tolerant_comparison/…

— feersum

Answer 8

जावास्क्रिप्ट (ES5), 73 बाइट्स 81 बाइट्स 79 बाइट्स 75 बाइट्स

for(n=+prompt(),p=Math.pow,i=0;i++<n;)p(.5+p(n,1/i)|0,i)==n&&console.log(i)

यह देखने के लिए जांचता है कि क्या संभावित रूट की निकटतम पूर्णांक शक्ति बराबर है n। पूर्णांक श्रेणी (0 से 2 ^ 31 - 1) के भीतर अभिव्यक्तियों के लिए ~~(.5+...)बराबर है Math.round(...)।

संपादित करें: इस्तेमाल किया आलसी &&तर्क के बजाय if2 बाइट्स दाढ़ी और इनपुट के लिए शीघ्र जोड़ा क्योंकि सवाल एक स्पष्टीकरण जोड़ा। पहले मान लिया गया था कि इनपुट में संग्रहीत किया गया था n।

संपादित करें 2: समूहीकरण से बचने के लिए दो बाइट्स को बचाने के ~~(.5+...)लिए परिवर्तित .5+...|0।

संपादन 3:var 4 बाइट्स को बचाने के लिए निकाला गया । गैर-सख्त मोड में, यह स्वीकार्य है।

Comments

आप कुछ युगल बाइट्स को जॉगिंग एक्सप्रेशंस द्वारा शेव कर सकते हैं: (var p = Math.pow, i = 1 + ++ <n; p (~~ (.5 + p (n, 1 / i)), i) == n && कंसोल। लॉग (i));

@ अ्लादिस आपके इनपुट के लिए धन्यवाद, मैं थोड़ा संपादन करता हूँ

— पैट्रिक रॉबर्ट्स

@PatrickRoberts आप p=Math.powतुरंत 1 बाइट बचाने में सक्षम हो सकते हैं

— डाउनगोट सेप

@vihan, यह एक अमान्य घोषणा होगी, जब varसे आवश्यक है

— पैट्रिक रॉबर्ट्स

जब तक आप का मतलब forके बजाय prompt..

— पैट्रिक रॉबर्ट्स

Answer 9

ब्रेकीलॉग , 8 बाइट्स

≥^↙.?≥ℕ≜

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

अपने इनपुट वैरिएबल के माध्यम से इनपुट लेता है और प्रत्येक आउटपुट को अपने आउटपुट वैरिएबल के माध्यम से, आरोही क्रम में आवश्यकतानुसार पुराने समाधान के विपरीत उत्पन्न करता है, ≥ℕ≜^↙.?∧जो कि ठीक उसी लंबाई का होता है।

≥           Some number which is less than or equal to
            the input,
 ^          when raised to the power of
  ↙.        the output,
    ?       is the input.
       ≜    Label
            the output
      ℕ     as a whole number
     ≥      which is less than or equal to
    ?       the input.

मेरे पास यह दावा करने का कोई कठोर औचित्य नहीं है कि प्रत्येक घातांक इनपुट से अधिक नहीं है, लेकिन कार्यक्रम को वास्तव में समाप्त करने के लिए इसे बाध्य करने की आवश्यकता है।

ḋḅlᵛfसभी दिए गए परीक्षण मामलों के लिए एक बहुत छोटा (गैर-जनरेटर) समाधान है, लेकिन यह विफल रहता है अगर इनपुट अलग-अलग अपराधों के उत्पाद की शक्ति नहीं है। (यह सोचने के लिए आओ, क्योंकि सभी परीक्षण मामलों में अपराधों की शक्तियां हैं, ḋlfयह भी काम करता है ...) सबसे अच्छा मैं विचार को उबारने के लिए आया हूं ḋḅlᵐḋˢ⊇ᵛ×f, 10 बाइट्स के लिए आता है।

Answer 10

जेली , 6 बाइट्स

ÆEg/ÆD

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

    ÆD    The list of divisors of
ÆE        the exponents in the prime factorization of the input
   /      reduced by
  g       greatest common divisor.

Answer 11

05AB1E , 3 बाइट्स

Ó¿Ñ

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

पोर्ट ऑफ असंबंधित स्ट्रिंग के जेली उत्तर ।

Ó       # exponents in the prime factorization
 ¿      # gcd
  Ñ     # divisors

Answer 12

जावास्क्रिप्ट ईएस 7, 66 बाइट्स

प्रयोगात्मक सरणी समझ का लाभ लेता है। केवल फ़ायरफ़ॉक्स पर काम करता है।

n=>[for(i of Array(n).keys(m=Math.pow))if(m(0|.5+m(n,1/i),i)==n)i]

संभव गोल्फिंग। मैं संभवत: भावों को थोड़ा छोटा करने की कोशिश करूंगा और उम्मीद करता हूं कि लंबे Array(n).keys()वाक्य विन्यास का विकल्प मिलेगा ।

छोटा हो सकता है लेकिन जावास्क्रिप्ट में बहुत ही अस्थायी बिंदु सटीकता है।

Comments

आह, कुछ नया सीखा ... मस्त।

— पैट्रिक रॉबर्ट्स

Answer 13

CJam, 20 बाइट्स

ri_,1df+\1$fmL9fmO&p

इनपुट के लिए n , इस computes लोग इन _ख n सभी के लिए ख छोटा या बराबर है n और परिणाम है कि पूर्णांक हैं रहता है।

यह 2 और 9,999 के बीच सभी पूर्णांकों के लिए काम करना चाहिए । रन टाइम लगभग O (n) है ।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

ri                   e# Read an integer N from STDIN.
  _,                 e# Copy N and transform it into [0 ... N-1].
    1df+             e# Add 1.0 to each, resulting in [1.0 ... Nd].
        \1$          e# Swap the array with N and copy the array.
           fmL       e# Mapped log base N: N [1.0 ... Nd] -> [log1(N) ... logN(N)]
              9fmO   e# Round each logarithm to 9 decimals.
                  &  e# Intersect this array with [1.0 ... Nd].
                   p e# Print the result.

Comments

क्या १५,६२५ एकमात्र इनपुट है जिस पर वह विफल रहता है या क्या यह केवल वही है जो आपने परीक्षण किया था?

— बीटा डिके

निश्चित रूप से अन्य हैं। वास्तव में, मुझे अभी पता चला है कि यह 4913 के लिए भी विफल रहा , जिसने मेरे पिछले संशोधन को अमान्य बना दिया।

— डेनिस

Answer 14

रूबी, 50

->n{(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||p(i)}}

स्क्रीन पर प्रिंट करता है।

रूबी, ५ Rub

->n{a=[]
(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||a<<i}
a}

एक सरणी देता है।

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

f=->n{(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||puts(i)}}

g=->n{a=[]
(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||a<<i}
a}

f.call(4096)
puts g.call(4096)

प्रत्येक रूट की गणना करता है और उन्हें यह देखने के लिए modulo 1 का परीक्षण करता है कि क्या शेष 1e-8 से कम है। सीमित परिशुद्धता के कारण कुछ मान्य पूर्णांक जड़ों की गणना 0.9999 के रूप में की जाती है, इसलिए उन्हें 1e-9 जोड़ने की आवश्यकता है।

N की मूल जड़ तक गणना की जाती है, जो कुल ओवरकिल है, लेकिन एक गैर-अनंत लूप लिखने का सबसे छोटा तरीका लग रहा था।

Answer 15

स्टैक्स , 6 बाइट्स

£ÅeÉåC

इसे चलाएं और डीबग करें

मुख्य कारक में घातांक के gcd के सभी भाजक। यह जेली एल्गोरिथ्म के समान है।

Answer 16

डीसी, 104 बाइट्स

इनपुट टर्मिनल से लिया जाता है, आउटपुट प्रिंट होता है और स्टैक पर भी।

क्योंकि यह उपयोग करता है? ऑपरेटर, आपको उपयोग करने की आवश्यकता है dc -e "<solution>"या dc <file with solution in it>।

कोई भी कभी भी मेरे उत्तर नहीं देखता है, अकेले उन पर वोट दें, लेकिन मुझे वास्तव में डीसी में समस्याओं को हल करने में मजा आता है। यह इस धागे में अब तक का सबसे कम कुशल समाधान है, लेकिन मैंने सोचा कि मैं इसे वैसे भी पोस्ट करूंगा।

1sb?sn[lesi]ss[lble1+dse^dln=sln>c]sc[liSflq1+sq]sm[Lfplq1-dsq0<p]dsp[lb1+sb0si0selcxli0!=mlbln!=h]dshxx

स्टार्टर सामान

1sb           Store 1 in register b
?sn           Store user input in register n
[lesi]ss      A macro to copy the e to the i register, stored in the s register

मैक्रो सभी शक्तियों के लिए एक आधार जुटाने के लिए जब तक कि परिणाम लक्ष्य से बड़ा या लक्ष्य के बराबर न हो

[lble1+dse^dln=sln>c]sc
[lb                 ]   load our base num (register b)
[  le               ]   load our exponent (register e)
[    1+dse          ]   add 1 to the exponent, copy and store in the e register
[         ^d        ]   raise the base to the exponent and copy it
[           ln=s    ]   load the user input, if that is equal to the power result run the macro in register s
[               ln>c]   load the user input, if it's greater than the power result run the macro in register c (this one)
[                   ]sc save this macro in register c

मैक्रो एक वैध घातांक मान को बचाने के लिए जैसा कि उपरोक्त घातांक मैक्रो से दूसरे स्टैक में पाया जाता है

[liSflq1+sq]sm
[liSf      ]     copy the i register to the top of the stack in register f
[    lq1+sq]     add 1 to the q register
[          ]sm   save this macro in the m register

मैक्रो 2 से हमारे लक्ष्य संख्या तक सभी ठिकानों के माध्यम से मैक्रो (मैक्रो सी) के ऊपर 2x को चलाने के लिए

[lb1+sb0si0selcxli0!=mlbln!=h]dsh
[lb1+sb                      ]     add 1 to the base number
[      0si0se                ]     reset the i and e registers (previously found value and exponent
[            lcx             ]     load and run the c macro
[               li0!=m       ]     load the result of the c macro and if it's not 0, run m to save it to the f stack
[                     lbln!=h]     if our base number is not equal to our target number, run macro h (this macro)
[                            ]dsh  duplicate this macro and save one copy, so that one is left on the stack to run later

मैक्रो को एफ स्टैक से मान प्रिंट करने के लिए

[Lfplq1-dsq0<p]dsp
[Lfp          ]      load the top value from the f register and print it
[   lq1-dsq   ]      load the q register and subtract one from it and save it
[          0<p]      if the q register is greater than 0, run macro p (this macro) again
[             ]dsp   duplicate this macro and save one copy, so that one is left on the stack to run later

xx finally run the two macros on the stack (h and then p)

Comments

मुझे लगता है कि डीसी को बहुत से लोग नहीं जानते होंगे। नए प्रश्नों का उत्तर देना (विशेष रूप से सबसे शुरुआती उत्तरों में से एक) अधिक ध्यान पाने में मदद करेगा। आप अपने उत्तरों के लिए TIO लिंक का उपयोग करके भी देख सकते हैं, क्योंकि यह बहुत लोकप्रिय है। यहाँ TIO पर DC है ।

— mbomb007

धन्यवाद! मैं निश्चित रूप से जवाब देने के लिए आगे का उपयोग करेंगे!

— फ्लेक्सएस्ट

Answer 17

रूबी , 46 बाइट्स

जानवर बल समाधान। आत्म व्याख्यात्मक; इनपुट के लिए$n$, सभी संख्याओं को खोजें $e$ कुछ के लिए कहाँ $b$, $b^e=n$।

->n{(0..n).select{|e|(1..n).find{|b|b**e==n}}}

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

Answer 18

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 93 बाइट्स

g=n=>Enumerable.Range(1,n);
f=n=>g(n).SelectMany(x=>g(n).Where(y=>(Math.Pow(x,y)==n))).Reverse()

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

Answer 19

जाप , 10 बाइट्स

õ
f@mpX øN

कोशिश करो

õ            :Implicit input of integer U
õ            :Range [1,U]
f@mpX øN     :Reassign to U
f            :Filter
 @           :By passing each X through the following function
  m          :  Map U
   pX        :    Raise to the power of X
      ø      :  Contains
       N     :    Any element of the (singelton) array of inputs