Beberapa angka seperti 64dapat dinyatakan sebagai kekuatan bilangan bulat dalam berbagai cara:

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

Keluarkan array yang diurutkan dari semua kekuatan yang mungkin (di sini, [1,2,3,6]) dalam sesedikit mungkin byte.

Memasukkan

Seluruh angka positif yang lebih besar dari 1 dan kurang dari 10.000.

Keluaran

Array kekuatan bilangan bulat p(termasuk 1) yang inputnya dapat dinyatakan a^pdengan bilangan bulat a. Keluaran mungkin memiliki desimal, selama masih dalam urutan.

Setiap masalah floating point harus ditangani oleh program.

Contohnya

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Papan angka

Agar skor Anda muncul di papan tulis, itu harus dalam format ini:

# Language, Bytes

Dicoret tidak seharusnya menyebabkan masalah.

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 byte

f}Q^RTSQSQ

Demonstrasi

Untuk setiap daya, itu menghasilkan daftar semua angka hingga input yang diambil untuk kekuatan itu, dan kemudian memeriksa apakah input ada dalam daftar.

Haskell, 38

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

Cukup mudah. Pemahaman daftar menemukan nilai binput yang nmuncul [1^b, 2^b, ..., n^b]. Cukup untuk memeriksa brentang [1..n].

Python 2, 53

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

Brute memaksa semua kombinasi pangkalan dalam eksponen dalam [0, n-1] dan pangkalan dalam [1, n].

Python 3, 56 byte

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

Ini benar-benar canggung. Menguji apakah setiap iroot -th potensial memberikan bilangan bulat dengan membulatkannya, mengambil kekuatannya i, dan memeriksa bahwa itu sama dengan yang asli.

Langsung memeriksa bahwa root adalah bilangan bulat itu rumit karena floating point memberikan hal-hal seperti 64**(1/3) == 3.9999999999999996. Membulatkannya ke bilangan bulat, mari kita periksa apakah mengambil daya kembali ke nilai semula. Terima kasih kepada ypercube karena menyarankan ini, menghemat 1 byte.

feersum memiliki solusi yang lebih pendek dan lebih pintar . Anda semua harus benar-benar merasa terharu karenanya.

Pyth, 11 10 12 byte

fsmqQ^dTSQSQ

Periksa semua kemungkinan kombinasi kekuatan. Sangat lambat.

CJam, 23 byte

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

Ini bekerja dengan mengambil faktorisasi utama n dan menghitung persimpangan pembagi semua eksponen.

Hal ini sedikit lebih lama dari solusi saya yang lain , tapi saya berharap untuk bekerja (dan menyelesaikan langsung) untuk semua bilangan bulat antara 2 dan 2 ⁶³ - 1 .

Cobalah online di juru bahasa CJam .

Bagaimana itu bekerja

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 byte

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

Program APL pertama saya; saran bermain golf dihargai.

              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 byte 81 byte, 79 byte, 75 byte

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

Cek untuk melihat apakah kekuatan bilangan bulat terdekat dari kemungkinan root sama n. ~~(.5+...)sama dengan Math.round(...)untuk ekspresi dalam rentang integer (0 hingga 2 ^ 31 - 1).

Sunting: Digunakan &&logika malas alih-alih ifmencukur 2 byte dan menambahkan prompt untuk input karena pertanyaan menambahkan klarifikasi. Sebelumnya dengan asumsi input disimpan di n.

Edit 2: Berubah ~~(.5+...)untuk .5+...|0menyelamatkan dua byte dengan menghindari pengelompokan.

Sunting 3: Dihapus varuntuk menyimpan 4 byte. Dalam mode non-ketat, ini dapat diterima.

Brachylog , 8 byte

≥^↙.?≥ℕ≜

Cobalah online!

Mengambil input melalui variabel inputnya dan menghasilkan setiap daya melalui variabel outputnya, dalam urutan naik sesuai kebutuhan, tidak seperti solusi lama ≥ℕ≜^↙.?∧yang kebetulan memiliki panjang yang sama persis.

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

Saya tidak memiliki pembenaran yang ketat untuk menyatakan bahwa setiap eksponen tidak lebih besar dari input, tetapi agar program untuk benar-benar menghentikannya perlu dibatasi.

ḋḅlᵛfadalah solusi yang jauh lebih pendek (non-generator) untuk semua kasus uji yang diberikan, tetapi gagal jika input bukan kekuatan produk dari bilangan prima yang berbeda. (Kalau dipikir-pikir, karena semua kasus uji adalah kekuatan bilangan prima, ḋlfjuga berfungsi ...) Yang terbaik yang saya temukan untuk menyelamatkan ide,, ḋḅlᵐḋˢ⊇ᵛ×fkeluar hingga 10 byte.

Jelly , 6 byte

ÆEg/ÆD

Cobalah 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 byte

Ó¿Ñ

Cobalah online!

Port of Jelly String yang tidak terkait jawabannya .

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

JavaScript ES7, 66 byte

Mengambil keuntungan dari pemahaman array eksperimental. Hanya berfungsi di Firefox.

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

Kemungkinan bermain golf. Saya mungkin akan mencoba untuk menekan ekspresi sedikit lebih pendek dan mudah-mudahan menemukan alternatif untuk Array(n).keys()sintaks yang panjang .

Bisa lebih pendek tetapi JavaScript memiliki akurasi titik mengambang yang mengerikan.

CJam, 20 byte

ri_,1df+\1$fmL9fmO&p

Untuk input n , ini menghitung log _b n untuk semua b kurang atau sama dengan n dan menjaga hasil yang bilangan bulat.

Ini harus bekerja untuk semua bilangan bulat antara 2 dan 9.999 . Run time kira-kira O (n) .

Cobalah online di juru bahasa CJam .

Bagaimana itu bekerja

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

Mencetak ke layar.

Ruby, 57

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

Mengembalikan array.

Dalam program uji:

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)

Hitung setiap root dan uji mereka modulo 1 untuk melihat apakah sisanya kurang dari 1e-8. Karena presisi terbatas, beberapa akar integer yang valid dihitung sebagai bentuk 0,9999 .., maka kebutuhan untuk menambahkan 1e-9 ke dalamnya.

Sampai ke akar n dari n dihitung, yang merupakan total berlebihan, tetapi tampaknya cara terpendek untuk menulis loop non-infinite.

Stax , 6 byte

£ÅeÉåC

Jalankan dan debug itu

Semua pembagi dari gcd eksponen dalam faktorisasi utama. Ini sama dengan algoritma jelly.

DC, 104 byte

Input diambil dari terminal, output dicetak dan juga di stack.

Karena ini menggunakan? operator, Anda harus menggunakan dc -e "<solution>"atau dc <file with solution in it>.

Tidak ada yang pernah melihat jawaban saya, apalagi memilihnya, tapi saya benar-benar menikmati menyelesaikan masalah di DC. Ini solusi paling efisien di utas ini sejauh ini, tapi saya pikir saya akan mempostingnya.

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

barang pemula

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 menaikkan basis ke semua kekuatan hingga hasilnya lebih besar dari target atau sama dengan target

[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 untuk menyimpan nilai eksponen yang valid seperti yang ditemukan dari makro eksponen di atas ke tumpukan lain

[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 menjalankan makro 2x di atas (makro c) melalui semua basis dari 2 hingga nomor target kami

[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 untuk mencetak nilai dari f stack

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

$n$$e$$b$$b^e=n$

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

Cobalah 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()

Cobalah online!

Japt , 10 byte

õ
f@mpX øN

Cobalah

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