Alguns números como 64podem ser expressos como um número inteiro de várias maneiras:

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

Envie uma matriz classificada de todos os possíveis poderes (aqui, [1,2,3,6]) no menor número possível de bytes.

Entrada

Um número inteiro positivo maior que 1 e menor que 10000.

Resultado

Uma matriz de potências de número inteiro p(inclusive 1) para as quais a entrada pode ser expressa como a^pcom número inteiro a. As saídas podem ter decimais, desde que estejam em ordem.

Qualquer problema de ponto flutuante deve ser tratado pelo programa.

Exemplos

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Placar

Para que sua pontuação apareça no quadro, ela deve estar neste formato:

# Language, Bytes

Tacadas não devem causar problemas.

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>

Pitão, 10 bytes

f}Q^RTSQSQ

Demonstração

Para cada energia, gera a lista de todos os números até a entrada recebida para essa energia e verifica se a entrada está na lista.

Haskell, 38

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

Bem direto. A compreensão da lista localiza valores bpara os quais a entrada naparece entre [1^b, 2^b, ..., n^b]. Basta verificar bo intervalo [1..n].

Python 2, 53

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

Brute força todas as combinações de bases em expoentes em [0, n-1] e bases em [1, n].

Python 3, 56 bytes

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

Isso é realmente desajeitado. Testa se cada potencial i-ésima raiz fornece um número inteiro arredondando-o, obtendo o poder de ie verificando se é igual ao original.

A verificação direta de que a raiz é um número inteiro é complicada porque pontos flutuantes fornecem coisas do tipo 64**(1/3) == 3.9999999999999996. Arredondando-o para um número inteiro, vamos verificar se a potência retorna ao valor original. Obrigado ao ypercube por sugerir isso, economizando 1 byte.

feersum tem uma solução mais curta e inteligente . Vocês todos deveriam realmente votar isso.

Pitão, 11 10 12 bytes

fsmqQ^dTSQSQ

Verifica todas as combinações possíveis de poderes. Muito devagar.

CJam, 23 bytes

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

Isso funciona tomando a fatoração primária de n e computando a interseção dos divisores de todos os expoentes.

É um pouco mais longo que minha outra solução , mas espero que funcione (e termine instantaneamente) para todos os números inteiros entre 2 e 2 ⁶³ - 1 .

Experimente on-line no intérprete CJam .

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

Meu primeiro programa de APL; sugestões de golfe são apreciadas.

              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)

Verifica se a potência inteira mais próxima da raiz possível é igual n. ~~(.5+...)é equivalente a Math.round(...)para expressões dentro do intervalo inteiro (0 a 2 ^ 31 - 1).

Editar: Usava &&lógica lenta em vez de ifraspar 2 bytes e adicionou um prompt de entrada, pois a pergunta adicionava um esclarecimento. Anteriormente, assumindo que a entrada foi armazenada n.

Editar 2: Alterado ~~(.5+...)para .5+...|0salvar dois bytes, evitando o agrupamento.

Editar 3: Removido varpara salvar 4 bytes. No modo não estrito, isso é aceitável.

Braquilog , 8 bytes

≥^↙.?≥ℕ≜

Experimente online!

Toma entrada através de sua variável de entrada e gera cada potência através de sua variável de saída, em ordem crescente, conforme necessário, ao contrário da solução antiga, ≥ℕ≜^↙.?∧que por acaso tem exatamente o mesmo comprimento.

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

Não tenho justificativa rigorosa para afirmar que todo expoente não é maior que a entrada, mas para que o programa realmente termine, ele precisa ser limitado.

ḋḅlᵛfé uma solução muito mais curta (sem gerador) para todos os casos de teste, mas falha se a entrada não for uma potência de um produto de primos distintos. (Pense bem, já que todos os casos de teste são poderes de números primos, ḋlftambém funciona ...) O melhor que eu vim para salvar a ideia ḋḅlᵐḋˢ⊇ᵛ×f, sai em 10 bytes.

Gelatina , 6 bytes

ÆEg/ÆD

Experimente 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

Ó¿Ñ

Experimente online!

Resposta do porto da geléia de cordas não relacionadas .

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

JavaScript ES7, 66 bytes

Aproveita as compreensões experimentais da matriz. Só funciona no Firefox.

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

Possível golfe. Provavelmente tentarei espremer as expressões um pouco mais e esperançosamente encontrar uma alternativa para a longa Array(n).keys()sintaxe.

Pode ser mais curto, mas o JavaScript tem uma precisão horrível de ponto flutuante.

CJam, 20 bytes

ri_,1df+\1$fmL9fmO&p

Para a entrada n , isso calcula o log _b n para todos os b menores ou iguais a n e mantém os resultados inteiros.

Isso deve funcionar para todos os números inteiros entre 2 e 9.999 . O tempo de execução é aproximadamente O (n) .

Experimente on-line no intérprete CJam .

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

Ruby, 50

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

Imprime na tela.

Ruby, 57

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

Retorna uma matriz.

No programa de teste:

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 raiz e testa o módulo 1 para ver se o restante é menor que 1e-8. Devido à precisão limitada, algumas raízes inteiras válidas são calculadas com o formato 0,9999 .., daí a necessidade de adicionar 1e-9 a elas.

Até a enésima enésima raiz de n é calculada, que é um excedente total, mas parecia a maneira mais curta de escrever um loop não infinito.

Stax , 6 bytes

£ÅeÉåC

Execute e depure

Todos os divisores do MDC de expoentes na fatoração primária. É o mesmo que o algoritmo de geléia.

DC, 104 bytes

A entrada é retirada do terminal, a saída é impressa e também na pilha.

Porque isso usa o? operador, você precisa usar dc -e "<solution>"ou dc <file with solution in it>.

Ninguém nunca vê minhas respostas, muito menos vote nelas, mas eu realmente gosto de resolver problemas em Washington. Até agora, é a solução menos eficiente neste segmento, mas pensei em publicá-lo de qualquer maneira.

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

coisas iniciais

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 uma base a todos os poderes até que o resultado seja maior que o alvo ou igual ao alvo

[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 salvar um valor de expoente válido conforme encontrado nas macros de expoente acima em outra pilha

[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 executar a macro 2x acima (macro c) em todas as bases, de 2 ao número alvo

[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 os valores da pilha 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}}}

Experimente online!

C # (compilador interativo do 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()

Experimente online!

Japt , 10 bytes

õ
f@mpX øN

Tente

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