Scrivi il programma più breve per stampare in ordine i poteri non banali ≤ 2 ^ 12

potere non banale significa che la base e l'esponente sono> 1

Lo spazio bianco principale è facoltativo
Quando ci sono più soluzioni, l'ordine non è importante, quindi

16 = 4^2, 2^4 va bene

Uscita campione:

      4 = 2^2
      8 = 2^3
      9 = 3^2
     16 = 2^4, 4^2
     25 = 5^2
     27 = 3^3
     32 = 2^5
     36 = 6^2
     49 = 7^2
     64 = 2^6, 4^3, 8^2
     81 = 3^4, 9^2
    100 = 10^2
    121 = 11^2
    125 = 5^3
    128 = 2^7
    144 = 12^2
    169 = 13^2
    196 = 14^2
    216 = 6^3
    225 = 15^2
    243 = 3^5
    256 = 2^8, 4^4, 16^2
    289 = 17^2
    324 = 18^2
    343 = 7^3
    361 = 19^2
    400 = 20^2
    441 = 21^2
    484 = 22^2
    512 = 2^9, 8^3
    529 = 23^2
    576 = 24^2
    625 = 5^4, 25^2
    676 = 26^2
    729 = 3^6, 9^3, 27^2
    784 = 28^2
    841 = 29^2
    900 = 30^2
    961 = 31^2
   1000 = 10^3
   1024 = 2^10, 4^5, 32^2
   1089 = 33^2
   1156 = 34^2
   1225 = 35^2
   1296 = 6^4, 36^2
   1331 = 11^3
   1369 = 37^2
   1444 = 38^2
   1521 = 39^2
   1600 = 40^2
   1681 = 41^2
   1728 = 12^3
   1764 = 42^2
   1849 = 43^2
   1936 = 44^2
   2025 = 45^2
   2048 = 2^11
   2116 = 46^2
   2187 = 3^7
   2197 = 13^3
   2209 = 47^2
   2304 = 48^2
   2401 = 7^4, 49^2
   2500 = 50^2
   2601 = 51^2
   2704 = 52^2
   2744 = 14^3
   2809 = 53^2
   2916 = 54^2
   3025 = 55^2
   3125 = 5^5
   3136 = 56^2
   3249 = 57^2
   3364 = 58^2
   3375 = 15^3
   3481 = 59^2
   3600 = 60^2
   3721 = 61^2
   3844 = 62^2
   3969 = 63^2
   4096 = 2^12, 4^6, 8^4, 16^3, 64^2

Ruby 1.9, 112 111 99 caratteri

4097.times{|x|s=[]
2.upto(64){|a|2.upto(12){|b|a**b==x&&s<<[a,b]*?^}}
puts [x,s*", "]*" = "if s[0]}

Il completamento del mio sistema richiede circa 0,8 secondi. Una soluzione più veloce è lunga 111 caratteri:

h={};(2..64).map{|a|(2..12).map{|b|a**b<4097&&(h[a**b]||=[])<<[a,b]*?^}}
puts h.sort.map{|a,b|[a,b*", "]*" = "}

Python, 113

R = raggio
per k in R (4097):
 v = ',' .join (`i` + '^' +` j`per i in R (2,65) per j in R (2,13) ​​se i ** j == k)
 se v: stampa k, '=', v

Questo richiede alcuni secondi per il completamento.
Una versione più veloce (148 caratteri), usando un dizionario per evitare il ciclo più esterno, gira in ~ 0,01 sec:

R = raggio (2,65)
p = {}
per i in R:
 per j in R:
    se i ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' +` j`]
per k, v in ordine (p.items ()): stampa k, '=', ',' .join (v)

Windows PowerShell, 102

Con l'aiuto di Ventero per il codice iniziale.

$OFS=', '
4..4KB|%{$x=$_
if($s=2..64|%{$a=$_
2..12|?{[math]::pow($a,$_)-eq$x}|%{"$a^$_"}}){"$x = $s"}}

Interactive J, 118 101 98

3 :0"0 i.4097
if.#l=.":2j2+63(<.@%~j.|)I.y=,^/~2+i.63
do.echo(":y),' = ',l rplc j`^,' ';', 'end.
)

(ultima riga nuova non necessaria)

Ancora molto codice per la presentazione ...

Nota: in teoria cambiando 63e 63to ye ysalva altri 2 byte, ma quella versione utilizza una quantità estrema di memoria.

A cura di randomra.

Bash, 138 caratteri

i=2;j=1
f(){((v>4096))&&((j=1,++i))
a[$v]+="$i^$j, "
((v=i**++j,i<65))&&f
}
f
f(){
echo $j = ${a[$j]}
((j++<v))&&f
}
f|sed '/=$/d;s/.$//'

Le modifiche

• (169: 155) 2 forper a while.
• (155: 148) Aggiungi con+=
• (148: 147) output con while, riutilizzando j
• (147: 142) usa sed per rimuovere le righe vuote
• (142: 137) mettere vin (())utilizzare v per 4096 (ultimo valore)
• (137: 134) rimuove le citazioni sed, unisce le (())espressioni
• (134: 132) sostituisce i loop con funzioni ricorsive
• (132: 142) dimenticato la virgola ,:(
• (142: 138) stanco degli aggiornamenti: p

PHP, 138 caratteri - Uscita

<?for($b=1;++$b<65;)for($e=1;++$e<13;)if(4097>$f=pow($b,$e))$p[$f][]="$b^$e";ksort($p);foreach($p as$n=>$c)echo"$n = ".join($c,", ")."\n";

Ungolfed

<?php

// Array of combinations

$powers = array();

// Loop through every base from 2 to 64, as 64 is the highest you can go

for($base = 2; $base < 65; $base++){

    // Loop through all powers from 2 to 12, as 12 is the maximum

    for($power = 2; $power < 13; $power++){

        // Calculate the power

        $end = pow($base, $power);

        // Kill the loop if the result is too high

        if($end > 4096){
            break;
        }

        // Add the combination if the result is within limits

        $powers[$end][] = $base."^".$power;
    }
}

// Sort the powers by the total amount

ksort($powers);

// Output the powers in the correct format

foreach($powers as $number => $combinations){
    echo $number." = ".implode($combinations, ", ")."\n";
}

Python, 127 caratteri

F={}
for i in range(693):a,b=i/11+2,i%11+2;F[a**b]=F.get(a**b,'')+', %d^%d'%(a,b)
for k in sorted(F)[:81]:print k,'=',F[k][2:]

Mathematica, 152 byte

Print/@Cases[Range@4096,n_/;(2<=##&&##==##&)@@(f=#2&@@@FactorInteger@#&)@n:>{n,Row[{n^(1/#),#}~Row~"^"&/@Reverse@Rest@Divisors@#,", "]&@@f@n}~Row~" = "]

È diventato imbarazzantemente lungo. Qualcosa come 25 caratteri vengono spesi per la formattazione dell'output. Il codice attuale è abbastanza semplice: filtra quei numeri in cui tutti gli esponenti nella scomposizione in fattori primi sono uguali. Quindi, per ognuno di questi si ottiene un risultato per ciascun divisore dell'esponente (escluso 1, incluso se stesso).

C (589 byte)

int pow(int a,int b){
   int res = 1;
   while(b>0){
    while(b%2 == 0){
        a *= a; b/=2;
    }
    b--;
    res = res*a;
}
return res;
}
char s[99],t[9];

int main(){
   int N,T,a,i,f,e,n;
  for(n = 2; n <= 1<<12; n++){
      strcpy(s,"");
      T = N = n;
      f = 0;
      int sqt = sqrt(N)+1;
      for(i = 2; i <= sqt; i++){
         for(e=0;0==N%i;e++,N/=i);
           for(a = i; e > 1;e = e%2?(e+1)/2:e/2)
              for(a=i;a<T;pow(a,e)==T?f++?0:printf("%d =",T),sprintf(t,", %d^%d",a,e),strcat(s,t):0,a*=i);
    }
    f?puts(s+1):0;
   }
   return 0;
 }

Non ho giocato a golf, anche questo approccio non è il migliore, ma abbastanza veloce da produrre uno 0 esatto in ideone .

Batterie OCaml +, 220 206 158 156 caratteri

Trarre un suggerimento dalle soluzioni più votate:

Printf.(iter(fun x->match
String.join", "[?List:sprintf"%d^%d"b e|b<-2--64;e<-2--12;float
x=float b**float e?]with""->()|s->printf"%5d = %s\n"x s)(4--4096))

(Le terminazioni di linea in spazi significativi per mantenere le linee corte.) Una versione più veloce ma più lunga che genera poteri invece di testarli:

Printf.(List.(iter(fun l->printf"%5d = %s\n"(fst(hd l))(String.join", "(map
snd l)))(group(fun(x,_)(y,_)->x-y)[?List:truncate p,sprintf"%d^%d"b
e|b<-2--64;e<-2--12;p<-List:[float b**float e];p<=4096.?])))

Haskell, 146 caratteri

c[a]=a
c(a:z)=a++", "++c z
n#[]=""
n#s=shows n$" = "++c s++"\n"
main=putStr$(\n->n#[shows x$'^':show y|x<-[2..64],y<-[2..12],x^y==n])=<<[4..4096]

JavaScript, 160

o={}
i=2
s=''
n=4097
for(k=4;k<n;k=++i*i)for(j=2;k<n;k*=i)
{a=i+'^'+j
if(o[k])o[k]+=', '+a
else o[k]=a
j++}for(i=0;i<n;i++)if(o[i])s+='\n'+i+' = '+o[i]
alert(s)

194

o={},i=2,s='',n=4096
for(k=4;k<=n;k=i*i){for(j=2;k<=n;k*=i){o[k]=o[k]||[]
o[k].push(i+'^'+j)
j++}i++}
for(i=0;i<n;i++){if(o[i]){s+='\n'+i+' = '
for(j in o[i])s+=(j==0?'':', ')+o[i][j]}}
alert(s)

Pyth, 39 byte

jm++^Fhd" = "j", "jL\^d<.g^Fk^tS64 2 81

Provalo online qui .

jm++^Fhd" = "j", "jL\^d<.g^Fk^tS64 2 81
                               S64       [1-64]
                              t          Discard first element
                             ^     2     Cartesian product of the above with itself
                        .g               Group the pairs, as k, using:
                          ^Fk              [a,b] -> a^b
                       <             81  Take the first 81 results of the above (those where exponential <= 4096)
 m                                       Map the remaining groups, as d, using:
                  jL\^d                    Join each pair in d on "^"
             j", "                         Join on ", "
  +     " = "                              Prepend " = "
   +^Fhd                                   Prepend the result of the exponent of one of the pairs
j                                        Join the result of the above on newlines, implicit print

Se il formato di output è abbastanza flessibile da rimuovere la necessità di spazi, -5 byte da sostituire " = "con \=e ", "con\,

Haskell, 131

p[]=return()
p((x,y,z):s)=do print$show x++" = "++show y++"^"++show z;p s
main=p [(x,y,z)|x<-[2..2^12],y<-[2..x],z<-[2..x],x==y^z]

JavaScript, 148 caratteri

s=''
for(i=2;i<4097;i++){q=''
for(a=2;a<65;a++)for(b=2;b<13;b++)if(Math.pow(a,b)==i)q+=a+'^'+b+', '
if(q)s+=i+' = '+q.slice(0,-2)+"\n"}alert(s)

C 184

Dovrebbe compilare (con avvertenze) con qualsiasi compilatore C.

char*l[5000],*t=l+4100,*u;
main(b,e,r) 
{
  for(;++b<65;)
    for(e=2,r=b;(r*=b)<4100;l[r]=u)
      t+=1+sprintf(u=t,"%s, %d^%d",l[r]?l[r]:"",b,e++);
  for(r=1;++r<4097;)
    l[r]&&printf("%d =%s\n",r,l[r]+1);
}

Pyth, 55 caratteri

=Tr2 64V^2 12JYFZTFbTIqN^ZbaJj\^[Zb))))IJjk[Nd\=dj", "J

La prima volta che utilizzo Pyth, quindi probabilmente può essere migliorato. È una forza bruta che controlla fino a 64 ^ 64, quindi è piuttosto lenta. Puoi risparmiare tempo controllando solo fino a 64 ^ 12 ma costerebbe un byte.

JavaScript (ES6) 134 127

Modifica revisionata, corretta e abbreviata Modifica 2 Dopo alcune ricerche, mi sono reso conto che questa risposta non era valida per motivi cronologici. La domanda precede arrow functionsdi anni.

Detto questo, le altre risposte di JS sono troppo complicate

/* for TEST:redefine console.log */ console.log=x=>O.innerHTML+=x+'\n';

for(l=[],b=1;++b<65;)for(e=2,r=b;(r*=b)<4197;)(l[r]=l[r]||[]).push(b+'^'+e++);l.some(function(v,i){console.log(i+' = '+v.join(', '))})

<pre id=O></pre>

05AB1E , 36 byte

2žxŸãΣ`m}99£.γ`m}εн`m'=yε'^ý}„, ý)}»

Ho la sensazione che questo possa essere migliorato un po 'usando un approccio leggermente diverso ..

Provalo online.

Spiegazione:

2žxŸ           # Create a list in the range [2,64]
    ã          # Create each possible pair by taking the cartesian product with itself
Σ`m}           # Sort these `a,b`-pairs by their result of `a ** b`
    99£        # Only leave the first 99 pairs
       .γ`m}   # And then group the `a,b`-pairs by their result of `a ** b`
ε              # Now map each list of pairs `y` to:
 н             #  Take the first pair of list `y`
  `m           #  Take the `a ** b` value
 '=           '#  Push character "=" to the stack
 yε            #  Inner map over the pairs of list `y`:
   '^ý        '#   Join each pair with a "^" delimiter
      }„, ý    #  After the inner map: join these strings with a ", " delimiter
 )             #  Wrap all values on the stack into a list
}»             # After the outer map: join every inner list by spaces,
               # and the outer list by newlines (and output the result implicitly)