Poderes no triviales

15

Escriba el programa más corto para imprimir los poderes no triviales ≤ 2 ^ 12 en orden

poder no trivial significa que la base y el exponente son> 1

El espacio en blanco inicial es opcional
Cuando hay varias soluciones, el orden no es importante, por lo que

16 = 4^2, 2^4 esta bien

Salida de muestra:

      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
gnibbler
fuente
Aquí faltan muchos poderes; ¿Qué pasa con 21 ^ 3, etc.? ¿Cuál es su definición de "poderes no triviales"?
hallvabo
¿También es posible imprimir varias líneas con el mismo número a la izquierda, si hay varias soluciones?
FUZxxl
@hallvabo, ¡Uy! Todavía no hemos tomado café esta mañana. lo arregló ahora
gnibbler
@FUZxxl, debe poner las múltiples soluciones en la misma línea, aunque por interés envíe la versión alternativa también si el requisito marca una gran diferencia en su idioma
gnibbler
+1 cuando obtengo más votos :-)
hallvabo

Respuestas:

6

Ruby 1.9, 112 111 99 caracteres

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

Esto demora aproximadamente 0,8 segundos en completarse en mi sistema. Una solución más rápida tiene 111 caracteres de longitud:

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

Python, 113

R = rango
para k en R (4097):
 v = ',' .join (`i` + '^' +` j` para i en R (2,65) para j en R (2,13) ​​si i ** j == k)
 si v: imprime k, '=', v

Esto lleva unos segundos en completarse.
Una versión más rápida (148 caracteres), que usa un diccionario para evitar el bucle más externo, se ejecuta en ~ 0.01 segundos:

R = rango (2,65)
p = {}
para i en R:
 para j en R:
    si i ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' +` j`]
para k, v en orden (p.items ()): print k, '=', ',' .join (v)
hallvabo
fuente
Estoy bastante seguro de que se requiere el signo igual para la salida, aunque eso no debería cambiar mucho el tamaño del código.
Kevin Brown
Whops, lo eliminé accidentalmente cuando eliminé el espacio en blanco (opcional). ¡Arreglado!
hallvabo
4

Windows PowerShell, 102

Con ayuda de Ventero para el código inicial.

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

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

(última línea innecesaria)

Todavía hay mucho código para la presentación ...

Nota: en la teoría de cambiar 63y 63para yy yahorra más de 2 bytes, sino que utiliza la versión extrema cantidad de memoria.

Editado por randomra.

JB
fuente
Usando [space] j [backtick] ^, ''; ',' en lugar de 'j';'^';' ';', 'guardar 3 bytes. (Dado el formato ...)
randomra
@randomra Tienes derechos de edición; ¡por favor adelante! (No puedo encontrar una casilla con J para verificar con mi configuración actual, y estoy apurado). Esto haría que J fuera el mejor del espectáculo, ¡sería una pena no presumirlo! :-)
JB
3

Bash, 138 caracteres

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

Ediciones

  • (169: 155) 2 forpara a while.
  • (155: 148) Agregar con+=
  • (148: 147) salida con while, reutilizando j
  • (147: 142) usa sed para eliminar líneas vacías
  • (142: 137) poner ven (()), el uso v para 4096 (último valor)
  • (137: 134) eliminar comillas sed, unir (())expresiones
  • (134: 132) reemplazar bucles con funciones recursivas
  • (132: 142) olvidé la coma ,:(
  • (142: 138) cansado de actualizaciones: p
Eelvex
fuente
2

PHP, 138 caracteres - Salida

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

Sin golf

<?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";
}
Kevin Brown
fuente
2

Python, 127 caracteres

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:]
Keith Randall
fuente
2

Mathematica, 152 bytes

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

Esto se hizo vergonzosamente largo. Algo así como 25 caracteres se gastan en el formato de salida. El código real es bastante simple: filtre aquellos números donde todos los exponentes en la factorización prima son iguales. Luego, para cada uno de ellos, se produce un resultado para cada divisor del exponente (excluyendo 1, incluido él mismo).

Martin Ender
fuente
1

C (589 bytes)

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

No jugué al golf también, este enfoque no es el mejor, pero sí lo suficientemente rápido como para producir un 0 exacto en ideone .

Quijotesco
fuente
1

OCaml + baterías, 220 206 158 156 caracteres

Tomando una pista de las soluciones mejor calificadas:

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

(Terminaciones de línea en espacios en blanco significativos para mantener las líneas cortas.) Una versión más rápida pero más larga que genera poderes en lugar de probarlos:

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.?])))
Matías Giovannini
fuente
1

Haskell, 146 caracteres

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]
MtnViewMark
fuente
1

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)
zzzzBov
fuente
2
Retrotraído; publique sugerencias de golf como comentarios, no ediciones.
lirtosiast
1

Pyth, 39 bytes

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

Pruébelo en línea aquí .

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

Si el formato de salida es lo suficientemente flexible como para eliminar la necesidad de espacios, -5 bytes para reemplazar " = "con \=y ", "con\,

Sok
fuente
0

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]
CAS
fuente
poderes que tienen el mismo valor se supone que deben estar en la misma línea
MtnViewMark
0

JavaScript, 148 caracteres

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)
Casey Chu
fuente
0

C 184

Debe compilar (con advertencias) con cualquier compilador de 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);
}
edc65
fuente
0

Pyth, 55 caracteres

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

Mi primera vez usando Pyth, por lo que probablemente pueda mejorarse. Es una fuerza bruta que controla hasta 64 ^ 64, por lo que es bastante lenta. Puede ahorrar tiempo solo comprobando hasta 64 ^ 12 pero costaría un byte.

Alce
fuente
0

JavaScript (ES6) 134 127

Edición revisada, corregida y acortada Edición 2 Después de algunas investigaciones, me di cuenta de que esta respuesta no era válida por razones cronológicas. La pregunta es anterior arrow functionsa años.

Dicho todo esto, las otras respuestas de JS son demasiado complicadas

/* 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>

edc65
fuente
Si no le importa demasiado el formato '=', puede reducirlo a 121 bytes: for (l = [], b = 1; ++ b <65;) for (e = 2, r = b ; (r * = b) <4197;) (l [r] = l [r] || []). push (b + '^' + e ++); l.map ((v, i) => consola. log (i + '=' + v.join`, `))
Mama Fun Roll
@molarmanful hay requisitos estrictos sobre el formato
edc65
Oh bueno ... al menos cambia la parte v.join. Eso al menos puede reducir la cuenta de bytes a 123.
Mama Fun Roll
@molarmanful en el momento en que se publicó este desafío (¡y esta respuesta!), las cadenas de plantilla no se implementaron en ningún navegador: Firefox fue el primero - rel 34, dic primero 2014 - luego Chrome, marzo 2015. No puede usar una función que estaba disponible 3 años después de la pregunta
edc65
Oh bueno ... no lo sabía. ¡Acabo de ingresar a ES6 hace una semana!
Mama Fun Roll
0

05AB1E , 36 bytes

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

Tengo la sensación de que esto puede mejorarse un poco utilizando un enfoque ligeramente diferente.

Pruébalo en línea.

Explicación:

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)
Kevin Cruijssen
fuente