Napisz najkrótszy program, aby wydrukować nietrywialne moce ≤ 2 ^ 12 w kolejności

potęga nietrywialna oznacza, że ​​podstawa i wykładnik są> 1

Wiodące białe znaki są opcjonalne
Jeśli istnieje wiele rozwiązań, kolejność nie jest ważna, więc

16 = 4^2, 2^4 jest ok

Przykładowe dane wyjściowe:

      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 znaków

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

Wykonanie tego w moim systemie zajmuje około 0,8 sekundy. Szybsze rozwiązanie ma 111 znaków:

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 = zakres
dla kw R (4097):
 v = ',' .join (`i '+' ^ '+` j` dla i w R (2,65) dla j w R (2,13) ​​jeśli i ** j == k)
 if v: print k, '=', v

Wykonanie tego zajmuje kilka sekund.
Wersja szybsza (148 znaków), wykorzystująca słownik do unikania najbardziej zewnętrznej pętli, działa w ~ 0,01 sekundy:

R = zakres (2,65)
p = {}
dla i w R:
 dla jw R:
    jeśli i ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' +` j`]
dla k, v posortowane (p.items ()): print k, '=', ',' .join (v)

Windows PowerShell, 102

Z pomocą Ventero dla kodu początkowego.

$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.
)

(ostatni niepotrzebny nowy wiersz)

Wciąż dużo kodu do prezentacji ...

Uwaga: w teorii zmianie 63i 63do yi yoszczędza 2 kolejne bajty, ale ta wersja używa ekstremalne ilości pamięci.

Edytowane przez randomra.

Bash, 138 znaków

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/.$//'

Edycje

• (169: 155) 2 fordla a while.
• (155: 148) Dołącz z+=
• (148: 147) wyjście while, ponowne użycie j
• (147: 142) użyj sed, aby usunąć puste linie
• (142: 137) umieścić vw (()), użytkowania V 4096 (ostatnia wartość)
• (137: 134) usuwaj cytaty sed, łącz (())wyrażenia
• (134: 132) zamień pętle na funkcje rekurencyjne
• (132: 142) zapomniałem przecinka ,:(
• (142: 138) zmęczeni aktualizacjami: str

PHP, 138 znaków - Wyjście

<?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";

Nie golfił

<?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 znaków

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 bajty

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

To stało się krępująco długie. Na formatowanie wyjściowe wydaje się około 25 znaków. Rzeczywisty kod jest dość prosty: odfiltruj te liczby, w których wszystkie wykładniki w rozkładzie na czynniki pierwsze są równe. Następnie dla każdego z nich uzyskaj jeden wynik dla każdego dzielnika wykładnika (z wyłączeniem 1, włączając siebie).

C (589 bajtów)

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;
 }

Nie grałem też w golfa, to podejście nie jest najlepsze, ale jest wystarczająco szybkie, aby uzyskać dokładnie 0 w ideonie .

OCaml + Baterie, 220 206 158 156 znaków

Podpowiedź do najlepiej ocenianych rozwiązań:

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))

(Zakończenia linii znaczącą spacją, aby linie były krótkie). Szybsza, ale dłuższa wersja, która generuje moce zamiast je testować:

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 znaków

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 bajtów

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

Wypróbuj online tutaj .

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

Jeśli format wyjściowy jest na tyle elastyczny, aby usunąć potrzebę przestrzeni, -5 bajty zastąpić " = "z \=oraz ", "z\,

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 znaków

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

Powinny się kompilować (z ostrzeżeniami) z dowolnym kompilatorem 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 znaków

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

Pierwszy raz używam Pytha, więc prawdopodobnie można go poprawić. To brutalna siła, która sprawdza do 64 ^ 64, a więc jest dość wolna. Możesz zaoszczędzić czas, sprawdzając tylko do 64 ^ 12, ale kosztowałoby to bajt.

JavaScript (ES6) 134 127

Edytuj poprawioną, poprawioną i skróconą edycję 2 Po kilku badaniach zdałem sobie sprawę, że ta odpowiedź była nieprawidłowa z powodów chronologicznych. Pytanie poprzedza arrow functionslata.

To powiedziawszy, inne odpowiedzi JS są zbyt skomplikowane

/* 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 bajtów

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

Mam wrażenie, że można to nieco poprawić, stosując nieco inne podejście ...

Wypróbuj online.

Wyjaśnienie:

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)