เขียนโปรแกรมที่สั้นที่สุดเพื่อพิมพ์พลังที่ไม่สำคัญ order 2 ^ 12 ตามลำดับ

พลังงานที่ไม่สำคัญหมายถึงฐานและเลขชี้กำลังคือ> 1

ช่องว่างนำหน้าเป็นตัวเลือก
เมื่อมีวิธีแก้ปัญหาหลายคำสั่งไม่สำคัญ

16 = 4^2, 2^4 ก็โอเค

ตัวอย่างผลลัพธ์:

      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

ทับทิม 1.9 112 111 99 ตัวอักษร

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

การดำเนินการนี้ใช้เวลาประมาณ 0.8 วินาทีในระบบของฉัน วิธีแก้ปัญหาที่เร็วกว่าคือความยาว 111 ตัวอักษร:

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 = ช่วง
สำหรับ k ใน R (4097):
 v = ',' .join (`i` + '^' +` j` สำหรับ i ใน R (2,65) สำหรับ j ใน R (2,13) ​​ถ้า i ** j == k)
 ถ้า v: print k, '=', v

การดำเนินการนี้ใช้เวลาสองสามวินาที
รุ่นที่เร็วขึ้น (148 ตัวอักษร) ใช้พจนานุกรมเพื่อหลีกเลี่ยงการวนรอบนอกสุดทำงานใน ~ 0.01 วินาที:

R = ช่วง (2,65)
p = {}
สำหรับฉันใน R:
 สำหรับ j ใน R:
    ถ้า i ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' +` j`]
สำหรับ k, v ในการเรียงลำดับ (p.items ()): print k, '=', ',' .join (v)

Windows PowerShell, 102

ด้วยความช่วยเหลือจาก Ventero สำหรับรหัสเริ่มต้น

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

อินเตอร์แอคที 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.
)

(ขึ้นบรรทัดใหม่ที่ไม่จำเป็น)

ยังมีรหัสจำนวนมากสำหรับงานนำเสนอ ...

หมายเหตุ: ในทางทฤษฎีการเปลี่ยนแปลง63และ63ไปยังyและyบันทึกอีก 2 ไบต์ แต่รุ่นนั้นใช้หน่วยความจำจำนวนมาก

แก้ไขโดย randomra

Bash, 138 ตัวอักษร

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

การแก้ไข

• (169: 155) 2 สำหรับforwhile
• (155: 148)ผนวกเข้าด้วย+=
• เอาท์พุท(148: 147)ด้วยการwhileใช้ซ้ำ j
• (147: 142)ใช้ sed เพื่อลบบรรทัดว่าง
• (142: 137)ใส่vเข้าไป(())ใช้ v สำหรับ 4096 (ค่าสุดท้าย)
• (137: 134)ลบเครื่องหมายคำพูด, เข้าร่วม(())การแสดงออก
• (134: 132)แทนที่ลูปด้วยฟังก์ชันแบบเรียกซ้ำ
• (132: 142)ลืมเครื่องหมายจุลภาค,:(
• (142: 138)เบื่อกับการอัพเดท: p

PHP, 138 ตัวอักษร - ผลลัพธ์

<?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 ตัวอักษร

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 ไบต์

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

สิ่งนี้มีความยาวน่าอาย มีการใช้บางอย่างเช่น 25 อักขระในการจัดรูปแบบผลลัพธ์ รหัสจริงค่อนข้างง่าย: กรองตัวเลขเหล่านั้นโดยที่เลขชี้กำลังทั้งหมดในการแยกตัวประกอบเฉพาะมีค่าเท่ากัน จากนั้นสำหรับแต่ละผลลัพธ์จะมีหนึ่งผลลัพธ์สำหรับตัวหารแต่ละตัวของเลขชี้กำลัง (ยกเว้น 1 รวมถึงตัวของมันเอง)

C (589 ไบต์)

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

ฉันไม่ได้แข็งแรงเล่นกอล์ฟยังวิธีการนี้จะไม่ดีที่สุด แต่ยังไม่เร็วพอที่จะผลิต 0s แน่นอนในideone

OCaml + แบตเตอรี่220 206 158 156 ตัวอักษร

รับคำแนะนำจากโซลูชันที่ได้คะแนนสูงสุด:

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

(การสิ้นสุดบรรทัดที่ช่องว่างที่สำคัญเพื่อให้บรรทัดสั้น) เวอร์ชันที่เร็วกว่า แต่ยาวกว่าที่สร้างพลังแทนการทดสอบ:

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 ตัวอักษร

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 ไบต์

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

ลองออนไลน์ได้ที่นี่

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

หากรูปแบบเอาต์พุตมีความยืดหยุ่นเพียงพอที่จะลบความต้องการช่องว่าง -5 ไบต์เพื่อแทนที่" = "ด้วย\=และ", "ด้วย\,

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 ตัวอักษร

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

ควรรวบรวม (พร้อมคำเตือน) ด้วยตัวแปลภาษา 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 ตัวอักษร

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

ครั้งแรกของฉันเมื่อใช้ Pyth ดังนั้นอาจปรับปรุงได้ มันเป็นสัตว์เดรัจฉานที่ตรวจสอบมากถึง 64 ^ 64 ดังนั้นจึงค่อนข้างช้า คุณสามารถประหยัดเวลาด้วยการตรวจสอบสูงสุด 64 ^ 12 แต่จะเสียค่าใช้จ่ายเป็นไบต์

JavaScript (ES6) 134 127

แก้ไขแก้ไขข้อผิดพลาดและสั้นลง แก้ไข 2หลังจากการวิจัยบางอย่างฉันรู้ว่าคำตอบนี้ไม่ถูกต้องสำหรับเหตุผลตามลำดับเหตุการณ์ คำถามมาก่อนarrow functionsหลายปี

ทั้งหมดที่กล่าวมาคำตอบ JS อื่น ๆ นั้นซับซ้อนเกินไป

/* 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 ไบต์

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

ฉันมีความรู้สึกว่าสิ่งนี้สามารถปรับปรุงได้เล็กน้อยโดยใช้วิธีการที่แตกต่างกันเล็กน้อย ..

ลองออนไลน์

คำอธิบาย:

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)