Niektóre liczby 64mogą być wyrażone jako potęga liczb całkowitych na wiele sposobów:

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

Wyprowadza posortowaną tablicę wszystkich możliwych mocy (tutaj [1,2,3,6]) w jak najmniejszej liczbie bajtów.

Wejście

Dodatnia liczba całkowita większa niż 1 i mniejsza niż 10000.

Wynik

Tablica potęg liczb całkowitych p(w tym 1), dla których dane wejściowe można wyrazić tak jak a^pprzy użyciu liczby całkowitej a. Dane wyjściowe mogą mieć miejsca dziesiętne, o ile są w porządku.

Wszelkie problemy zmiennoprzecinkowe muszą być obsługiwane przez program.

Przykłady

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Tablica wyników

Twój wynik powinien pojawić się na tablicy, powinien mieć następujący format:

# Language, Bytes

Przekreślenia nie powinny powodować problemów.

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 bajtów

f}Q^RTSQSQ

Demonstracja

Dla każdej mocy generuje listę wszystkich liczb aż do wejścia pobranego do tej mocy, a następnie sprawdza, czy dane wejście znajduje się na liście.

Haskell, 38

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

Całkiem proste. Zrozumienie listy znajduje wartości, bdla których dane wejściowe npojawiają się między [1^b, 2^b, ..., n^b]. Wystarczy sprawdzić bw zakresie [1..n].

Python 2, 53

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

Brute wymusza wszystkie kombinacje zasad w wykładnikach w [0, n-1] i zasad w [1, n].

Python 3, 56 bajtów

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

To jest naprawdę niezdarne. Sprawdza, czy każdy potencjalny i-ty pierwiastek podaje liczbę całkowitą, zaokrąglając go, biorąc moc ii sprawdzając, czy jest równy oryginałowi.

Bezpośrednie sprawdzanie, czy pierwiastek jest liczbą całkowitą, jest trudne, ponieważ zmiennoprzecinkowe dają takie rzeczy 64**(1/3) == 3.9999999999999996. Zaokrąglając go do liczby całkowitej, sprawdźmy, czy przywrócenie mocy wraca do pierwotnej wartości. Dzięki ypercube za zasugerowanie tego, oszczędzając 1 bajt.

feersum ma krótsze i mądrzejsze rozwiązanie . Wszyscy powinniście naprawdę to poprzeć.

Pyth, 11 10 12 bajtów

fsmqQ^dTSQSQ

Sprawdza wszystkie możliwe kombinacje mocy. Bardzo wolno.

CJam, 23 bajty

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

Działa to poprzez przyjęcie pierwszej faktoryzacji n i obliczenie przecięcia dzielników wszystkich wykładników.

Jest to nieco dłużej niż innym moim rozwiązanie , ale można oczekiwać, że do pracy (i zakończyć natychmiast) dla wszystkich liczb całkowitych między 2 a 2 ⁶³ - 1 .

Wypróbuj online w interpretatorze CJam .

Jak to działa

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 bajtów

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

Mój pierwszy program APL; sugestie dotyczące gry w golfa są mile widziane.

              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 bajty 81 bajtów 79 bajtów 75 bajtów

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

Sprawdza, czy najbliższa całkowita liczba możliwych możliwych pierwiastków jest równa n. ~~(.5+...)jest równoważne Math.round(...)wyrażeniom z zakresu liczb całkowitych (od 0 do 2 ^ 31 - 1).

Edycja: Użyto leniwej &&logiki zamiast ifgolić 2 bajty i dodano monit o wprowadzenie, ponieważ pytanie dodało wyjaśnienie. Poprzednio zakładano, że dane wejściowe zostały zapisane w n.

Edycja 2: Zmieniono ~~(.5+...)na, .5+...|0aby zapisać dwa bajty, unikając grupowania.

Edycja 3: Usunięto, varaby zapisać 4 bajty. W trybie nieściągalnym jest to dopuszczalne.

Brachylog , 8 bajtów

≥^↙.?≥ℕ≜

Wypróbuj online!

Pobiera dane wejściowe przez zmienną wejściową i generuje każdą moc poprzez zmienną wyjściową, w kolejności rosnącej zgodnie z wymaganiami, w przeciwieństwie do starego rozwiązania, ≥ℕ≜^↙.?∧które akurat ma dokładnie taką samą długość.

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

Nie mam żadnego rygorystycznego uzasadnienia dla twierdzenia, że ​​każdy wykładnik nie jest większy niż dane wejściowe, ale aby program mógł się zakończyć, musi zostać ograniczony.

ḋḅlᵛfjest rozwiązaniem znacznie krótszym (bez generatora) dla wszystkich podanych przypadków testowych, ale zawodzi, jeśli dane wejściowe nie są potęgą iloczynu różnych liczb pierwszych. (Pomyśl o tym, ponieważ wszystkie przypadki testowe są potęgami liczb pierwszych, ḋlfdziała również ...) Najlepsze, co wymyśliłem, aby uratować ten pomysł ḋḅlᵐḋˢ⊇ᵛ×f, wychodzi na 10 bajtów.

Galaretka , 6 bajtów

ÆEg/ÆD

Wypróbuj 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 bajty

Ó¿Ñ

Wypróbuj online!

Odpowiedź na galaretkę Portu niepowiązanego sznurka .

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

JavaScript ES7, 66 bajtów

Wykorzystuje eksperymentalne tablice. Działa tylko w przeglądarce Firefox.

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

Możliwy golf. Prawdopodobnie postaram się nieco skrócić wyrażenia i mam nadzieję znaleźć alternatywę dla długiej Array(n).keys()składni.

Może być krótszy, ale JavaScript ma niesamowicie zmiennoprzecinkową dokładność.

CJam, 20 bajtów

ri_,1df+\1$fmL9fmO&p

Dla wejścia n oblicza to log _b n dla wszystkich b mniejszych lub równych n i zachowuje wyniki, które są liczbami całkowitymi.

Powinno to działać dla wszystkich liczb całkowitych od 2 do 9 999 . Czas pracy wynosi mniej więcej O (n) .

Wypróbuj online w interpretatorze CJam .

Jak to działa

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.

Ruby, 50

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

Drukuje na ekranie.

Ruby, 57 lat

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

Zwraca tablicę.

W programie testowym:

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)

Oblicza każdy pierwiastek i testuje go modulo 1, aby sprawdzić, czy reszta jest mniejsza niż 1e-8. Z powodu ograniczonej precyzji oblicza się, że niektóre prawidłowe pierwiastki całkowite mają postać 0,9999 .., stąd potrzeba dodania do nich 1e-9.

Oblicza się do n-tego pierwiastka z n, co jest całkowitą nadwyżką, ale wydaje się najkrótszym sposobem na napisanie nieskończonej pętli.

Stax , 6 bajtów

£ÅeÉåC

Uruchom i debuguj

Wszystkie dzielniki gcd wykładników w głównym rozkładzie na czynniki pierwsze. Jest taki sam jak algorytm galaretki.

DC, 104 bajty

Dane wejściowe są pobierane z terminala, dane wyjściowe są drukowane, a także na stosie.

Ponieważ używa to? operator, musisz użyć dc -e "<solution>"lub dc <file with solution in it>.

Nikt nigdy nie widzi moich odpowiedzi, nie mówiąc już o głosowaniu na nie, ale naprawdę lubię rozwiązywać problemy w DC. Jak dotąd jest to najmniej wydajne rozwiązanie w tym wątku, ale pomyślałem, że i tak go opublikuję.

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

rzeczy początkowe

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, aby podnieść bazę do wszystkich mocy, aż wynik będzie większy niż cel lub równy celowi

[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, aby zapisać poprawną wartość wykładnika, jak znaleziono z powyższych makr wykładnika na innym stosie

[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, aby uruchomić 2x powyższe makro (makro c) przez wszystkie bazy od 2 do naszej liczby docelowej

[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, aby wydrukować wartości ze stosu F.

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

Rubin , 46 bajtów

Rozwiązanie brutalnej siły. Oczywiste; na wejście$n$, znajdź wszystkie liczby $e$ gdzie dla niektórych $b$, $b^e=n$.

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

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 93 bajty

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

Wypróbuj online!

Japt , 10 bajtów

õ
f@mpX øN

Spróbuj

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