Viết chương trình ngắn nhất để in các quyền hạn không tầm thường ≤ 2 ^ 12 theo thứ tự

sức mạnh không tầm thường có nghĩa là cơ sở và số mũ là> 1

Khoảng trắng hàng đầu là tùy chọn
Khi có nhiều giải pháp, thứ tự không quan trọng, vì vậy

16 = 4^2, 2^4 vẫn ổn

Đầu ra mẫu:

      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 ký tự

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

Điều này mất khoảng 0,8 giây để hoàn thành trên hệ thống của tôi. Một giải pháp nhanh hơn dài 111 ký tự:

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*", "]*" = "}

Con trăn, 113

R = phạm vi
cho k trong R (4097):
 v = ',' .join (`i` + '^' +` j`for i in R (2,65) cho j trong R (2,13) ​​nếu i ** j == k)
 nếu v: in k, '=', v

Điều này mất vài giây để hoàn thành.
Phiên bản nhanh hơn (148 ký tự), sử dụng từ điển để tránh vòng lặp ngoài cùng, chạy trong ~ 0,01 giây:

R = phạm vi (2,65)
p = {}
cho tôi trong R:
 cho j trong R:
    nếu tôi ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' +` j`]
for k, v in sort (p.items ()): print k, '=', ',' .join (v)

Windows PowerShell, 102

Với sự giúp đỡ của Ventero cho mã ban đầu.

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

Tương tác 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.
)

(dòng mới nhất không cần thiết)

Vẫn còn rất nhiều mã cho bài thuyết trình ...

Lưu ý: về lý thuyết thay đổi 63và 63sang yvà ytiết kiệm thêm 2 byte nhưng phiên bản đó sử dụng lượng bộ nhớ cực lớn.

Chỉnh sửa bởi ngẫu nhiên.

Bash, 138 ký tự

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

Chỉnh sửa

• (169: 155) 2 forcho a while.
• (155: 148) Nối với+=
• (148: 147) đầu ra với while, tái sử dụng j
• (147: 142) sử dụng sed để xóa các dòng trống
• (142: 137) đưa vvào (()), sử dụng v cho 4096 (giá trị cuối cùng)
• (137: 134) xóa dấu ngoặc kép, tham gia (())biểu thức
• (134: 132) thay thế các vòng lặp bằng các hàm đệ quy
• (132: 142) quên dấu phẩy ,:(
• (142: 138) mệt mỏi với các cập nhật: p

PHP, 138 ký tự - Đầu ra

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

Ung dung

<?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 ký tự

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

Toán học, 152 byte

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

Điều này đã gây bối rối lâu dài. Một cái gì đó như 25 ký tự được dành cho định dạng đầu ra. Mã thực tế khá đơn giản: lọc các số đó trong đó tất cả các số mũ trong hệ số nguyên tố đều bằng nhau. Sau đó, cho mỗi kết quả tạo ra một kết quả cho mỗi ước của số mũ (không bao gồm 1, bao gồm chính nó).

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

Tôi cũng không chơi gôn, cách tiếp cận này không phải là cách tốt nhất nhưng đủ nhanh để tạo ra số 0 chính xác trong ideone .

Pin OCaml +, 220 206 158 156 ký tự

Lấy một gợi ý từ các giải pháp ghi điểm tốt nhất:

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

(Kết thúc dòng ở khoảng trắng có ý nghĩa để giữ cho các dòng ngắn.) Phiên bản nhanh hơn nhưng dài hơn tạo ra sức mạnh thay vì kiểm tra chúng:

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 ký tự

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)

Bình thường, 39 byte

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

Hãy thử trực tuyến tại đây .

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

Nếu định dạng đầu ra đủ linh hoạt để loại bỏ nhu cầu về khoảng trắng, -5 byte để thay thế " = "bằng \=và ", "bằng\,

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 ký tự

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

Nên biên dịch (có cảnh báo) với bất kỳ trình biên dịch C nào

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

Bình, 55 ký tự

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

Lần đầu tiên tôi sử dụng Pyth, vì vậy nó có thể được cải thiện. Đó là một lực lượng vũ phu kiểm tra tới 64 ^ 64, do đó khá chậm. Bạn có thể tiết kiệm thời gian bằng cách chỉ kiểm tra tối đa 64 ^ 12 nhưng sẽ tốn một byte.

JavaScript (ES6) 134 127

Chỉnh sửa sửa đổi, sửa lỗi và rút ngắn Chỉnh sửa 2 Sau một số nghiên cứu, tôi nhận ra rằng câu trả lời này không hợp lệ vì lý do thời gian. Câu hỏi có trước hàng arrow functionsnăm.

Tất cả những gì đã nói, các câu trả lời JS khác quá phức tạp

/* 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ε'^ý}„, ý)}»

Tôi có cảm giác điều này có thể được cải thiện một chút bằng cách sử dụng một cách tiếp cận hơi khác ..

Hãy thử trực tuyến.

Giải trình:

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)