Imprime la tabla de tiempos f × f


46

Su tarea es imprimir la tabla de tiempos hexadecimales:

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 
00 02 04 06 08 0a 0c 0e 10 12 14 16 18 1a 1c 1e 
00 03 06 09 0c 0f 12 15 18 1b 1e 21 24 27 2a 2d 
00 04 08 0c 10 14 18 1c 20 24 28 2c 30 34 38 3c 
00 05 0a 0f 14 19 1e 23 28 2d 32 37 3c 41 46 4b 
00 06 0c 12 18 1e 24 2a 30 36 3c 42 48 4e 54 5a 
00 07 0e 15 1c 23 2a 31 38 3f 46 4d 54 5b 62 69 
00 08 10 18 20 28 30 38 40 48 50 58 60 68 70 78 
00 09 12 1b 24 2d 36 3f 48 51 5a 63 6c 75 7e 87 
00 0a 14 1e 28 32 3c 46 50 5a 64 6e 78 82 8c 96 
00 0b 16 21 2c 37 42 4d 58 63 6e 79 84 8f 9a a5 
00 0c 18 24 30 3c 48 54 60 6c 78 84 90 9c a8 b4 
00 0d 1a 27 34 41 4e 5b 68 75 82 8f 9c a9 b6 c3 
00 0e 1c 2a 38 46 54 62 70 7e 8c 9a a8 b6 c4 d2 
00 0f 1e 2d 3c 4b 5a 69 78 87 96 a5 b4 c3 d2 e1 

Especificaciones:

  • Puede imprimir los valores hexadecimales en mayúsculas.
  • Sus líneas pueden terminar con un espacio final y la salida del programa puede terminar con una nueva línea final.
  • Cada valor hexadecimal debe rellenarse con 2 dígitos con 0s como se muestra.

Este es el , por lo que gana la respuesta más corta (medida en bytes).




44
Las tablas de multiplicar generalmente no incluyen el factor 0 ... :-)
Luis Mendo

28
@Luis Mendo: ¿De qué otra manera los niños de la escuela podrán memorizar lo que es 0 veces un número? : P
leche

1
Maldición, quería hacer una solución usando hexdump, pero eso se agrupa en bloques de 4 bytes. :(
HyperNeutrino

Respuestas:



14

Python 2 , 60 bytes

for n in range(256):r=n%16;print'%02x%s'%(n/16*r,r/15*'\n'),

Pruébalo en línea!

Cómo funciona

Para todos los enteros n de 0 a 255 , hacemos lo siguiente.

  • Calculamos (n / 16) × (n% 16) .

    En el rango de n , tanto n / 16 como n% 16 cubren independientemente el rango 0, ..., 15 , por lo que esto genera todas las entradas de la tabla de multiplicación.

  • Repetimos el carácter de salto de línea ( '\n') (n% 16) / 15 veces, lo que da como resultado el mismo carácter cuando n% 16 = 15 y una cadena vacía de lo contrario.

  • La cadena de formato '%02x%s'convierte los dos resultados anteriores en una sola cadena, primero una representación entera hexadecimal en minúscula, rellenada con cero (al menos) dos dígitos, luego la cadena generada.

  • Finalmente, print...,imprime los resultados formateados.

    Como la declaración de impresión termina con una coma, Python no agregará un salto de línea. Además, antes de imprimir la siguiente cadena, Python antepondrá un espacio a menos que estemos al comienzo de una nueva línea. ( fuente ) Esto sucede para formatear la salida exactamente como queremos.


14

Jalea , 12 bytes

⁴Ḷ×þ`d⁴‘ịØhG

Pruébalo en línea!

Cómo funciona

⁴Ḷ×þ`d⁴‘ịØhG  Main link. No arguments.

⁴             Set the return value to 16.
 Ḷ            Unlength; yield [0, ..., 15].
  ×þ`         Build the multiplication table of [0, ..., 15] and itself.
     d⁴       Divmod 16; yield [p : 16, p % 16] for each product p.
       ‘      Increment quotients and remainders (1-based indexing).
        ịØh   Index into the lowercase hexadecimal alphabet.
           G  Grid; join columns by spaces, rows by newlines.

Eso es 12 caracteres, no bytes. Según la pregunta, la respuesta se mide en bytes y su respuesta es de 25 bytes y 12 caracteres . Al menos según este sitio web mothereff.in/byte-counter
Ciprum

18
En UTF-8, claro. Sin embargo, Jelly usa un SBCS , por lo que cada carácter puede codificarse usando un solo byte.
Dennis

11

R, 42 bytes

as.hexmode(sapply(0:15,function(x)x*0:15))

Imprime lo siguiente:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14] [,15] [,16]
 [1,] "00" "00" "00" "00" "00" "00" "00" "00" "00" "00"  "00"  "00"  "00"  "00"  "00"  "00" 
 [2,] "00" "01" "02" "03" "04" "05" "06" "07" "08" "09"  "0a"  "0b"  "0c"  "0d"  "0e"  "0f" 
 [3,] "00" "02" "04" "06" "08" "0a" "0c" "0e" "10" "12"  "14"  "16"  "18"  "1a"  "1c"  "1e" 
 [4,] "00" "03" "06" "09" "0c" "0f" "12" "15" "18" "1b"  "1e"  "21"  "24"  "27"  "2a"  "2d" 
 [5,] "00" "04" "08" "0c" "10" "14" "18" "1c" "20" "24"  "28"  "2c"  "30"  "34"  "38"  "3c" 
 [6,] "00" "05" "0a" "0f" "14" "19" "1e" "23" "28" "2d"  "32"  "37"  "3c"  "41"  "46"  "4b" 
 [7,] "00" "06" "0c" "12" "18" "1e" "24" "2a" "30" "36"  "3c"  "42"  "48"  "4e"  "54"  "5a" 
 [8,] "00" "07" "0e" "15" "1c" "23" "2a" "31" "38" "3f"  "46"  "4d"  "54"  "5b"  "62"  "69" 
 [9,] "00" "08" "10" "18" "20" "28" "30" "38" "40" "48"  "50"  "58"  "60"  "68"  "70"  "78" 
[10,] "00" "09" "12" "1b" "24" "2d" "36" "3f" "48" "51"  "5a"  "63"  "6c"  "75"  "7e"  "87" 
[11,] "00" "0a" "14" "1e" "28" "32" "3c" "46" "50" "5a"  "64"  "6e"  "78"  "82"  "8c"  "96" 
[12,] "00" "0b" "16" "21" "2c" "37" "42" "4d" "58" "63"  "6e"  "79"  "84"  "8f"  "9a"  "a5" 
[13,] "00" "0c" "18" "24" "30" "3c" "48" "54" "60" "6c"  "78"  "84"  "90"  "9c"  "a8"  "b4" 
[14,] "00" "0d" "1a" "27" "34" "41" "4e" "5b" "68" "75"  "82"  "8f"  "9c"  "a9"  "b6"  "c3" 
[15,] "00" "0e" "1c" "2a" "38" "46" "54" "62" "70" "7e"  "8c"  "9a"  "a8"  "b6"  "c4"  "d2" 
[16,] "00" "0f" "1e" "2d" "3c" "4b" "5a" "69" "78" "87"  "96"  "a5"  "b4"  "c3"  "d2"  "e1" 

1
¿Qué tal: as.hexmode (exterior (0: 15,0: 15, `*`))
ixodesbeta

2
O mejor aún,as.hexmode(0:15%o%0:15)
Giuseppe

10

Bash + coreutils, 40

  • 1 byte guardado gracias a @MitchellSpector
printf %02x\  $[{0..15}*{0..15}]|fmt -52
  • Bash expande expansiones de llaves antes de expansiones aritméticas, por lo que la cadena $[{0..15}*{0..15}]primero se expande a $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
  • La serie anterior de expansiones aritméticas se expande a los contenidos numéricos de la tabla, como enteros decimales.
  • La printf '%02x 'expresa esta lista de enteros decimales como hexagonal, con relleno de ceros a dos personajes
  • fmt -52formatea los enteros como líneas anchas de 47 caracteres, dando la alineación deseada. Note fmtintenta hacer que las líneas sean anchas para los objetivos . Por defecto, esto es 7% más corto que el ancho. 52 * 93% -1 (para nueva línea) = 47.

Pruébalo en línea .


1
Buena solución Parece que puede afeitarse un byte usando fmt -52 (sin la w).
Mitchell Spector

¡bonito! por cierto. en zsh podría ser {0..15}\*{0..15}que es 2 bytes más corto :)
ბიმო

5

C # 6, 98 bytes

()=>{int i,j;for(i=-1;++i<16;)for(j=-1;++j<16;)System.Console.Write($"{i*j:x2} {j<15?"":"\n"}");};

demo de repl.it

Bucle for anidado estándar. El único truco es imprimir nueva línea cuando j> = 15.


+1, pero parece que no le gusta$""
Metoniem

@Metoniem tio.run/# es muy superior
HyperNeutrino

4

JavaScript (ES6), 79 78 77 bytes

f=(i=256)=>i?f(--i)+(i%16*(i>>4)+256).toString(16).slice(1)+`
 `[~i&15&&1]:``

document.write('<pre>'+f())

Editar: guardado 1 byte gracias a @ETHproductions y otro byte gracias a @YairRand.


@ETHproductions Bah, el que sobró .slice(-2)de cuando estaba haciendo ('0'+toString(16)). Creo que ya lo había intentado ' \n'[+!(~i&15)]pero tiene la misma longitud.
Neil

@ETHproductions También guardé 1 bytes ...
Neil

Puede guardar un byte reemplazándolo (~i&15?' ':'\n')con ' \n'[~i&15&&1].
Yair Rand

@YairRand Creo que te refieres, '\n 'pero tengo la idea, ¡gracias!
Neil

3

MATL , 19 18 bytes

16:q&*1YAO3Z(!48e!

Pruébalo en línea!

16:q   % Push [0 1 ... 15]
&*     % 16×16 matrix of pairwise products
1YA    % Convert to hexadecimal. Gives a 256×2 char array 
O3Z(   % Assign char 0 to 3rd column. Gives a 256×3 char array
!48e!  % Reshape in row-major order as a 48-column char array
       % Implicitly display. Char 0 is shown as space

3

PowerShell , 46 bytes

0..15|%{$i=$_;"$(0..15|%{"{0:X2}"-f($i*$_)})"}

Pruébalo en línea!

Recorre de 0a 15, establece $ique sea ese número actual, luego vuelve a recorrer. Utiliza el -foperador ormat con la X2designación para especificar que la salida es la Xadecuada rellenada a 2espacios con ceros a la izquierda.

Una nota especial, y realmente el único golf, es que en lugar de usar un (...)-join' 'para tomar los resultados hexadecimales, encapsularlos en una matriz y concatenarlos juntos en una cadena, aprovechamos el hecho de que el $OutputFieldSeparatorvalor predeterminado para encadenar una matriz es un espacio. Eso significa que podemos hacer una cadena con un bloque de script en su "$(...)"lugar, ahorrando 6 bytes.

Esas cadenas se dejan en la tubería, y la salida implícita Write-Outputen la finalización del programa nos da una nueva línea entre ellas de forma gratuita.




2

Ruby, 49 bytes

256.times{|i|print"%02x "%(i/16*j=i%16),$/*j/=15}

Uso bastante sencillo del %operador equivalente a sprintf.

$/es la variable del separador de línea ( \npor defecto).

Tenga en cuenta el uso de tareas como j/=15evitar paréntesis más largos(j/15)


2

Mathematica, 46 bytes

Grid@Array[IntegerString[1##,16,2]&,{16,16},0]

Implementación sencilla utilizando el relleno incorporado IntegerString, en la base 16, a medida 2. El Array[...,{16,16},0]tiene las dos variables cada una de 0 a 15.


2

Matlab, 53 bytes

for i=[0:15]'*[0:15];fprintf('%02X ',i);disp(' ');end

Salida de muestra:

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  
00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E  
00 03 06 09 0C 0F 12 15 18 1B 1E 21 24 27 2A 2D  
00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C  
00 05 0A 0F 14 19 1E 23 28 2D 32 37 3C 41 46 4B  
00 06 0C 12 18 1E 24 2A 30 36 3C 42 48 4E 54 5A  
00 07 0E 15 1C 23 2A 31 38 3F 46 4D 54 5B 62 69  
00 08 10 18 20 28 30 38 40 48 50 58 60 68 70 78  
00 09 12 1B 24 2D 36 3F 48 51 5A 63 6C 75 7E 87  
00 0A 14 1E 28 32 3C 46 50 5A 64 6E 78 82 8C 96  
00 0B 16 21 2C 37 42 4D 58 63 6E 79 84 8F 9A A5  
00 0C 18 24 30 3C 48 54 60 6C 78 84 90 9C A8 B4  
00 0D 1A 27 34 41 4E 5B 68 75 82 8F 9C A9 B6 C3  
00 0E 1C 2A 38 46 54 62 70 7E 8C 9A A8 B6 C4 D2  
00 0F 1E 2D 3C 4B 5A 69 78 87 96 A5 B4 C3 D2 E1 

Pruébalo en línea! (algo así como ...)
Pavel

2

Perl, 48 bytes

for$a(@%=0..15){printf"%02x "x@%.$/,map$a*$_,@%}

Pruébalo en línea!

Estoy seguro de que esto no está optimizado, pero me condenarán si puedo encontrar algo mejor.

Desglose del código:

for$a(@%=0..15){printf"%02x "x@%.$/,map$a*$_,@%}
         0..15                                    #Create a list of the range 0 - 15...
      @%=                                         #...and store it in the array @%
for$a(        ){                               }  #Loop through @% with $a as the iterator
                printf[  string   ],[ params  ]   #Perl's port of the standard printf function
                      "%02x "                     #2-digit (hexit?) padding, followed by space...
                             x@%                  #...repeated 16 times (in scalar context, @% represents the size of array @%)...
                                .$/               #...followed by a newline
                                     map$a*$_,@%  #Loops through @%, and using $_ as the iterator, returns a list composed of each member of @% multiplied by the current $a

2

Perl 6 , 42 bytes

.fmt("%02x").put for (^16 X*^16).rotor: 16

Intentalo

Expandido:

.fmt("%02x") # format each element of list to lowercase hex
.put         # print with trailing newline

for          # for each of the following

(
  ^16  # Range upto ( and excluding ) 16
  X*   # cross multiplied with
  ^16
).rotor: 16 # break it up into chunks of 16 values

2

JavaScript, 104 bytes

s="";for(a=0;16>a;a++){for(b=0;16>b;b++)c=(a*b).toString(16),s=1==c.length?s+(" 0"+c):s+(" "+c);s+="\n"}

Llamar usando variable s:

console.log("HEX Table: " + s)

Código sin golf:

s=""; // Define s as empty string
for(a=0;16>a;a++){ // For y axis
  for(b=0;16>b;b++) // For x axis
    c=(a*b).toString(16),s=1==c.length?s+(" 0"+c):s+(" "+c); // Multiply and format
  s+="\n" // Add line breaks
}

¿No es el "\n"salto de línea? Wow, alguien usó ECMA puro por una vez.
Zacharý

Y deberías poder usarlo s+=2>c.length?" 0"+c:" "+c.
Zacharý

Sé que esto es viejo, ¡pero noté algunos ahorros que también podrían ayudar en futuros desafíos! se puede establecer tanto ay sque ""ya ""*0está todavía 0. Es posible alinear su lugar b++donde se está utilizando a*btambién para otro pequeño ahorro, pero si reescribe la cadena anexe: s+=" "+(0+(a*b++).toString(16)).substr(-2)eso ahorrará un trozo. ¡Debería estar a 86 bytes con esos! ¡Espero que ayude!
Dom Hastings

2

C, 68 66 bytes

f(i){for(i=0;i<256;)printf("%02x%c",i%16*(i++/16),i%16<15?32:10);}

-2 bytes gracias a ceilingcat!

Sin golf:

f(i){
  for(i=0; i<256;)
    printf("%02x%c", i%16*(i++/16), i%16<15 ? 32 : 10);
}

Imprime el resultado rellenado con cero y espacio o nueva línea.


¿Se ideduce eso implícitamente como intuna característica estándar de C?
sergiol

@sergiol sí, intes el supuesto predeterminado.
Karl Napf

Lamentablemente, la salida no está definida de acuerdo con el estándar C (C99 - 6.5.2.2 Llamadas de función).
Jasmes

Sugerir en ~i%16lugar dei%16<15
ceilingcat

2

Python 3, 55 bytes

r=range(16)
for x in r:print(*['%02x'%(x*y)for y in r])

El uso del formato% ahorra unos pocos bytes sobre [2:] uso. Lo mismo ocurre con * splats en la función de impresión.


2

Japt -R , 20 15 bytes

GÆGÇ*X sGÃùT2 ¸

¡Pruébelo en línea!

GÆGÇ*X sGÃùT2 ¸
G                   :16
 Æ                  :Map each X in the range [0,G)
  GÇ                :  Map the range [0,G)
    *X              :    Multiply by X
       sG           :    Convert to base-16 string
         Ã          :  End map
          ù         :  Left pad each
           T        :    With 0
            2       :    To length 2
              ¸     :  Join with spaces
                    :Implicitly join with newlines and output

Simplemente podría haberlo hecho en ®lugar de Ë; P
ETHproductions

@ETHproductions: Sí, ¡pero quería jugar con el nuevo atajo brillante! : D
Shaggy


1

05AB1E , 17 bytes

16F15ÝN*8o+h€¦ðý»

Pruébalo en línea!

16F               For N in [0,15]
   15Ý            Push [0, ..., 15]
      N*          Multiply by N
        8o+       Add 256
           h      Take the uppercase hexadecimal representation
            €¦    Remove the leading 1 of each value
              ðý  Join with spaces
                » End for and join everything with newlines

Puede haber una mejor manera de manejar esto en 05AB1E.



¡En efecto! ;) Tales comandos no existían en ese entonces; presionar 256 era el comando de 2 bytes žz. Ver Info.txt el 12 de noviembre de 2016 . Es bueno ver que el lenguaje todavía está evolucionando y que las personas lo usan: D.
Osable

Ah ok Yo sabía que las pequeñas constantes numéricas son bastante nuevo, pero pensé que el de 256estaba allí por más tiempo. Pero veo que su respuesta es de diciembre de 2016, así que puedo entender que aún no estaba allí en ese momento. :) He visto algunas respuestas 05AB1E de 2016 que ni siquiera tenían una entrada implícita todavía.
Kevin Cruijssen

1

C, 61 bytes

i;f(){while(i<256)printf("%02x%c",i%16*(i>>4),++i%16?32:10);}

Caja de varitas


¿se ideduce eso implícitamente como intuna característica estándar de C?
sergiol

1

Python2, 102 97 92 90 89 bytes

i=1
exec"print' '.join('%02x'%(j-x)*(i>0)for x,j in enumerate(range(0,16*i,i)));i+=1;"*16

Salida:

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
00 02 04 06 08 0a 0c 0e 10 12 14 16 18 1a 1c 1e
00 03 06 09 0c 0f 12 15 18 1b 1e 21 24 27 2a 2d
00 04 08 0c 10 14 18 1c 20 24 28 2c 30 34 38 3c
00 05 0a 0f 14 19 1e 23 28 2d 32 37 3c 41 46 4b
00 06 0c 12 18 1e 24 2a 30 36 3c 42 48 4e 54 5a
00 07 0e 15 1c 23 2a 31 38 3f 46 4d 54 5b 62 69
00 08 10 18 20 28 30 38 40 48 50 58 60 68 70 78
00 09 12 1b 24 2d 36 3f 48 51 5a 63 6c 75 7e 87
00 0a 14 1e 28 32 3c 46 50 5a 64 6e 78 82 8c 96
00 0b 16 21 2c 37 42 4d 58 63 6e 79 84 8f 9a a5
00 0c 18 24 30 3c 48 54 60 6c 78 84 90 9c a8 b4
00 0d 1a 27 34 41 4e 5b 68 75 82 8f 9c a9 b6 c3
00 0e 1c 2a 38 46 54 62 70 7e 8c 9a a8 b6 c4 d2
00 0f 1e 2d 3c 4b 5a 69 78 87 96 a5 b4 c3 d2 e1

Pruébalo en línea!


1

SmileBASIC, 56 51 47 bytes

I=RND(16)J=RND(16)LOCATE I*3,J?HEX$(I*J,2)EXEC.

1

k, 50 bytes

`0:" "/'("0123456789abcdef"@16 16\)''{x*\:/:x}@!16

Por desgracia, se ve obstaculizado por la falta de una impresora hexadecimal incorporada.

Lectura de derecha a izquierda, más o menos:

                                               !16 / make the array {0, 1, 2, ..., 15}
                                     {x*\:/:x}@    / cartesian product of the array multiplied by itself, results in a table
        (                         )''              / for each row, for each column
                            16 16\                 / decode int to two digits in base 16
         "0123456789abcdef"@                       / get the characters to form a string
   " "/'                                           / join the columns with a space, the table is now an array 
`0:                                                / print the array, each element is one line

1

/// , 588 bytes

/;/\/ //|/\/\///A/00 |B/
A|C;0|D;1|E;2|F;3|G;4|H;5|I;6|J;7|K;8/AAAAAAAAAAAAAAAAB01C2C3C4C5C6C7C8C9CaCbCcCdCeCf B02C4C6C8CaCcCeD0D2D4D6D8DaDcDe B03C6C9CcCfD2D5D8DbDeE1E4E7EaEd B04C8CcD0D4D8DcE0E4E8EcF0F4F8Fc B05CaCfD4D9DeE3E8EdF2F7FcG1G6Gb B06CcD2D8DeE4EaF0F6FcG2G8GeH4Ha B07CeD5 1cE3EaF1F8FfG6GdH4HbI2I9 B08D0D8E0E8F0F8G0G8H0H8I0I8J0J8 B09D2DbE4EdF6FfG8H1HaI3IcJ5JeK7 B0aD4DeE8F2FcG6H0HaI4IeJ8K2Kc 96 B0b 16E1EcF7G2Gd 58I3IeJ9K4Kf 9a a5 B0c 18E4F0FcG8 54I0IcJ8K4 90 9c a8 b4 B0d 1aE7F4G1GeHbI8J5K2Kf 9c a9 b6 c3 B0eDcEaF8G6H4I2J0JeKc 9a a8 b6 c4 d2 B0fDeEdFcGb 5aI9J8K7 96 a5 b4 c3 d2 e1 

Una versión más legible con nuevas líneas:

/]
[///;/\/ //|/\/\///A/00 |B/
A|C;0|D;1|E;2|F;3|G;4|H;5|I;6|J;7|K;8/]
[AAAAAAAAAAAAAAAAB01C2C3C4C5C6C7C8C9CaCbCcCdCeCf ]
[B02C4C6C8CaCcCeD0D2D4D6D8DaDcDe B03C6C9CcCfD2D5D]
[8DbDeE1E4E7EaEd B04C8CcD0D4D8DcE0E4E8EcF0F4F8Fc ]
[B05CaCfD4D9DeE3E8EdF2F7FcG1G6Gb B06CcD2D8DeE4EaF]
[0F6FcG2G8GeH4Ha B07CeD5 1cE3EaF1F8FfG6GdH4HbI2I9]
[ B08D0D8E0E8F0F8G0G8H0H8I0I8J0J8 B09D2DbE4EdF6Ff]
[G8H1HaI3IcJ5JeK7 B0aD4DeE8F2FcG6H0HaI4IeJ8K2Kc 9]
[6 B0b 16E1EcF7G2Gd 58I3IeJ9K4Kf 9a a5 B0c 18E4F0]
[FcG8 54I0IcJ8K4 90 9c a8 b4 B0d 1aE7F4G1GeHbI8J5]
[K2Kf 9c a9 b6 c3 B0eDcEaF8G6H4I2J0JeKc 9a a8 b6 ]
[c4 d2 B0fDeEdFcGb 5aI9J8K7 96 a5 b4 c3 d2 e1 

Bastante simple si sabes cómo funciona ///. Son solo algunos reemplazos de cuerdas.


1

/// , 544 bytes

Bueno, todos están haciendo /// respuestas ahora:

/|/\/\///Z/\/ |P/
0B|MZ9|LZ8|KZ7|JZ6|IZ5|HZ4|GZ3|FZ2|EZ1|C/BBB|B/0A|AZ0/0CCCCC0P1A2A3A4A5A6A7A8A9AaAbAcAdAeAfP2A4A6A8AaAcAeE0E2E4E6E8EaEcEeP3A6A9AcAfE2E5E8EbEeF1F4F7FaFdP4A8AcE0E4E8EcF0F4F8FcG0G4G8GcP5AaAfE4E9EeF3F8FdG2G7GcH1H6HbP6AcE2E8EeF4FaG0G6GcH2H8HeI4IaP7AeE5EcF3FaG1G8GfH6HdI4IbJ2J9P8E0E8F0F8G0G8H0H8I0I8J0J8K0K8P9E2EbF4FdG6GfH8I1IaJ3JcK5KeL7PaE4EeF8G2GcH6I0IaJ4JeK8L2LcM6PbE6F1FcG7H2HdI8J3JeK9L4LfMa a5PcE8F4G0GcH8I4J0JcK8L4M0Mc a8 b4PdEaF7G4H1HeIbJ8K5L2LfMc a9 b6 c3PeEcFaG8H6I4J2K0KeLcMa a8 b6 c4 d2PfEeFdGcHbIaJ9K8L7M6 a5 b4 c3 d2 e1

He sustituido \s0través de \s9la Acontinuación, Ea través de M, 0 0con C, \n00 0con P, /\scon Zy finalmente //con |, añadiendo todos estos en la parte delantera del código a medida que iba.

Pruébalo en línea!


1

Python 3, 66 bytes

r=range(16)
for i in r:print(*[('0'+hex(j*i)[2:])[-2:]for j in r])

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.