Imprimer le tableau des temps f × f


46

Votre tâche consiste à imprimer le tableau des temps hexidécimaux:

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 

Caractéristiques:

  • Vous pouvez imprimer les valeurs hexadécimales en majuscules.
  • Vos lignes peuvent se terminer par un espace de fin et la sortie du programme peut se terminer par une nouvelle ligne.
  • Chaque valeur hexadécimale doit être complétée à 2 chiffres avec 0s comme indiqué.

C'est du , donc la réponse la plus courte (mesurée en octets) est gagnante.



Également lié
Digital Trauma

4
Les tables de multiplication n'incluent généralement pas le facteur 0 ... :-)
Luis Mendo

28
@ Luis Mendo: Sinon, comment les enfants des écoles pourront-ils mémoriser ce qu'est 0 fois un nombre? : P
lait

1
Darn, je voulais faire une solution en utilisant hexdump, mais cela regroupe en blocs de 4 octets. :(
HyperNeutrino

Réponses:



14

Python 2 , 60 octets

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

Essayez-le en ligne!

Comment ça fonctionne

Pour tous les entiers n compris entre 0 et 255 , nous procédons comme suit.

  • Nous calculons (n / 16) × (n% 16) .

    Sur la plage de n , n / 16 et n% 16 couvrent indépendamment les plages 0,…, 15 , de sorte que toutes les entrées de la table de multiplication sont générées.

  • Nous répétons le caractère de saut de ligne ( '\n') (n% 16) / 15 fois, ce qui donne le même caractère lorsque n% 16 = 15 et une chaîne vide sinon.

  • La chaîne de format '%02x%s'transforme les deux résultats précédents en une seule chaîne, d'abord une représentation entière hexadécimale en minuscule, complétée de zéros (au moins) deux chiffres, puis de la chaîne générée.

  • Enfin, print...,imprime les résultats formatés.

    Puisque l'instruction print se termine par une virgule, Python n'ajoutera pas de saut de ligne. De plus, avant d’imprimer la chaîne suivante, Python ajoutera un espace avant, sauf si nous sommes au début d’une nouvelle ligne. ( source ) Cela arrive à formater la sortie exactement comme nous le souhaitons.


14

Gelée , 12 octets

⁴Ḷ×þ`d⁴‘ịØhG

Essayez-le en ligne!

Comment ça fonctionne

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

C'est 12 caractères, pas octets. Selon la question, la réponse est mesurée en octets et votre réponse est de 25 octets et 12 caractères . Au moins d'après ce site internet mothereff.in/byte-counter
Ciprum

18
En UTF-8, bien sûr. Cependant, Jelly utilise un SBCS , de sorte que chaque caractère peut être codé en utilisant un seul octet.
Dennis

11

R, 42 octets

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

Imprime les éléments suivants:

      [,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
Que diriez-vous: as.hexmode (externe (0: 15,0: 15, `*`))
ixodesbeta

2
Ou mieux encore,as.hexmode(0:15%o%0:15)
Giuseppe

10

Bash + coreutils, 40

  • 1 octet enregistré grâce à @MitchellSpector
printf %02x\  $[{0..15}*{0..15}]|fmt -52
  • Bash développe les extensions d'accolade avant les extensions arithmétiques, de sorte que la chaîne $[{0..15}*{0..15}]commence par s'étendre en premier $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
  • Les séries d’extensions arithmétiques ci-dessus s’étendent ensuite au contenu du tableau numérique, sous forme d’entiers décimaux.
  • La printf '%02x 'exprime cette liste d’entiers décimaux en hexa, complétée de zéros à deux caractères
  • fmt -52formate les nombres entiers en lignes de 47 caractères, donnant l’alignement souhaité. Note fmtessaie d'élargir les lignes des caractères de but . Par défaut, il est 7% plus court que la largeur. 52 * 93% -1 (pour les nouvelles lignes) = 47.

Essayez-le en ligne .


1
Belle solution. Il semble que vous puissiez supprimer un octet en utilisant fmt -52 (sans le w).
Mitchell Spector

agréable! btw. en zsh il pourrait être ce {0..15}\*{0..15}qui est de 2 octets plus court :)
ბიმო

5

C # 6, 98 octets

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

dem.it demo

Standard imbriqué pour la boucle. La seule astuce consiste à imprimer une nouvelle ligne lorsque j> = 15.


+1, mais il semble que repl.it n'aime pas$""
Metoniem 22/02/2017

@ Metoniem tio.run/# est bien supérieur
HyperNeutrino

4

JavaScript (ES6), 79 78 77 octets

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

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

Edit: 1 octet enregistré grâce à @ETHproductions et un autre octet grâce à @YairRand.


@ETHproductions Bah, le .slice(-2)reste de ma vie ('0'+toString(16)). Je pense que j'avais déjà essayé ' \n'[+!(~i&15)]mais c'est la même longueur.
Neil

@ETHproductions J'ai également enregistré 1 octet ...
Neil

Vous pouvez sauvegarder un octet en remplaçant (~i&15?' ':'\n')par ' \n'[~i&15&&1].
Yair Rand le

@YairRand Je pense que vous voulez dire '\n 'mais je comprends l'idée, merci!
Neil

3

MATL , 19 18 octets

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

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Boucle de 0à 15, définit $ipour être ce nombre actuel, puis boucle à nouveau. Utilise l’ -fopérateur ormat avec la X2désignation pour spécifier la sortie, est-il Xadécimal ajouté aux 2espaces avec des zéros non significatifs .

Il convient de noter que le seul golf est qu’au lieu d’utiliser un (...)-join' 'pour prendre les résultats hexadécimaux, les encapsuler dans un tableau et les concaténer dans une chaîne, nous exploitons le fait que la $OutputFieldSeparatorvaleur par défaut pour lier un tableau est un espace. Cela signifie que nous pouvons faire une chaîne avec un bloc de script à la "$(...)"place, en économisant 6 octets.

Ces chaînes sont toutes laissées dans le pipeline, et la sortie via implicite Write-Outputà la fin du programme nous donne une nouvelle ligne entre elles gratuitement.




2

Ruby, 49 octets

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

Utilisation assez simple de l' %opérateur équivalent à sprintf.

$/est la variable de séparateur de ligne ( \npar défaut).

Notez l'utilisation d'assignations j/=15pour éviter des parenthèses plus longues(j/15)


2

Mathematica, 46 octets

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

Mise en œuvre simple en utilisant le rembourrage à la longueur intégré IntegerStringdans la base . Les deux variables vont chacune de 0 à 15.162Array[...,{16,16},0]


2

Matlab, 53 octets

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

Exemple de sortie:

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 

Essayez-le en ligne! (en quelque sorte ...)
Pavel

2

Perl, 48 octets

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

Essayez-le en ligne!

Je suis convaincu que ce n'est pas une pratique optimale du golf, mais je serai damné si je peux trouver quelque chose de mieux.

Répartition du code:

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 octets

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

L'essayer

Étendu:

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

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

Appelez en utilisant variable s:

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

Code non 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
}

N'est-ce pas le "\n"saut de ligne? Wow, quelqu'un a utilisé l' ECMA pur pour une fois.
Zacharý

Et vous devriez pouvoir utiliser s+=2>c.length?" 0"+c:" "+c.
Zacharý

Je sais que c'est vieux, mais j'ai remarqué quelques économies qui pourraient également aider à relever les défis à venir! vous pouvez définir les deux aet sà ""depuis ""*0est encore 0. Il est possible d'inclure votre fichier b++là où il est utilisé a*bpour un autre léger enregistrement, mais si vous réécrivez la chaîne suivante: s+=" "+(0+(a*b++).toString(16)).substr(-2)cela économisera un morceau. Devrait être à 86 octets avec ceux! J'espère que ça t'as aidé!
Dom Hastings

2

C, 68 66 octets

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

-2 octets grâce à ceilingcat!

Ungolfed:

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

Imprime le résultat avec un zéro de remplissage et l’espace ou la nouvelle ligne.


Est-ce iimplicitement déduit comme intune caractéristique standard de C?
sergiol

@sergiol oui, intc'est l'hypothèse par défaut.
Karl Napf

Malheureusement, la sortie n’est pas définie selon la norme C (C99 - 6.5.2.2 Appels de fonction).
Jasmes

Suggérer au ~i%16lieu dei%16<15
ceilingcat

2

Python 3, 55 octets

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

L'utilisation de% formatage permet d'économiser quelques octets sur l'utilisation de [2:]. Il en va de même en utilisant * splats sur la fonction d'impression.


2

Japt -R , 20 15 octets

GÆGÇ*X sGÃùT2 ¸

Essayez-le en ligne!

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

Vous auriez tout aussi facilement pu le faire ®au lieu de Ë; P
ETHproductions

@ETHproductions: Oui, mais je voulais jouer avec le nouveau raccourci brillant! : D
Shaggy


1

05AB1E , 17 octets

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

Essayez-le en ligne!

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

Il y aurait peut-être une meilleure façon de gérer cela dans 05AB1E.



En effet! ;) De telles commandes n'existaient pas à l'époque; pousser 256 était la commande à 2 octets žz. Voir Info.txt le 12 novembre 2016 . Cela fait plaisir de voir que le langage évolue toujours et que les gens l'utilisent: D.
Osable

Ah ok. Je savais que les constantes de petit nombre étaient assez nouvelles, mais je pensais que le pour 256était là plus longtemps. Mais je vois que votre réponse date de décembre 2016, alors je peux comprendre que ce n'était pas encore là à l'époque. :) J'ai vu des réponses de 05AB1E de 2016 qui n'avaient même pas encore eu de participation implicite.
Kevin Cruijssen

1

C, 61 octets

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

Boîte à baguette


est-ce iimplicitement déduit comme intune caractéristique standard de C?
sergiol

1

Python2, 102 97 92 90 89 octets

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

Sortie:

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

Essayez-le en ligne!


1

SmileBASIC, 56 51 47 octets

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

1

k, 50 octets

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

Hélas, l’absence d’imprimante hexadécimale intégrée l’entrave.

Lire de droite à gauche, plus ou moins:

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

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

Une version plus lisible avec des nouvelles lignes:

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

Assez simple si vous savez comment /// fonctionne. C'est juste quelques remplacements de cordes.


1

/// , 544 octets

Tout le monde est en train de faire /// répond maintenant:

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

Je l' ai remplacé \s0par \s9avec Apuis à Etravers M, 0 0avec C, \n00 0avec P, /\savec Zet enfin //avec |, en ajoutant tout cela à l'avant du code que je suis allé.

Essayez-le en ligne!


1

Python 3, 66 octets

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.