Drucken Sie die f × f-Zeittabelle


46

Ihre Aufgabe ist es, die hexadezimale Zeittabelle zu drucken:

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 

Spezifikationen:

  • Sie können die Hex-Werte in Großbuchstaben drucken.
  • Ihre Zeilen können mit einem Leerzeichen am Ende und die Programmausgabe mit einem Zeilenumbruch am Ende enden.
  • Jeder Hex-Wert muss 0wie gezeigt mit s auf 2 Stellen aufgefüllt werden .

Das ist , also gewinnt die kürzeste Antwort (gemessen in Bytes).




4
Multiplikationstabellen enthalten normalerweise keinen Faktor 0 ... :-)
Luis Mendo

28
@ Luis Mendo: Wie sonst können sich Schulkinder merken, was 0-mal eine Zahl ist? : P
Milch

1
Verdammt, ich wollte eine Lösung mit Hexdump machen, aber das gruppiert sich in 4-Byte-Blöcke. :(
HyperNeutrino

Antworten:



14

Python 2 , 60 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Für alle ganzen Zahlen n von 0 bis 255 gehen wir wie folgt vor.

  • Wir berechnen (n / 16) × (n% 16) .

    Im Bereich von n decken sowohl n / 16 als auch n% 16 unabhängig voneinander den Bereich 0,…, 15 ab , sodass alle Einträge der Multiplikationstabelle generiert werden.

  • Wir wiederholen das Zeilenvorschubzeichen ( '\n') (n% 16) / 15- mal, was dasselbe Zeichen ergibt, wenn n% 16 = 15 und andernfalls eine leere Zeichenfolge.

  • Die Formatzeichenfolge '%02x%s'verwandelt die beiden vorherigen Ergebnisse in eine einzelne Zeichenfolge, zunächst eine hexadezimale Ganzzahldarstellung in Kleinbuchstaben, die mit (mindestens) zwei Ziffern aufgefüllt wird, und anschließend die generierte Zeichenfolge.

  • Zum Schluss werden print...,die formatierten Ergebnisse gedruckt.

    Da die print-Anweisung mit einem Komma endet, hängt Python keinen Zeilenvorschub an. Außerdem wird Python vor dem Drucken der nächsten Zeichenfolge ein Leerzeichen voranstellen, es sei denn, wir stehen am Anfang einer neuen Zeile. ( Quelle ) Dies geschieht, um die Ausgabe genau so zu formatieren, wie wir es möchten.


14

Gelee , 12 Bytes

⁴Ḷ×þ`d⁴‘ịØhG

Probieren Sie es online!

Wie es funktioniert

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

Das sind 12 Zeichen, keine Bytes. Entsprechend der Frage wird die Antwort in Bytes gemessen, und Ihre Antwort besteht aus 25 Bytes und 12 Zeichen . Zumindest laut dieser Website mothereff.in/byte-counter
Ciprum

18
In UTF-8 sicher. Jelly verwendet jedoch ein SBCS , sodass jedes Zeichen mit einem einzelnen Byte codiert werden kann.
Dennis

11

R, 42 Bytes

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

Druckt Folgendes aus:

      [,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
Wie wäre es mit: as.hexmode (Outer (0: 15,0: 15, `*`))
ixodesbeta

2
Oder noch besser,as.hexmode(0:15%o%0:15)
Giuseppe

10

Bash + Coreutils, 40

  • Dank @MitchellSpector 1 Byte gespart
printf %02x\  $[{0..15}*{0..15}]|fmt -52
  • Bash erweitert Klammererweiterungen vor arithmetischen Erweiterungen, sodass die Zeichenfolge $[{0..15}*{0..15}]zuerst auf erweitert wird $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
  • Die obige Reihe von arithmetischen Erweiterungen wird dann als Dezimalzahl auf den Inhalt der numerischen Tabelle erweitert.
  • Das printf '%02x 'drückt diese Liste der Dezimalzahlen als Hexadezimalzahl aus, die mit Nullen aufgefüllt ist und zwei Zeichen enthält
  • fmt -52formatiert die ganzen Zahlen als 47 Zeichen breite Zeilen und gibt die gewünschte Ausrichtung an. Hinweis fmtversucht, Zeilen mit einer Zielbreite von Zeichen zu versehen. Standardmäßig ist dies 7% kürzer als die Breite. 52 * 93% -1 (für Zeilenvorschub) = 47.

Probieren Sie es online aus .


1
Gute Lösung. Es sieht so aus, als könnten Sie ein Byte mit fmt -52 (ohne das w) sparen.
Mitchell Spector

nett! btw. in zsh könnte es sein {0..15}\*{0..15}das 2 bytes kürzer ist :)
ბიმო

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

Repl.it Demo

Standard verschachtelte for-Schleife. Der einzige Trick ist, eine neue Zeile zu drucken, wenn j> = 15 ist.


+1, aber es scheint repl.it mag nicht$""
Metoniem

@Metoniem tio.run/# ist viel besser
HyperNeutrino

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

Bearbeiten: 1 Byte dank @ETHproductions und ein weiteres Byte dank @YairRand gespeichert.


@ETHproductions Bah, das .slice(-2)war übrig, als ich es tat ('0'+toString(16)). Ich denke, ich habe es bereits versucht, ' \n'[+!(~i&15)]aber es ist die gleiche Länge.
Neil

@ETHproductions Ich speicherte auch 1 Bytes ...
Neil

Sie können durch Ersetzen eines Byte speichern (~i&15?' ':'\n')mit ' \n'[~i&15&&1].
Yair Rand

@YairRand Ich denke du meinst, '\n 'aber ich habe die Idee, danke!
Neil

3

MATL , 19 18 Bytes

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

Probieren Sie es 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

3

PowerShell , 46 Byte

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

Probieren Sie es online!

Loops from 0to 15( Schleifen von bis) , wird $iauf die aktuelle Nummer gesetzt und dann erneut wiederholt. Verwendet den -format-Operator mit der X2Bezeichnung, um die Ausgabe zu spezifizieren, wird er Xauf 2Leerzeichen mit führenden Nullen aufgefüllt .

Von besonderer Bedeutung und wirklich der einzige Vorteil ist, dass anstelle von a (...)-join' ', um die hexadezimalen Ergebnisse zu nehmen, sie in einem Array zu kapseln und zu einer Zeichenfolge $OutputFieldSeparatorzu verknüpfen , der Standardwert für die Zeichenfolge eines Arrays a verwendet wird Platz. Das heißt, wir können "$(...)"stattdessen eine Zeichenfolge mit einem darin enthaltenen Skriptblock erstellen und 6 Bytes einsparen.

Diese Zeichenfolgen Write-Outputverbleiben alle in der Pipeline, und die Ausgabe über implizit bei Programmabschluss gibt uns kostenlos eine neue Zeile dazwischen.




2

Ruby, 49 Bytes

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

Ziemlich unkomplizierte Bedienung des %Bedieners entspricht sprintf.

$/ist die Zeilentrennungsvariable ( \nstandardmäßig)

Beachten Sie die Verwendung von Zuweisungen j/=15, um längere Klammern zu vermeiden(j/15)


2

Mathematica, 46 Bytes

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

Einfache Implementierung unter Verwendung des Einbau- IntegerStringin Basen- 16, Klotzen auf Länge 2. Die Array[...,{16,16},0]beiden Variablen laufen jeweils von 0 bis 15.


2

Matlab, 53 Bytes

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

Beispielausgabe:

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 


2

Perl, 48 Bytes

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

Probieren Sie es online!

Ich bin mir sicher, dass dies nicht optimal ist, aber ich werde verdammt sein, wenn ich etwas Besseres finde.

Code-Aufschlüsselung:

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

Versuch es

Erweitert:

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

Aufruf mit Variable s:

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

Ungolfed-Code:

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
}

Ist das nicht "\n"Zeilenumbruch? Wow, jemand hat einmal reines ECMA benutzt.
Zacharý

Und Sie sollten verwenden können s+=2>c.length?" 0"+c:" "+c.
Zacharý

Ich weiß, dass dies alt ist, aber ich habe einige Einsparungen festgestellt, die auch bei zukünftigen Herausforderungen hilfreich sein könnten! Sie können beide eingestellt aund sauf ""da ""*0noch ist 0. Es ist möglich, Ihre Daten dort einzufügen b++, wo sie a*bauch für ein weiteres leichtes Speichern verwendet werden. Wenn Sie jedoch den String anhängen s+=" "+(0+(a*b++).toString(16)).substr(-2), wird ein Teil gespeichert. Sollte bei denen bei 86 Bytes liegen! Ich hoffe, das hilft!
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 dank ceilingcat!

Ungolfed:

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

Druckt das mit Nullen aufgefüllte Ergebnis und entweder Leerzeichen oder Zeilenumbruch.


Wird das iimplizit als intStandardmerkmal von C abgeleitet?
Sergiol

@ Sergiol ja, intist die Standardannahme.
Karl Napf

Leider ist der Ausgang gemäß C-Standard undefiniert (C99 - 6.5.2.2 Funktionsaufrufe).
Jasmes

Schlagen Sie ~i%16stattdessen vori%16<15
ceilingcat

2

Python 3, 55 Bytes

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

Durch die Verwendung der% -Formatierung werden im Vergleich zu [2:] einige Bytes gespart. Dies gilt auch für die Verwendung von * splats für die Druckfunktion.


2

Japt -R , 20 15 Bytes

GÆGÇ*X sGÃùT2 ¸

Probieren Sie es 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

Du ®Ë
hättest es

@ETHproductions: Ja, aber ich wollte mit der glänzenden neuen Verknüpfung spielen! : D
Shaggy


1

05AB1E , 17 Bytes

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

Probieren Sie es 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

In 05AB1E könnte es eine bessere Möglichkeit geben, damit umzugehen.



Tatsächlich! ;) Solche Befehle gab es damals noch nicht; Das Drücken von 256 war der 2-Byte-Befehl žz. Siehe Info.txt am 12. November 2016 . Schön zu sehen, dass sich die Sprache noch weiterentwickelt und von den Menschen verwendet wird: D.
Osable

Ach ok Ich wusste, dass die kleinen Zahlenkonstanten ziemlich neu sind, dachte aber, dass das für 256länger da ist. Aber ich sehe, dass Ihre Antwort vom Dezember 2016 stammt, daher kann ich verstehen, dass sie zu diesem Zeitpunkt noch nicht da war. :) Ich habe einige 05AB1E-Antworten aus dem Jahr 2016 gesehen, die noch nicht einmal implizite Eingaben
enthielten

1

C 61 Bytes

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

Wandbox


wird das iimplizit als intStandardmerkmal von C abgeleitet?
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

Ausgabe:

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

Probieren Sie es online!


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

Leider wird es durch das Fehlen eines eingebauten Hexadezimaldruckers behindert.

Lesen von rechts nach links, mehr oder weniger:

                                               !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 

Eine lesbarere Version mit Zeilenumbrüchen:

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

Ziemlich einfach, wenn Sie wissen, wie /// funktioniert. Es sind nur ein paar Saitenwechsel.


1

/// 544 Bytes

Nun, alle machen /// Antworten jetzt:

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

I ersetzt \s0durch \s9mit Adann Edurch M, 0 0mit C, \n00 0mit P, /\smit Zund schließlich //mit |, alle diese an der Vorderseite des Code hinzufügen , wie ich ging.

Probieren Sie es online!


1

Python 3, 66 Bytes

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

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.