Algunos números como 64se pueden expresar como una potencia de número entero de múltiples maneras:

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

Genere una matriz ordenada de todas las potencias posibles (aquí [1,2,3,6]) en el menor número de bytes posible.

Entrada

Un número entero positivo que es mayor que 1 y menor que 10000.

Salida

Una matriz de potencias de números enteros p(incluidos 1) para los cuales la entrada se puede expresar como a^pcon números enteros a. Las salidas pueden tener decimales, siempre que estén en orden.

Cualquier problema de punto flotante debe ser manejado por el programa.

Ejemplos

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Marcador

Para que su puntaje aparezca en el tablero, debe estar en este formato:

# Language, Bytes

Los tachados no deberían causar un problema.

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

Demostración

Para cada potencia, genera la lista de todos los números hasta la entrada llevada a esa potencia, y luego verifica si la entrada está en la lista.

Haskell, 38

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

Muy claro. La comprensión de la lista encuentra valores bpara los que naparece la entrada [1^b, 2^b, ..., n^b]. Basta comprobar ben el rango [1..n].

Pitón 2, 53

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

Brute fuerza todas las combinaciones de bases en exponentes en [0, n-1] y bases en [1, n].

Python 3, 56 bytes

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

Esto es realmente torpe. Comprueba si cada iraíz potencial -th da un número entero redondeándolo, tomándole el poder de i, y verificando que sea igual al original.

Verificar directamente que la raíz es un número entero es complicado porque los puntos flotantes dan cosas como 64**(1/3) == 3.9999999999999996. Redondeándolo a un entero, verifiquemos si tomar la potencia vuelve al valor original. Gracias a ypercube por sugerir esto, ahorrando 1 byte.

Feersum tiene una solución más corta y más inteligente . Todos ustedes realmente deberían votar eso.

Pyth, 11 10 12 bytes

fsmqQ^dTSQSQ

Comprueba todas las combinaciones posibles de poderes. Muy lento.

CJam, 23 bytes

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

Esto funciona tomando la factorización prima de n y calculando la intersección de los divisores de todos los exponentes.

Es un poco más largo que mi otra solución , pero esperar que funcione (y terminar al instante) para todos los enteros entre 2 y 2 ⁶³ - 1 .

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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

Mi primer programa APL; Se agradecen las sugerencias de golf.

              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)

Comprueba si la potencia entera más cercana de la posible raíz es igual n. ~~(.5+...)es equivalente a Math.round(...)para expresiones dentro del rango entero (0 a 2 ^ 31 - 1).

Editar: se usó la &&lógica diferida en lugar de ifreducir 2 bytes y se agregó un mensaje de entrada ya que la pregunta agregó una aclaración. Anteriormente asumía que la entrada estaba almacenada n.

Edición 2: se modificó ~~(.5+...)para .5+...|0guardar dos bytes evitando la agrupación.

Edición 3: eliminada varpara guardar 4 bytes. En modo no estricto, esto es aceptable.

Brachylog , 8 bytes

≥^↙.?≥ℕ≜

Pruébalo en línea!

Toma la entrada a través de su variable de entrada y genera cada potencia a través de su variable de salida, en orden ascendente según sea necesario, a diferencia de la solución anterior ≥ℕ≜^↙.?∧que tiene exactamente la misma longitud.

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

No tengo ninguna justificación rigurosa para afirmar que cada exponente no sea mayor que la entrada, pero para que el programa realmente termine, necesita ser limitado.

ḋḅlᵛfes una solución mucho más corta (sin generador) para todos los casos de prueba dados, pero falla si la entrada no es una potencia de un producto de primos distintos. (Ahora que lo pienso, ya que todos los casos de prueba son poderes de primos, ḋlftambién funciona ...) Lo mejor que se me ocurrió para salvar la idea ḋḅlᵐḋˢ⊇ᵛ×f, sale a 10 bytes.

Jalea , 6 bytes

ÆEg/ÆD

Pruébalo en línea!

    Æ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

Ó¿Ñ

Pruébalo en línea!

Respuesta de Port of Unrelated String's Jelly .

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

JavaScript ES7, 66 bytes

Aprovecha las comprensiones experimentales de matrices. Solo funciona en Firefox.

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

Posible golf. Probablemente intentaré reducir las expresiones un poco más y espero encontrar una alternativa a la Array(n).keys()sintaxis larga .

Podría ser más corto, pero JavaScript tiene una precisión de coma flotante horrible.

CJam, 20 bytes

ri_,1df+\1$fmL9fmO&p

Para la entrada n , esto calcula el registro _b n para todo b menor o igual a n y mantiene los resultados que son enteros.

Esto debería funcionar para todos los enteros entre 2 y 9,999 . El tiempo de ejecución es aproximadamente O (n) .

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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.

Rubí, 50

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

Imprime a la pantalla.

Rubí, 57

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

Devuelve una matriz.

En programa de prueba:

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)

Calcula cada raíz y las prueba en el módulo 1 para ver si el resto es menor que 1e-8. Debido a la precisión limitada, se calcula que algunas raíces enteras válidas tienen la forma 0.9999 ..., de ahí la necesidad de agregarles 1e-9.

Se calcula hasta la enésima raíz de n, que es una exageración total, pero parecía la forma más corta de escribir un bucle no infinito.

Stax , 6 bytes

£ÅeÉåC

Ejecutar y depurarlo

Todos los divisores de la mcd de exponentes en la factorización prima. Es lo mismo que el algoritmo de gelatina.

DC, 104 bytes

La entrada se toma del terminal, la salida se imprime y también en la pila.

Porque esto usa el? operador, necesita usar dc -e "<solution>"o dc <file with solution in it>.

Nadie ve mis respuestas, y mucho menos las vota, pero realmente disfruto resolviendo problemas en DC. Es la solución menos eficiente en este hilo hasta ahora, pero pensé que lo publicaría de todos modos.

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

cosas de arranque

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 para elevar una base a todas las potencias hasta que el resultado sea mayor que el objetivo o igual al objetivo

[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 para guardar un valor de exponente válido como se encuentra en las macros de exponente anteriores en otra pila

[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 para ejecutar la macro 2x anterior (macro c) a través de todas las bases desde 2 hasta nuestro número objetivo

[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 para imprimir los valores de la 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)

Ruby , 46 bytes

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

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 93 bytes

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

Pruébalo en línea!

Japt , 10 bytes

õ
f@mpX øN

Intentalo

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