사소한 거듭 제곱 ≤ 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, 112111 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*", "]*" = "}

파이썬, 113

R = 범위
R에서 k의 경우 (4097) :
 v = ','.join (`i` + '^'+`j` R의 i (2,65)의 경우 j의 R (2,13)의 경우 i ** j == k)
 v : print k, '=', v 인 경우

완료하는 데 몇 초가 걸립니다.
가장 바깥 쪽 루프를 피하기 위해 사전을 사용하는 더 빠른 (148 자) 버전은 ~ 0.01 초 내에 실행됩니다.

R = 범위 (2,65)
p = {}
R의 경우 :
 R에서 j의 경우 :
    i ** j <4097 : p [i ** j] = p.get (i ** j, []) + [`i` + '^'+`j`] 인 경우
k, v의 경우 정렬 됨 (p.items ()) : print k, '=', ','.join (v)

윈도우 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및 y2 바이트 이상을 절약 할 수 있지만 버전은 메모리의 극단적 인 양을 사용합니다.

randomra에 의해 편집.

배쉬, 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) forA에 대한 while.
• (155 : 148)로 추가+=
• (148 : 147)로 출력 while, j 재사용
• (147 : 142) sed를 사용하여 빈 줄 제거
• (142 137) 넣어 v에서 (())4096 (전회 값)에 사용 된 V,
• (137 : 134) sed quotes를 제거하고 (())표현식을 결합하십시오
• (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";

언 골프

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

파이썬, 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;
 }

나는 골프를 치지 않았지만이 접근법은 최선의 방법은 아니지만 ideone 에서 정확한 0을 생성하기에 충분히 빠릅니다 .

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.?])))

하스켈, 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]

자바 스크립트, 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 대체 바이트 " = "로 \=와 ", "함께\,

하스켈, 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]

자바 스크립트, 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까지만 확인하면 시간을 절약 할 수 있지만 비용은 1 바이트입니다.

자바 스크립트 (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)