Il tuo compito è stampare la tabella dei tempi esadecimali:

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

specifiche tecniche:

È possibile stampare i valori esadecimali in maiuscolo.
Le righe possono terminare con uno spazio finale e l'output del programma può terminare con una riga finale finale.
Ogni valore esadecimale deve essere riempito con 2 cifre con 0s come mostrato.

Questo è code-golf , quindi vince la risposta più breve (misurata in byte).

code-golf kolmogorov-complexity hexadecimal

— Esolanging Fruit
fonte

Correlati

— Luis Mendo il

Anche correlato

— Trauma digitale il

4

Le tabelle di moltiplicazione di solito non includono il fattore 0 ... :-)

— Luis Mendo il

28

@Luis Mendo: In che altro modo gli scolari saranno in grado di memorizzare ciò che 0 volte un numero è? : P

— latte,

1

Accidenti, volevo creare una soluzione usando hexdump, ma che si raggruppa in blocchi di 4 byte. :(

— HyperNeutrino,

2

Stax , 11 byte

äΔ←ùûv╚ö♦.J

Esegui ed esegui il debug

— ricorsivo
fonte

14

Python 2 , 60 byte

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

Provalo online!

Come funziona

Per tutti i numeri interi n da 0 a 255 , facciamo quanto segue.

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

Nell'intervallo n , sia n / 16 che n% 16 coprono in modo indipendente l'intervallo 0,…, 15 , quindi questo genera tutte le voci della tabella di moltiplicazione.
Ripetiamo il carattere di avanzamento riga ( '\n') (n% 16) / 15 volte, che risulta nello stesso carattere quando n% 16 = 15 e una stringa vuota in caso contrario.
La stringa di formato '%02x%s'trasforma i due risultati precedenti in una singola stringa, prima una rappresentazione intera esadecimale minuscola, con spaziatura zero a (almeno) due cifre, quindi la stringa generata.
Infine, print...,stampa i risultati formattati.

Poiché l'istruzione print termina con una virgola, Python non aggiungerà un avanzamento riga. Inoltre, prima di stampare la stringa successiva, Python anteporrà uno spazio a meno che non siamo all'inizio di una nuova riga. ( fonte ) Questo accade per formattare l'output esattamente come vogliamo.

— Dennis
fonte

14

Gelatina , 12 byte

⁴Ḷ×þ`d⁴‘ịØhG

Provalo online!

Come funziona

⁴Ḷ×þ`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

Sono 12 caratteri, non byte. In base alla domanda, la risposta viene misurata in byte e la risposta è di 25 byte e 12 caratteri . Almeno secondo questo sito web mothereff.in/byte-counter

— Ciprum

18

In UTF-8, certo. Tuttavia, Jelly usa un SBCS , quindi ogni carattere può essere codificato usando un singolo byte.

— Dennis,

11

R, 42 byte

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

Stampa quanto segue:

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

Che ne dici di: as.hexmode (esterno (0: 15,0: 15, `*`))

— ixodesbeta,

2

O meglio ancora,as.hexmode(0:15%o%0:15)

— Giuseppe,

10

Bash + coreutils, 40

1 byte salvato grazie a @MitchellSpector

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

Bash espande le espansioni del controvento prima delle espansioni aritmetiche, quindi la stringa si $[{0..15}*{0..15}]espande per prima $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
Le precedenti serie di espansioni aritmetiche si espandono quindi al contenuto della tabella numerica, come numeri interi decimali.
La printf '%02x 'esprime questo elenco di numeri interi decimali come esadecimale, con zeri fino alla due personaggi
fmt -52formatta gli interi come larghe righe di 47 caratteri, fornendo l'allineamento desiderato. Nota fmtcerca di allargare le linee ai caratteri obiettivo . Per impostazione predefinita, è inferiore del 7% rispetto alla larghezza. 52 * 93% -1 (per newline) = 47.

Provalo online .

— Trauma digitale
fonte

1

Bella soluzione. Sembra che puoi radere via un byte usando fmt -52 (senza la w).

— Mitchell Spector,

simpatico! btw. in zsh potrebbe essere {0..15}\*{0..15}più corto di 2 byte :)

— ბიმო

5

C # 6, 98 byte

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

demo di repl.it

Ciclo forato nidificato standard. L'unico trucco è stampare newline quando j> = 15.

— Link Ng
fonte

+1, ma sembra repl.it non piace$""

— Metoniem

@Metoniem tio.run/# è molto superiore

— HyperNeutrino il

4

JavaScript (ES6), 79 78 77 byte

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

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

Espandi frammento

Modifica: 1 byte salvato grazie a @ETHproductions e un altro byte grazie a @YairRand.

— Neil
fonte

@ETHproductions Bah, è .slice(-2)stato lasciato da quando stavo facendo ('0'+toString(16)). Penso di aver già provato, ' \n'[+!(~i&15)]ma è della stessa lunghezza.

— Neil,

@ETHproductions Ho anche salvato 1 byte ...

— Neil

È possibile salvare un byte sostituendolo (~i&15?' ':'\n')con ' \n'[~i&15&&1].

— Yair Rand

@YairRand Penso che intendi '\n 'ma ho avuto l'idea, grazie!

— Neil

3

MATL , 19 18 byte

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

Provalo 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 byte

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

Provalo online!

Passa da 0a 15, imposta $iper essere quel numero corrente, quindi passa di nuovo. Utilizza l' -foperatore ormat con la X2designazione per specificare l'output se è Ximbottito adecimale in 2spazi con zeri iniziali.

Di particolare nota, e in realtà l'unico golf, è che invece di usare a (...)-join' 'per prendere i risultati esadecimali, incapsularli in un array e concatenarli insieme in una stringa, $OutputFieldSeparatorsfruttiamo il fatto che il valore predefinito per la stringa di un array è un spazio. Ciò significa che invece possiamo fare una stringa con un blocco di script "$(...)", salvando 6 byte.

Queste stringhe sono tutte lasciate in cantiere e l'output implicito Write-Outputal completamento del programma ci fornisce una nuova linea tra loro gratuitamente.

— AdmBorkBork
fonte

3

Haskell , 87 byte

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

Provalo online!

Immagino che ci sia un modo migliore. Forse dipende dal printfpacchetto ....

— dfeuer
fonte

2

Non utilizzare importazioni che puoi fare mapM(pure"0123456789abcdef")".."!!(x*y)++" "per lo stesso conteggio parziale, ma hai ragione con printf 81 byte .

— ბიმო

3

K7, 36 byte

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

— yiyus
fonte

" "/:'(`hex@`c$)''x*/:x:!16dovrebbe farlo

— Alexander Belopolsky il

Meglio ancora: (" "/:`hex@')'x*/:x:`c$!16(26 byte)

— Alexander Belopolsky,

2

Rubino, 49 byte

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

Uso abbastanza semplice %dell'operatore equivalente a sprintf.

$/è la variabile del separatore di riga ( \nper impostazione predefinita).

Nota l'uso di compiti come j/=15evitare parentesi più lunghe(j/15)

— Level River St
fonte

2

Mathematica, 46 byte

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

Implementazione semplice utilizzando l' imbottitura integrata IntegerString, in base 16, a misura della lunghezza 2. Il Array[...,{16,16},0]ha le due variabili ogni corsa da 0 a 15.

— Greg Martin
fonte

2

Matlab, 53 byte

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

Uscita campione:

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

Provalo online! (sorta di ...)

— Pavel,

2

Perl, 48 byte

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

Provalo online!

Sono convinto che questo non sia ottimale, ma sarò dannato se riuscissi a trovare qualcosa di meglio.

Analisi del codice:

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 byte

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

Provalo

Allargato:

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

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

Chiama utilizzando la variabile s:

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

Codice non golfato:

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

La "\n"linea non è interrotta? Caspita, qualcuno ha usato l' ECMA pura per una volta.

— Zacharý,

E dovresti essere in grado di usare s+=2>c.length?" 0"+c:" "+c.

— Zacharý,

So che questo è vecchio, ma ho notato alcuni risparmi che potrebbero aiutare anche nelle sfide future! è possibile impostare sia ae ssu ""poiché ""*0è fermo 0. È possibile incorporare il punto b++in cui viene utilizzato a*banche per un altro leggero salvataggio, ma se si riscrive l'appendice di stringa in: s+=" "+(0+(a*b++).toString(16)).substr(-2)ciò salverà un pezzo. Dovrebbe essere a 86 byte con quelli! Spero che aiuti!

— Dom Hastings,

2

C, 68 66 byte

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

-2 byte grazie a ceilingcat!

Ungolfed:

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

Stampa il risultato azzerato zero e lo spazio o la nuova riga.

— Karl Napf
fonte

È iimplicitamente dedotto come intuna caratteristica standard di C?

— sergiol

@sergiol Sì, intè il presupposto predefinito.

— Karl Napf,

Purtroppo l'uscita non è definita secondo lo standard C (C99 - 6.5.2.2 Chiamate di funzione).

— Jasmes,

Suggerisci ~i%16invece dii%16<15

— ceilingcat

2

Python 3, 55 byte

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

L'uso della formattazione% consente di risparmiare parecchi byte rispetto all'uso [2:]. Lo stesso vale per l'uso di * simboli sulla funzione di stampa.

— Beefster
fonte

2

Japt `-R` , 20 15 byte

GÆGÇ*X sGÃùT2 ¸

Provalo 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

— ispido
fonte

Avresti potuto fare altrettanto facilmente ®invece di Ë; P

— ETHproductions

@ETHproductions: Sì, ma volevo giocare con la nuova brillante scorciatoia! : D

— Shaggy,

1

Ottava, 34 byte

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

— rahnema1
fonte

1

05AB1E , 17 byte

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

Provalo 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

Potrebbe esserci un modo migliore per gestirlo in 05AB1E.

— Osable
fonte

8opuò essere ₁per salvare un byte. Anche se hai ragione, potrebbe esserci un modo migliore. :)

— Kevin Cruijssen il

Infatti! ;) Tali comandi non esistevano allora; spingendo 256 era il comando a 2 byte žz. Vedere Info.txt il 12 novembre 2016 . Bello vedere che la lingua è ancora in evoluzione e che la gente la usa: D.

— Osable il

Ah ok. Sapevo che i piccoli costanti numero sono abbastanza nuovo, ma pensato che la ₁per 256è stato più a lungo. Ma vedo che la tua risposta è di dicembre 2016, quindi capisco che non era ancora lì al momento. :) Ho visto alcune risposte 05AB1E del 2016 che non avevano ancora avuto un input implicito ..

— Kevin Cruijssen

1

C, 61 byte

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

Wandbox

— o79y
fonte

è iimplicitamente dedotto come intcaratteristica standard di C?

— sergiol

1

Python2, 102 97 92 90 89 byte

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

Produzione:

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

Provalo online!

— Yytsi
fonte

1

SmileBASIC, 56 51 47 byte

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

— 12Me21
fonte

1

k, 50 byte

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

Purtroppo, è ostacolato dalla mancanza di una stampante esadecimale integrata.

Lettura da destra a sinistra, più o meno:

                                               !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 byte

/;/\/ //|/\/\///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 versione più leggibile con newline:

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

Abbastanza semplice se sai come funziona ///. Sono solo alcune sostituzioni di stringhe.

— Esolanging Fruit
fonte

1

/// , 544 byte

Bene, tutti stanno facendo /// risposte ora:

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

Ho sostituito \s0tutto \s9con Apoi Eattraverso M, 0 0con C, \n00 0con P, /\scon Ze infine //con |, aggiungendo tutti questi all'inizio del codice mentre procedevo.

Provalo online!

— boboquack
fonte

1

Python 3, 66 byte

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

— 0WJYxW9FMN
fonte

1

Perl 5 , 45 byte

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

Provalo online!

— Xcali
fonte

Stampa la tabella dei tempi f × f

specifiche tecniche:

Stax , 11 byte

Python 2 , 60 byte

Come funziona

Gelatina , 12 byte

Come funziona

R, 42 byte

Bash + coreutils, 40

C # 6, 98 byte

JavaScript (ES6), 79 78 77 byte

MATL , 19 18 byte

PowerShell , 46 byte

Haskell , 87 byte

Rubino, 49 byte

Mathematica, 46 byte

Matlab, 53 byte

Perl, 48 byte

Analisi del codice:

Perl 6 , 42 byte

Allargato:

JavaScript, 104 byte

C, 68 66 byte

Python 3, 55 byte

Japt -R , 20 15 byte

Ottava, 34 byte

05AB1E , 17 byte

C, 61 byte

Python2, 102 97 92 90 89 byte

SmileBASIC, 56 51 47 byte

k, 50 byte

/// , 588 byte

/// , 544 byte

Python 3, 66 byte

Perl 5 , 45 byte

Japt `-R` , 20 15 byte