Las computadoras viven por binario. Todos los programadores saben binario.

Pero las 2**xbases a menudo se descuidan como no prácticas, mientras que tienen hermosas relaciones con lo binario.

Para mostrarles un ejemplo de una relación tan hermosa, 19 será mi testimonio.

19 10011 103 23 13 j

• 19 es decimal, incluido para mayor claridad.

• 10011 es 19 en binario.

• 103, en la base 4 se realiza a partir de binario de esta manera:

  • log2 (4) == 2, recordemos dos.
  • Pad 10011 para que tenga un múltiplo de 2 longitudes -> 010011

  • Tome los dígitos 2 por 2 de izquierda a derecha y trátelos como números binarios de 2 dígitos:

    • 01 -> 1
    • 00 -> 0
    • 11 -> 3

  Hecho , 10011 en base-4 es 103.

Para la base 8, haga lo mismo pero 3 por 3 como log2 (8) = 3.

• Pad 010011
• 010 -> 2

• 011 -> 3

  23, hecho .

Para la base 16, haga lo mismo pero 4 por 4 como log2 (16) = 4.

• Pad 00010011
• 0001 -> 1

• 0011 -> 3

  13, hecho .

Tarea

Dado un número máximo como entrada, debe generar una tabla

base-ten-i base-two-i base-four-i base-eight-i base-sixteen-i base-thirtytwo-i

para i que va de 0 a n inclusive. Los números binarios son el epítome del mínimo absoluto necesario para trabajar, por lo que su código debe ser lo más corto posible.

Restricciones y bonos

• Base-diez -> binario y binario -> Las bases-diez incorporadas se consideran lagunas legales como Base-a -> Base-b.

• Si genera todas las 2**ibases (para i> 2) utilizando las relaciones antes mencionadas, obtendrá un *0.6bono, pero se permiten conversiones de bases generales (escritas por usted mismo).

Tabla de ejemplo

> 32
0 0 0 0 0 0
1 1 1 1 1 1
2 10 2 2 2 2
3 11 3 3 3 3
4 100 10 4 4 4
5 101 11 5 5 5
6 110 12 6 6 6
7 111 13 7 7 7
8 1000 20 10 8 8
9 1001 21 11 9 9
10 1010 22 12 a a
11 1011 23 13 b b
12 1100 30 14 c c
13 1101 31 15 d d
14 1110 32 16 e e
15 1111 33 17 f f
16 10000 100 20 10 g
17 10001 101 21 11 h
18 10010 102 22 12 i
19 10011 103 23 13 j
20 10100 110 24 14 k
21 10101 111 25 15 l
22 10110 112 26 16 m
23 10111 113 27 17 n
24 11000 120 30 18 o
25 11001 121 31 19 p
26 11010 122 32 1a q
27 11011 123 33 1b r
28 11100 130 34 1c s
29 11101 131 35 1d t
30 11110 132 36 1e u
31 11111 133 37 1f v
32 100000 200 40 20 10

CJam, 54 * 0.6 = 32.4 bytes

q~){_5,f{)L@{2md@+\}h(%/Wf%W%{{\2*+}*_9>{'W+}&}%S\}N}/

Pruébalo aquí.

Como referencia, aquí hay una solución más corta que no califica para la bonificación (a 39 bytes):

q~){:X5{SLX{2I)#md_9>{'W+}&@+\}h;}fIN}/

Pyth, 52 * 0.6 = 31.2 bytes

L?b+%b2y/b2YVUhQjd+NmjkX|_uL++GGHZ_McyNd]ZUQ+jkUTGS5

Pruébelo en línea

Mi respuesta no extra es de 39 bytes

M?G+g/GHH@+jkUTG%GHkVUhQjd+N|R0gLN^L2S5

PHP, 232 230 233 217 * 0.6 = 130.2

No hay posibilidad de vencer a los idiomas de golf, pero me gustó el desafío.

for(;$d<=$n;$d++){echo'
',$d|0;for($k=$d,$b='';$k;$k>>=1)$b=($k&1).$b;for($w=1;$w<6;$w++,print" $z"|' 0')for($z='',$k=strlen($b);-$w<$k-=$w;$z=($e>9?chr($e+87):$e).$z)for($e=0,$y=1,$j=$w;$j--;$y*=2) $e+=$y*$b[$j+$k];}

• uso: anteponer $n=32;o reemplazar $ncon 32(o cualquier otro número entero no negativo); llamar por cli
• Si eso no se acepta, reemplace $ncon $_GET[n](+ 6 / + 3.6) y llame ya sea en el navegador
  o en cli conphp-cgi -f bases.php -n=32
• Reemplazar el salto de línea con <br>o anteponer <pre>para probar en el navegador
• puede lanzar avisos para variables indefinidas y compensaciones de cadenas no inicializadas en versiones PHP más recientes.
  Elimine E_NOTICE de error_reporting (prepend error_reporting(0);) para suprimirlos.
• probado en 5.6

Descompostura:

for(;$d<=$n;$d++) // loop decimal $d from 0 to $n
{
    echo'
',$d|0; // print line break and decimal
    for($k=$d,$b='';$k;$k>>=1)$b=($k&1).$b; // convert $d to binary
    for($w=1;$w<6;$w++,
        print" $z"|' 0' // print number generated in inner loop (echo doesn´t work here)
    )
        for($z='',$k=strlen($b);-$w<$k-=$w; // loop from end by $w
            $z=($e>9?chr($e+87):$e).$z // prepend digit created in body
        )
            for($e=0,$y=1,$j=$w;$j--;$y*=2) $e+=$y*$b[$j+$k]; // convert chunk to 2**$w
}

edición principal:

• usó un poco de magia de índice para renovar el bucle interno -> ahora funciona al revés en toda la cadena (no más relleno, no más división o copia del binario)
• movió partes de los cuerpos de bucle a las cabezas para eliminar los aparatos
• tuvo que agregar 7 4 bytes para arreglar los resultados decimales 0 después de la renovación

versión sin bonificación, 142 bytes

for(;$d<=$n;$d++,print'
',$d|0)for($w=1;$w<6;$w++,print" $z"|' 0')for($k=$d,$y=1,$z='';$k&&$y<<=$w;$k>>=$w)$z=(9<($e=$k%$y)?chr($e+87):$e).$z;

PHP supera a Python?
Incluso si agrego los 6 (3.6) bytes para hacer que el fragmento sea un programa, todavía vencería a Python (223 * 0.6 = 133.8 o 148 sin bonificación vs. 158). Asombroso.

Ruby, 80 bytes (versión sin bonificación)

m=ARGV[0].to_i;(0..m).each{|n|puts [10,2,4,8,16,32].map{|b|n.to_s(b)}.join(' ')}

Python3: 189, 167, 166, 150 bytes

for i in range(int(input())+1):f=lambda b,n=i,c="0123456789abcdefghijklmnopqrstuv":n<b and c[n]or f(b,n//b)+c[n%b];print(i,f(2),f(4),f(8),f(16),f(32))

¡ Ahorré 16 bytes con la ayuda de @ LeakyNun !

Versión de bonificación: 296 * 0.6 = 177.6 279 * 0.6 = 167.4 bytes

p=lambda b,c:"".join(str(int(b[i:i+c],2))for i in range(0,len(b),c))
z=lambda s:len(s)%2 and s or "0"+s
for i in range(int(input())+1):f=lambda n,b,c="0123456789abcdefghijklmnopqrstuv":n<b and c[n]or f(n//b,b)+c[n%b];v=f(i,2);d=z(v);print(i,v,p(d,2),p(d,3),p(d,4),p(d,5),f(i,32))

Versión ligeramente más legible de la versión de bonificación.

p=lambda b,c:"".join(str(int(b[i:i+c],2))for i in range(0,len(b),c))
z=lambda s:len(s)%2 and s or "0"+s
for i in range(int(input())+1):
    f=lambda n,b,c="0123456789abcdefghijklmnopqrstuv":n<b and c[n] or f(n//b,b) + c[n%b]
    v=f(i,2)
    d=z(v)
    print(i,v,p(d,2),p(d,3),p(d,4),p(d,5),f(i,32))