Sua tarefa é imprimir a tabela de tempos hexidecimais:

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

Especificações:

Você pode imprimir os valores hexadecimais em maiúsculas.
Suas linhas podem terminar com um espaço à direita e a saída do programa pode terminar com uma nova linha à direita.
Cada valor hexadecimal deve ser preenchido com 2 dígitos com 0s, como mostrado.

Isso é código-golfe , então a resposta mais curta (medida em bytes) vence.

code-golf kolmogorov-complexity hexadecimal

— Esolanging Fruit
fonte

Também relacionado

— Digital Trauma

4

Multiplicação tabelas não costumam incluir fator 0 ... :-)

— Luis Mendo

28

@Luis Mendo: De que outra forma as crianças em idade escolar poderão memorizar o que 0 vezes é um número? : P

— milk

1

Porra, eu queria criar uma solução usando o hexdump, mas isso agrupa em blocos de 4 bytes. :(

— HyperNeutrino

2

Stax , 11 bytes

äΔ←ùûv╚ö♦.J

Execute e depure

— recursivo
fonte

14

Python 2 , 60 bytes

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

Experimente online!

Como funciona

Para todos os números inteiros n de 0 a 255 , fazemos o seguinte.

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

No intervalo de n , n / 16 e n% 16 cobrem independentemente o intervalo 0,…, 15 , portanto, isso gera todas as entradas da tabela de multiplicação.
Repetimos o caractere de avanço de linha ( '\n') (n% 16) / 15 vezes, o que resulta no mesmo caractere quando n% 16 = 15 e em uma sequência vazia.
A sequência de formatação '%02x%s'transforma os dois resultados anteriores em uma única sequência, primeiro uma representação inteira hexadecimal em minúscula, preenchida com zero até (pelo menos) dois dígitos e depois a sequência gerada.
Por fim, print...,imprime os resultados formatados.

Como a instrução print termina com uma vírgula, o Python não acrescentará um avanço de linha. Além disso, antes de imprimir a próxima string, o Python acrescentará um espaço a menos que estejamos no início de uma nova linha. ( fonte ) Isso acontece para formatar a saída exatamente como queremos.

— Dennis
fonte

14

Gelatina , 12 bytes

⁴Ḷ×þ`d⁴‘ịØhG

Experimente online!

Como 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.

— Dennis
fonte

São 12 caracteres, não bytes. De acordo com a pergunta, a resposta é medida em bytes, e sua resposta é de 25 bytes e 12 caracteres . Pelo menos de acordo com este site mothereff.in/byte-counter

— Ciprum

18

No UTF-8, com certeza. No entanto, o Jelly usa um SBCS , para que cada caractere possa ser codificado usando um único byte.

— Dennis

11

R, 42 bytes

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

Imprime o seguinte:

      [,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"

— JAD
fonte

1

Como sobre: as.hexmode (outer (0: 15,0: 15, `*`))

— ixodesbeta

2

Ou ainda melhor,as.hexmode(0:15%o%0:15)

— Giuseppe

10

Bash + coreutils, 40

1 byte salvo graças a @MitchellSpector

printf %02x\  $[{0..15}*{0..15}]|fmt -52

O Bash expande as expansões de chaves antes das expansões aritméticas; portanto, a cadeia se $[{0..15}*{0..15}]expande primeiro para $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
A série acima de expansões aritméticas é expandida para o conteúdo da tabela numérica, como números inteiros decimais.
Ele printf '%02x 'expressa essa lista de números inteiros decimais como hexadecimal, preenchido com zero para dois caracteres
fmt -52formata os números inteiros como linhas largas de 47 caracteres, fornecendo o alinhamento desejado. A nota fmttenta fazer com que os caracteres de meta sejam largos. Por padrão, isso é 7% menor que a largura. 52 * 93% -1 (para nova linha) = 47.

Experimente online .

— Trauma Digital
fonte

1

Ótima solução. Parece que você pode economizar um byte usando fmt -52 (sem o w).

— Mitchell Spector

legais! btw. no zsh pode ser {0..15}\*{0..15}que é 2 bytes mais curto :)

— ბიმო 16/03

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 repl.it

For-loop aninhado padrão. O único truque é imprimir uma nova linha quando j> = 15.

— Ng do link
fonte

+1, mas parece que repl.it não gosta #$""

— Metoniem 22/02

@Metoniem tio.run/# é muito superior

— HyperNeutrino 16/03

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

Expandir snippet

Editar: salvou 1 byte graças a @ETHproductions e outro byte a @YairRand.

— Neil
fonte

@ETHproductions Bah, o que .slice(-2)sobrou de quando eu estava fazendo ('0'+toString(16)). Acho que já tentei, ' \n'[+!(~i&15)]mas tem o mesmo comprimento.

— 21716 Neil

@ETHproductions Eu também salvou 1 bytes ...

— Neil

Você pode salvar um byte, substituindo (~i&15?' ':'\n')por ' \n'[~i&15&&1].

— Yair Rand

@YairRand Eu acho que você quer dizer, '\n 'mas entendi a ideia, obrigado!

— Neil

3

MATL , 19 18 bytes

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

Experimente online!

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

— Luis Mendo
fonte

3

PowerShell , 46 bytes

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

Experimente online!

Loops de 0para 15, define $icomo o número atual e depois loops novamente. Usa o -foperador ormat com a X2designação para especificar a saída: ele é Xadecimal preenchido com 2espaços com zeros à esquerda.

De nota especial, e realmente o único golfe, é que, em vez de usar a (...)-join' 'para obter os resultados hexadecimais, encapsulá-los em uma matriz e concatená-los em uma sequência, aproveitamos o fato de que o $OutputFieldSeparatorvalor padrão para a sequência de strings de uma matriz é um espaço. Isso significa que podemos criar uma string com um bloco de script "$(...)", economizando 6 bytes.

Essas seqüências são todas deixadas no pipeline e a saída via implícita Write-Outputna conclusão do programa nos fornece uma nova linha entre elas gratuitamente.

— AdmBorkBork
fonte

3

Haskell , 87 bytes

import Numeric
main=mapM(\x->putStrLn$do y<-s;['0'|x*y<16]++showHex(x*y)" ")s
s=[0..15]

Experimente online!

Eu imagino que há uma maneira melhor. Talvez dependa do printfpacote ....

— dfeuer
fonte

2

Não usando importações, você poderia fazer mapM(pure"0123456789abcdef")".."!!(x*y)++" "o mesmo número de printf bytes , mas você está certo com 81 bytes .

— ბიმო 16/03

3

K7, 36 bytes

` 0:" "/:'{`hex@`c$x}''{x*/:\:x}@!16

— yiyus
fonte

" "/:'(`hex@`c$)''x*/:x:!16deve fazê-lo

— Alexander Belopolsky 14/04

Melhor ainda: (" "/:`hex@')'x*/:x:`c$!16(26 bytes)

— Alexander Belopolsky

2

Ruby, 49 bytes

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

Uso bastante direto do %operador equivalente a sprintf.

$/é a variável separadora de linha ( \npor padrão).

Observe o uso de atribuições como j/=15evitar parênteses mais longos(j/15)

— Level River St
fonte

2

Mathematica, 46 bytes

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

Implementação direta usando o preenchimento interno IntegerString, na base 16, no comprimento 2. O Array[...,{16,16},0]possui as duas variáveis, cada uma executando de 0 a 15.

— Greg Martin
fonte

2

Matlab, 53 bytes

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

Saída de amostra:

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

— Owen Morgan
fonte

Experimente online! (tipo de ...)

— Pavel

2

Perl, 48 bytes

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

Experimente online!

Tenho certeza de que isso não é ideal para o golfe, mas serei amaldiçoado se encontrar algo melhor.

Repartição do 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

— Gabriel Benamy
fonte

2

Perl 6 , 42 bytes

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

Tente

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

— Brad Gilbert b2gills
fonte

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

Chame usando a variável s:

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

Código não destruído:

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
}

— Julian Lachniet
fonte

Não é "\n"quebra de linha? Uau, alguém usou ECMA puro pela primeira vez.

— Zachary

E você deve poder usar s+=2>c.length?" 0"+c:" "+c.

— Zacharý

Sei que isso é antigo, mas notei algumas economias que também podem ajudar nos desafios futuros! você pode definir ambos ae spara ""desde ""*0ainda 0. É possível alinhar o local b++onde está sendo usado a*btambém para outra economia, mas se você reescrever a sequência anexada a: s+=" "+(0+(a*b++).toString(16)).substr(-2)isso salvará um pedaço. Deve ter 86 bytes com esses! Espero que ajude!

— 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 graças ao ceilingcat!

Ungolfed:

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

Imprime o resultado preenchido com zero e espaço ou nova linha.

— Karl Napf
fonte

Isso é iimplicitamente deduzido como intum recurso padrão de C?

— sergiol

@sergiol sim, inté a suposição padrão.

— Karl Napf

Infelizmente, a saída é indefinida de acordo com o padrão C (C99 - 6.5.2.2 Chamadas de função).

— Jasmes

Sugerir em ~i%16vez dei%16<15

— ceilingcat 7/02

2

Python 3, 55 bytes

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

Usar% de formatação economiza alguns bytes com o uso de [2:]. O mesmo ocorre com * splats na função de impressão.

— Beefster
fonte

2

Japonês `-R` , 20 15 bytes

GÆGÇ*X sGÃùT2 ¸

Experimente Online!

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

— Shaggy
fonte

Você poderia facilmente fazer em ®vez de Ë; P

— ETHproductions

@ETHproductions: Sim, mas eu queria brincar com o novo e brilhante atalho! : D

— Salsicha

1

Oitava, 34 bytes

disp(num2str((a=0:15)'*a,'%02x '))

— rahnema1
fonte

1

05AB1E , 17 bytes

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

Experimente online!

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

Pode haver uma maneira melhor de lidar com isso no 05AB1E.

— Osable
fonte

8opode ser ₁para salvar um byte. Embora você esteja certo de que pode haver uma maneira melhor. :)

— Kevin Cruijssen 21/03

De fato! ;) Tais comandos não existiam naquela época; empurrar 256 era o comando de 2 bytes žz. Veja Info.txt em 12 de novembro de 2016 . É bom ver que a linguagem ainda está evoluindo e que as pessoas a usam: D.

— Osable 22/03

Ah ok. Eu sabia que os pequenos constantes números são muito novo, mas pensei que o ₁de 256foi há mais tempo. Mas vejo que sua resposta é de dezembro de 2016, para que eu possa entender que ainda não estava lá na época. :) Vi algumas respostas do 05AB1E de 2016 que ainda nem tinham informações implícitas ..

— Kevin Cruijssen 22/03

1

C, 61 bytes

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

Wandbox

— o79y
fonte

isso é ideduzido implicitamente como intum recurso padrão 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

Resultado:

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

Experimente online!

— Yytsi
fonte

1

SmileBASIC, 56 51 47 bytes

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

— 12Me21
fonte

1

k, 50 bytes

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

Infelizmente, é dificultada pela falta de uma impressora hexadecimal embutida.

Lendo da direita para a esquerda, mais ou 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

— zgrep
fonte

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

Uma versão mais legível com novas linhas:

/]
[///;/\/ //|/\/\///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

Muito simples se você souber como /// funciona. São apenas algumas substituições de cordas.

— Esolanging Fruit
fonte

1

/// , 544 bytes

Bem, todo mundo está fazendo /// respostas agora:

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

Substituí \s0completamente \s9com Athen Eatravés M, 0 0com C, \n00 0com P, /\scom Ze finalmente //com |, adicionando tudo isso na frente do código à medida que avançava.

Experimente online!

— boboquack
fonte

1

Python 3, 66 bytes

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

— 0WJYxW9FMN
fonte

1

Perl 5 , 45 bytes

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

Experimente online!

— Xcali
fonte

Imprimir a tabela de tempos f × f

Especificações:

Stax , 11 bytes

Python 2 , 60 bytes

Como funciona

Gelatina , 12 bytes

Como funciona

R, 42 bytes

Bash + coreutils, 40

C # 6, 98 bytes

JavaScript (ES6), 79 78 77 bytes

MATL , 19 18 bytes

PowerShell , 46 bytes

Haskell , 87 bytes

Ruby, 49 bytes

Mathematica, 46 bytes

Matlab, 53 bytes

Perl, 48 bytes

Repartição do código:

Perl 6 , 42 bytes

Expandido:

JavaScript, 104 bytes

C, 68 66 bytes

Python 3, 55 bytes

Japonês -R , 20 15 bytes

Oitava, 34 bytes

05AB1E , 17 bytes

C, 61 bytes

Python2, 102 97 92 90 89 bytes

SmileBASIC, 56 51 47 bytes

k, 50 bytes

/// , 588 bytes

/// , 544 bytes

Python 3, 66 bytes

Perl 5 , 45 bytes

Japonês `-R` , 20 15 bytes