Alcuni numeri come 64possono essere espressi come potenza di un numero intero in diversi modi:

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

Emette un array ordinato di tutti i possibili poteri (qui, [1,2,3,6]) nel minor numero di byte possibile.

Ingresso

Un numero intero positivo maggiore di 1 e inferiore a 10000.

Produzione

Un array di potenze a numero intero p(incluso 1) per le quali l'input può essere espresso come a^pcon un numero intero a. Le uscite possono avere decimali, purché siano in ordine.

Eventuali problemi in virgola mobile devono essere gestiti dal programma.

Esempi

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

tabellone segnapunti

Affinché il tuo punteggio appaia sul tabellone, dovrebbe essere in questo formato:

# Language, Bytes

Le barrature non dovrebbero causare problemi.

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

Dimostrazione

Per ogni potenza, genera l'elenco di tutti i numeri fino all'ingresso portato a quella potenza, quindi controlla se l'ingresso è nell'elenco.

Haskell, 38

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

Abbastanza diretto. La comprensione dell'elenco trova valori bper i quali nappare l'input [1^b, 2^b, ..., n^b]. È sufficiente verificare bnell'intervallo [1..n].

Python 2, 53

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

Brute forza tutte le combinazioni di basi in esponente in [0, n-1] e basi in [1, n].

Python 3, 56 byte

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

Questo è davvero maldestro. Verifica se ogni potenziale i-th radice fornisce un numero intero arrotondandolo, assumendolo ie verificando che sia uguale all'originale.

Controllare direttamente che la radice sia un numero intero è complicato perché i punti mobili danno cose come 64**(1/3) == 3.9999999999999996. Arrotondandolo a un numero intero, controlliamo se l'assorbimento di potenza ritorna al valore originale. Grazie a ypercube per averlo suggerito, risparmiando 1 byte.

feersum ha una soluzione più breve e intelligente . Dovresti davvero votarlo.

Pyth, 11 10 12 byte

fsmqQ^dTSQSQ

Controlla tutte le possibili combinazioni di poteri. Molto lento.

CJam, 23 byte

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

Questo funziona prendendo la fattorizzazione primaria di n e calcolando l'intersezione dei divisori di tutti gli esponenti.

È un po 'più lungo della mia altra soluzione , ma mi aspetto che funzioni (e finisca all'istante) per tutti gli interi tra 2 e 2 ⁶³ - 1 .

Provalo online nell'interprete CJam .

Come funziona

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←⎕

Il mio primo programma APL; i suggerimenti sul golf sono apprezzati.

              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)

Verifica se la potenza intera più vicina alla radice possibile è uguale n. ~~(.5+...)è equivalente a Math.round(...)per le espressioni nell'intervallo intero (da 0 a 2 ^ 31 - 1).

Modifica: ha usato la &&logica lazy invece di ifradere 2 byte e ha aggiunto il prompt per l'input poiché la domanda ha aggiunto un chiarimento. In precedenza si supponeva che l'input fosse archiviato n.

Modifica 2: modificato ~~(.5+...)per .5+...|0salvare due byte evitando il raggruppamento.

Modifica 3: rimosso varper salvare 4 byte. In modalità non rigorosa, questo è accettabile.

Brachylog , 8 byte

≥^↙.?≥ℕ≜

Provalo online!

Prende input attraverso la sua variabile di input e genera ogni potenza attraverso la sua variabile di output, in ordine crescente come richiesto, a differenza della vecchia soluzione ≥ℕ≜^↙.?∧che ha la stessa identica lunghezza.

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

Non ho alcuna giustificazione rigorosa per affermare che ogni esponente non è maggiore dell'input, ma per poter terminare effettivamente il programma deve essere limitato.

ḋḅlᵛfè una soluzione molto più breve (non generatore) per tutti i casi di test indicati, ma fallisce se l'input non è una potenza di un prodotto con numeri primi distinti. (Vieni a pensarci bene, dato che tutti i casi di test sono potenze di numeri primi, ḋlffunziona anche ...) Il migliore che mi è venuto in mente per salvare l'idea ḋḅlᵐḋˢ⊇ᵛ×f, arriva a 10 byte.

Gelatina , 6 byte

ÆEg/ÆD

Provalo 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

Ó¿Ñ

Provalo online!

La risposta della gelatina di Port of Unrelated String .

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

JavaScript ES7, 66 byte

Sfrutta le comprensioni sperimentali dell'array. Funziona solo su Firefox.

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

Possibile golf. Probabilmente proverò a ridurre leggermente le espressioni e, si spera, a trovare un'alternativa alla lunga Array(n).keys()sintassi.

Potrebbe essere più breve ma JavaScript ha un'accuratezza orribile in virgola mobile.

CJam, 20 byte

ri_,1df+\1$fmL9fmO&p

Per l'input n , questo calcola il log _b n per tutti b minori o uguali a n e mantiene i risultati che sono numeri interi.

Questo dovrebbe funzionare per tutti i numeri interi compresi tra 2 e 9.999 . Il tempo di esecuzione è all'incirca O (n) .

Provalo online nell'interprete CJam .

Come funziona

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 anni

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

Stampa sullo schermo.

Ruby, 57

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

Restituisce un array.

Nel programma di test:

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)

Calcola ciascuna radice e le verifica modulo 1 per vedere se il resto è inferiore a 1e-8. A causa della precisione limitata, alcune radici di numeri interi validi vengono calcolate come 0.9999 .., quindi la necessità di aggiungere 1e-9 a esse.

Viene calcolato fino all'ennesima radice di n, che è un eccesso totale, ma sembrava il modo più breve per scrivere un ciclo non infinito.

Stax , 6 byte

£ÅeÉåC

Esegui ed esegui il debug

Tutti i divisori del gcd di esponenti nella scomposizione in fattori primi. È lo stesso dell'algoritmo jelly.

DC, 104 byte

L'input viene prelevato dal terminale, l'output viene stampato e anche nello stack.

Perché questo usa il? operatore, è necessario utilizzare dc -e "<solution>"odc <file with solution in it> .

Nessuno vede mai le mie risposte, figuriamoci votare su di esse, ma mi piace davvero solo risolvere i problemi in DC. Finora è la soluzione meno efficiente in questa discussione, ma ho pensato di pubblicarla comunque.

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

roba di avviamento

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

Macro per elevare una base a tutti i poteri fino a quando il risultato non è più grande del bersaglio o uguale al bersaglio

[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

Macro per salvare un valore di esponente valido come trovato dalle macro di esponente di cui sopra in un altro stack

[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

Macro per eseguire la macro 2x sopra (macro c) attraverso tutte le basi da 2 al nostro numero di destinazione

[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

Macro per stampare i valori dalla pila 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)

Rubino , 46 byte

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

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

Provalo online!

C # (compilatore interattivo Visual C #) , 93 byte

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

Provalo online!

Japt , 10 byte

õ
f@mpX øN

Provalo

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