Einige Zahlen wie 64können auf verschiedene Arten als ganze Potenz ausgedrückt werden:

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

Geben Sie ein sortiertes Array aller möglichen Potenzen (hier [1,2,3,6]) in möglichst wenigen Bytes aus.

Eingang

Eine positive ganze Zahl, die größer als 1 und kleiner als 10000 ist.

Ausgabe

Eine Anordnung von ganzzahliger Potenzen p(einschließlich 1) , für die die Eingabe kann ausgedrückt werden a^pmit ganzzahliges a. Die Ausgänge können Dezimalstellen haben, solange sie in Ordnung sind.

Alle Fließkomma-Probleme müssen vom Programm behandelt werden.

Beispiele

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Anzeigetafel

Damit Ihre Partitur auf der Tafel erscheint, sollte sie in folgendem Format vorliegen:

# Language, Bytes

Durchgestrichene Symbole sollten kein Problem verursachen.

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>

Pyth, 10 Bytes

f}Q^RTSQSQ

Demonstration

Für jede Potenz generiert es die Liste aller Zahlen bis zu der Eingabe, die für diese Potenz verwendet wird, und prüft dann, ob die Eingabe in der Liste enthalten ist.

Haskell, 38

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

Ziemlich einfach. Das Listenverständnis findet Werte, unter bdenen die Eingabe nerscheint [1^b, 2^b, ..., n^b]. Es reicht aus, bden Bereich einzusehen [1..n].

Python 2, 53

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

Brute erzwingt alle Basenkombinationen in Exponenten in [0, n-1] und Basen in [1, n].

Python 3, 56 Bytes

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

Das ist wirklich ungeschickt. Prüft, ob jede potenzielle iWurzel eine Ganzzahl ergibt, indem sie gerundet, mit der Potenz von iberechnet und überprüft wird, ob sie der ursprünglichen entspricht.

Die direkte Überprüfung, ob die Wurzel eine ganze Zahl ist, ist schwierig, da Gleitkommazahlen Dinge wie ergeben 64**(1/3) == 3.9999999999999996. Wenn Sie es auf eine Ganzzahl runden, überprüfen Sie, ob die Potenz wieder zum ursprünglichen Wert zurückkehrt. Vielen Dank an ypercube, der dies vorgeschlagen und 1 Byte gespart hat.

feersum hat eine kürzere und cleverere lösung . Ihr alle solltet das wirklich gutheißen.

Pyth, 11 10 12 Bytes

fsmqQ^dTSQSQ

Überprüft alle möglichen Kombinationen von Kräften. Sehr langsam.

CJam, 23 Bytes

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

Dies funktioniert, indem die Primfaktorisierung von n genommen und der Schnittpunkt der Divisoren aller Exponenten berechnet wird.

Es ist etwas länger als meine andere Lösung , aber ich erwarte, dass es für alle ganzen Zahlen zwischen 2 und 2 ⁶³ - 1 funktioniert (und sofort beendet wird) .

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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.

APL, 17 Bytes

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

Mein erstes APL-Programm; Golfvorschläge werden geschätzt.

              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)

JavaScript (ES5), 73 Bytes 81 Bytes 79 Bytes 75 Bytes

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

Überprüft, ob die nächste ganzzahlige Potenz der möglichen Wurzel gleich ist n. ~~(.5+...)entspricht Math.round(...)für Ausdrücke im ganzzahligen Bereich (0 bis 2 ^ 31 - 1).

Bearbeiten: Lazy &&Logic anstelle von if2 Bytes verwendet und Eingabeaufforderung hinzugefügt, da die Frage eine Klarstellung hinzugefügt hat. Wurde früher angenommen, dass Eingaben in gespeichert wurden n.

Bearbeiten 2: Wurde geändert ~~(.5+...), .5+...|0um zwei Bytes zu sparen, indem Gruppierungen vermieden wurden.

Edit 3: Wurde entfernt var, um 4 Bytes zu sparen. Im nicht strengen Modus ist dies akzeptabel.

Brachylog , 8 Bytes

≥^↙.?≥ℕ≜

Probieren Sie es online!

Nimmt die Eingabe über die Eingangsvariable auf und erzeugt jede Leistung über die Ausgangsvariable in aufsteigender Reihenfolge, anders als bei der alten Lösung, ≥ℕ≜^↙.?∧die zufällig genau dieselbe Länge hat.

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

Ich habe keine strenge Rechtfertigung für die Behauptung, dass jeder Exponent nicht größer als die Eingabe ist, aber damit das Programm tatsächlich beendet wird, muss es begrenzt werden.

ḋḅlᵛfist eine weitaus kürzere (Nicht-Generator-) Lösung für alle gegebenen Testfälle, aber sie schlägt fehl, wenn die Eingabe keine Potenz eines Produkts unterschiedlicher Primzahlen ist. (Denken Sie mal darüber nach, da alle Testfälle Potenzen von Primzahlen sind und ḋlfauch funktionieren ...) Das Beste, was ich mir ausgedacht habe, um die Idee zu retten, ḋḅlᵐḋˢ⊇ᵛ×fsind 10 Bytes.

Gelee , 6 Bytes

ÆEg/ÆD

Probieren Sie es online!

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

05AB1E , 3 Bytes

Ó¿Ñ

Probieren Sie es online!

Port of Unrelated String's Jelly Antwort .

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

JavaScript ES7, 66 Bytes

Nutzt das experimentelle Array-Verständnis. Funktioniert nur mit Firefox.

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

Mögliches Golfen. Ich werde wahrscheinlich versuchen, die Ausdrücke etwas kürzer zu fassen und hoffentlich eine Alternative zu den langen zu findenArray(n).keys() Syntax zu finden.

Könnte kürzer sein, aber JavaScript hat eine fürchterliche Gleitkomma-Genauigkeit.

CJam, 20 Bytes

ri_,1df+\1$fmL9fmO&p

Für die Eingabe n wird log _b n für alle b berechnet kleiner oder gleich n und behält die Ergebnisse bei, die ganze Zahlen sind.

Dies sollte für alle ganzen Zahlen zwischen 2 und 9.999 funktionieren . Die Laufzeit beträgt ungefähr O (n) .

Probieren Sie es online in der CJam-Interpreter aus .

Wie es funktioniert

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.

Rubin, 50

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

Druckt auf dem Bildschirm.

Rubin, 57

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

Gibt ein Array zurück.

Im Testprogramm:

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)

Berechnet jede Wurzel und testet sie modulo 1, um festzustellen, ob der Rest kleiner als 1e-8 ist. Aufgrund der eingeschränkten Genauigkeit werden einige gültige Ganzzahlwurzeln mit der Form 0,9999 berechnet, weshalb 1e-9 hinzugefügt werden muss.

Bis zur n-ten Wurzel von n wird berechnet, was totaler Overkill ist, aber der kürzeste Weg schien, eine nicht-unendliche Schleife zu schreiben.

Stax , 6 Bytes

£ÅeÉåC

Führen Sie es aus und debuggen Sie es

Alle Divisoren der gcd von Exponenten in der Primfaktorisierung. Es ist das gleiche wie beim Jelly-Algorithmus.

DC, 104 Bytes

Die Eingabe wird vom Terminal übernommen, die Ausgabe wird gedruckt und auch auf dem Stapel abgelegt.

Weil dies das? Betreiber, müssen Sie dc -e "<solution>"oder verwenden dc <file with solution in it>.

Niemand kann meine Antworten sehen, geschweige denn darüber abstimmen, aber es macht mir wirklich Spaß, Probleme in DC zu lösen. Es ist die am wenigsten effiziente Lösung in diesem Thread, aber ich dachte, ich würde es trotzdem posten.

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

Starter Zeug

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

Makro, um eine Basis für alle Kräfte zu erhöhen, bis das Ergebnis größer als das Ziel oder gleich dem Ziel ist

[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

Makro zum Speichern eines gültigen Exponentenwerts aus den obigen Exponentenmakros in einem anderen Stapel

[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

Makro, um das obige Makro 2x (Makro c) durch alle Basen von 2 bis zu unserer Zielnummer zu führen

[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

Makro zum Drucken der Werte aus dem f-Stapel

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

Ruby , 46 Bytes

Brute-Force-Lösung. Selbsterklärend; zur Eingabe$n$finden Sie alle Zahlen $e$ wo für manche $b$, $b^e=n$.

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

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 93 Byte

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

Probieren Sie es online!

Japt , 10 Bytes

õ
f@mpX øN

Versuch es

õ            :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