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 Code-Golf , also gewinnt die kürzeste Antwort (gemessen in Bytes).

Stax , 11 Bytes

äΔ←ùûv╚ö♦.J

Führen Sie es aus und debuggen Sie es

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.

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.

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" 

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 .

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.

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.

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

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.

Haskell , 87 Bytes

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

Probieren Sie es online!

Ich stelle mir vor, es gibt einen besseren Weg. Vielleicht auf das paket abhängen printf....

K7, 36 Bytes

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

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)

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.

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 

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

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

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
}

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.

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.

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

Oktave, 34 Bytes

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

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.

C 61 Bytes

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

Wandbox

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!

SmileBASIC, 56 51 47 Bytes

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

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

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

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

Python 3, 66 Bytes

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

Perl 5 , 45 Bytes

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

Probieren Sie es online!