Certains nombres comme 64peuvent être exprimés en puissance entière de plusieurs façons:

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

Afficher un tableau trié de toutes ces puissances possibles (ici [1,2,3,6]) en aussi peu d'octets que possible.

Contribution

Un nombre entier positif supérieur à 1 et inférieur à 10000.

Production

Tableau de puissances de nombre entier p(y compris 1) pour lesquelles l'entrée peut être exprimée comme a^pavec nombre entier a. Les sorties peuvent avoir des décimales, tant qu'elles sont en ordre.

Tout problème de virgule flottante doit être géré par le programme.

Exemples

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

Tableau d'affichage

Pour que votre score apparaisse sur le tableau, il doit être dans ce format:

# Language, Bytes

Les barrés ne devraient pas poser de problème.

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 octets

f}Q^RTSQSQ

Manifestation

Pour chaque puissance, il génère la liste de tous les nombres jusqu'à l'entrée prise pour cette puissance, puis vérifie si l'entrée est dans la liste.

Haskell, 38

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

Assez simple. La compréhension de la liste trouve les valeurs bpour lesquelles l'entrée napparaît parmi [1^b, 2^b, ..., n^b]. Il suffit de vérifier bla plage [1..n].

Python 2, 53

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

Brute force toutes les combinaisons de bases dans les exposants dans [0, n-1] et les bases dans [1, n].

Python 3, 56 octets

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

C'est vraiment maladroit. Teste si chaque iracine potentielle -th donne un entier en l'arrondissant, en lui prenant la puissance de iet en vérifiant qu'il est égal à l'original.

Vérifier directement que la racine est un nombre entier est délicat car les virgules flottantes donnent des choses comme 64**(1/3) == 3.9999999999999996. L'arrondir à un entier nous permet de vérifier si la prise de puissance revient à la valeur d'origine. Merci à ypercube de l'avoir suggéré, économisant 1 octet.

feersum a une solution plus courte et plus intelligente . Vous devriez tous vraiment voter pour cela.

Pyth, 11 10 12 octets

fsmqQ^dTSQSQ

Vérifie toutes les combinaisons de pouvoirs possibles. Très lent.

CJam, 23 octets

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

Cela fonctionne en prenant la factorisation principale de n et en calculant l'intersection des diviseurs de tous les exposants.

Il est un peu plus long que mon autre solution , mais je m'attends à ce qu'il fonctionne (et se termine instantanément) pour tous les entiers compris entre 2 et 2 ⁶³ - 1 .

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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 octets

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

Mon premier programme APL; les suggestions de golf sont appréciées.

              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 octets 81 octets 79 octets 75 octets

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

Vérifie si la puissance entière la plus proche de la racine possible est égale n. ~~(.5+...)est équivalent à Math.round(...)pour les expressions dans la plage entière (0 à 2 ^ 31 - 1).

Modifier: utilisé la &&logique paresseuse au lieu de ifraser 2 octets et ajouté une invite d'entrée car la question a ajouté une clarification. Supposait auparavant que l'entrée était stockée dans n.

Edit 2: modifié ~~(.5+...)pour .5+...|0enregistrer deux octets en évitant le regroupement.

Edit 3: supprimé varpour enregistrer 4 octets. En mode non strict, cela est acceptable.

Brachylog , 8 octets

≥^↙.?≥ℕ≜

Essayez-le en ligne!

Prend l'entrée via sa variable d'entrée et génère chaque puissance via sa variable de sortie, dans l'ordre croissant selon les besoins, contrairement à l'ancienne solution ≥ℕ≜^↙.?∧qui se trouve avoir exactement la même longueur.

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

Je n'ai aucune justification rigoureuse pour affirmer que chaque exposant n'est pas supérieur à l'entrée, mais pour que le programme se termine réellement, il doit être limité.

ḋḅlᵛfest une solution beaucoup plus courte (non génératrice) pour tous les cas de test donnés, mais elle échoue si l'entrée n'est pas une puissance d'un produit de nombres premiers distincts. (Venez y penser, puisque tous les cas de test sont des pouvoirs de nombres premiers, ḋlfça marche aussi ...) Le meilleur que j'ai trouvé pour sauver l'idée ḋḅlᵐḋˢ⊇ᵛ×f,, sort à 10 octets.

Gelée , 6 octets

ÆEg/ÆD

Essayez-le en ligne!

    ÆD    The list of divisors of
ÆE        the exponents in the prime factorization of the input
   /      reduced by
  g       greatest common divisor.

05AB1E , 3 octets

Ó¿Ñ

Essayez-le en ligne!

Réponse de Port of Unrelated String's Jelly .

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

JavaScript ES7, 66 octets

Tire parti des compréhensions expérimentales des tableaux. Fonctionne uniquement sur Firefox.

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

Golf possible. J'essaierai probablement d'écraser les expressions un peu plus courtes et j'espère trouver une alternative à la longue Array(n).keys()syntaxe.

Peut être plus court mais JavaScript a une précision horriblement virgule flottante.

CJam, 20 octets

ri_,1df+\1$fmL9fmO&p

Pour l'entrée n , cela calcule le log _b n pour tout b inférieur ou égal à n et conserve les résultats qui sont des entiers.

Cela devrait fonctionner pour tous les entiers compris entre 2 et 9 999 . Le temps d'exécution est à peu près O (n) .

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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.

Rubis, 50

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

Imprime à l'écran.

Rubis, 57

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

Renvoie un tableau.

En programme de 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)

Calcule chaque racine et les teste modulo 1 pour voir si le reste est inférieur à 1e-8. En raison de la précision limitée, certaines racines entières valides sont calculées sous la forme 0,9999 .., d'où la nécessité de leur ajouter 1e-9.

On calcule jusqu'à la nième racine de n, ce qui est une surpuissance totale, mais semblait le moyen le plus court d'écrire une boucle non infinie.

Stax , 6 octets

£ÅeÉåC

Exécuter et déboguer

Tous les diviseurs du nombre entier d'exposants dans la décomposition en facteurs premiers. C'est la même chose que l'algorithme de gelée.

DC, 104 octets

L'entrée est prise à partir du terminal, la sortie est imprimée et également sur la pile.

Parce que cela utilise le? opérateur, vous devez utiliser dc -e "<solution>"ou dc <file with solution in it>.

Personne ne voit jamais mes réponses, encore moins voter sur elles, mais j'aime vraiment résoudre des problèmes dans DC. C'est la solution la moins efficace dans ce fil jusqu'à présent, mais j'ai pensé que je la publierais de toute façon.

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

trucs de démarrage

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 pour élever une base à tous les pouvoirs jusqu'à ce que le résultat soit supérieur à la cible ou égal à la cible

[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 pour enregistrer une valeur d'exposant valide trouvée dans les macros d'exposant ci-dessus dans une autre pile

[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 pour exécuter la macro 2x ci-dessus (macro c) sur toutes les bases de 2 à notre nombre cible

[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 pour imprimer les valeurs de la pile 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)

Rubis , 46 octets

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

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 93 octets

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

Essayez-le en ligne!

Japt , 10 octets

õ
f@mpX øN

Essayez-le

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