Twoim zadaniem jest wydrukowanie tabeli szesnastkowej razy:

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 

Dane techniczne:

• Możesz wydrukować wartości szesnastkowe dużymi literami.
• Twoje linie mogą kończyć się końcową spacją, a wynik programu może kończyć się końcową nową linią.
• Każda wartość szesnastkowa musi być uzupełniona do 2 cyfr za pomocą 0s, jak pokazano.

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź (mierzona w bajtach).

Stax , 11 bajtów

äΔ←ùûv╚ö♦.J

Uruchom i debuguj

Python 2 , 60 bajtów

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

Wypróbuj online!

Jak to działa

Dla wszystkich liczb całkowitych n od 0 do 255 , możemy wykonać następujące czynności.

• Obliczamy (n / 16) × (n% 16) .

  Powyżej zakresu n zarówno n / 16, jak i n% 16 niezależnie obejmują zakres 0,…, 15 , więc generuje to wszystkie wpisy w tablicy mnożenia.

• Powtarzamy znak wysuwu wiersza ( '\n') (n% 16) / 15 razy, co daje ten sam znak, gdy n% 16 = 15, aw przeciwnym razie pusty ciąg znaków.

• Łańcuch formatu '%02x%s'zamienia dwa poprzednie wyniki w pojedynczy ciąg, najpierw szesnastkową reprezentację liczb całkowitych w postaci małych liter, uzupełnioną zerą do (co najmniej) dwóch cyfr, a następnie wygenerowany ciąg.

• Na koniec print...,drukuje sformatowane wyniki.

  Ponieważ instrukcja print kończy się przecinkiem, Python nie dołącza linii. Ponadto przed wydrukowaniem następnego ciągu Python wstawi spację, chyba że znajdziemy się na początku nowej linii. ( źródło ) Zdarza się, aby sformatować dane wyjściowe dokładnie tak, jak chcemy.

Galaretka , 12 bajtów

⁴Ḷ×þ`d⁴‘ịØhG

Wypróbuj online!

Jak to działa

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

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

Drukuje następujące:

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

• 1 bajt zapisany dzięki @MitchellSpector

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

• Bash rozwija rozwinięcia nawiasów przed rozwinięciami arytmetycznymi, więc łańcuch $[{0..15}*{0..15}]najpierw rozwija się do $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
• Powyższa seria rozszerzeń arytmetycznych następnie rozwija się do zawartości tabeli numerycznej, jako liczb całkowitych dziesiętnych.
• Ta printf '%02x 'lista liczb całkowitych dziesiętnych jest wyrażana jako szesnastkowa, uzupełniona zerami do dwóch znaków
• fmt -52formatuje liczby całkowite jako linie o szerokości 47 znaków, co daje pożądane wyrównanie. Uwaga fmtprób by linie gol szerokości znaków. Domyślnie jest to o 7% mniej niż szerokość. 52 * 93% -1 (dla nowej linii) = 47.

Wypróbuj online .

C # 6, 98 bajtów

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

Standardowa zagnieżdżona pętla for. Jedyną sztuczką jest wydrukowanie nowego wiersza, gdy j> = 15.

JavaScript (ES6), 79 78 77 bajtów

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

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

Edycja: Zapisano 1 bajt dzięki @ETHproductions i kolejny bajt dzięki @YairRand.

MATL , 19 18 bajtów

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

Pętle od 0do 15, ustawia $ibieżącą liczbę, a następnie ponownie zapętla. Używa -foperatora ormat z X2oznaczeniem, aby określić, czy dane wyjściowe są Xdopełniane adecymalnie do 2spacji z wiodącymi zerami.

Na szczególną uwagę, a tak naprawdę jedyny golf, jest to, że zamiast używać a (...)-join' 'do pobrania wyników szesnastkowych, enkapsulacji ich w tablicy i połączenia ich razem w ciąg, wykorzystujemy fakt, że domyślną $OutputFieldSeparatorwartością dla stringowania tablicy jest przestrzeń. Oznacza to, że "$(...)"zamiast tego możemy wykonać ciąg znaków z blokiem skryptu , oszczędzając 6 bajtów.

Wszystkie te ciągi są pozostawione w potoku, a dane wyjściowe poprzez domniemane Write-Outputpo zakończeniu programu dają nam nowy wiersz między nimi za darmo.

Haskell , 87 bajtów

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

Wypróbuj online!

Wyobrażam sobie, że jest lepszy sposób. Może zależy od printfpakietu ....

K7, 36 bajtów

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

Rubinowy, 49 bajtów

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

Dość proste użycie %operatora równoważne z sprintf.

$/jest zmienną separatora linii ( \ndomyślnie).

Zwróć uwagę na użycie przypisań, j/=15aby uniknąć dłuższych nawiasów(j/15)

Mathematica, 46 bajtów

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

Prosta implementacja dzięki wbudowanemu IntegerStringw podstawie 16wypełnieniu na długość 2. Każda Array[...,{16,16},0]z dwóch zmiennych działa od 0 do 15.

Matlab, 53 bajtów

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

Przykładowe dane wyjściowe:

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 bajtów

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

Wypróbuj online!

Jestem pewien, że to nie jest optymalna gra w golfa, ale niech mnie szlag, jeśli znajdę coś lepszego.

Podział kodu:

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 bajtów

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

Spróbuj

Rozszerzony:

.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 bajtów

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

Zadzwoń za pomocą zmiennej s:

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

Nieskluczony kod:

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 bajtów

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

-2 bajty dzięki ceilingcat!

Nie golfowany:

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

Drukuje wynik wypełniony zerami oraz spację lub znak nowej linii.

Python 3, 55 bajtów

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

Korzystanie z formatowania% pozwala zaoszczędzić sporo bajtów na zużyciu [2:]. Podobnie jest z użyciem * ikonek w funkcji drukowania.

Japt -R , 20 15 bajtów

GÆGÇ*X sGÃùT2 ¸

Wypróbuj 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

Oktawa, 34 bajty

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

05AB1E , 17 bajtów

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

Wypróbuj 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

Może być lepszy sposób na poradzenie sobie z tym w 05AB1E.

C, 61 bajtów

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

Wandbox

Python2, 102 97 92 90 89 bajtów

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

Wynik:

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

Wypróbuj online!

SmileBASIC, 56 51 47 bajtów

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

k, 50 bajtów

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

Niestety przeszkadza mu brak wbudowanej drukarki szesnastkowej.

Czytanie od prawej do lewej, mniej więcej:

                                               !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 bajtów

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

Bardziej czytelna wersja z nowymi liniami:

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

Całkiem proste, jeśli wiesz, jak działa ///. To tylko kilka zamienników struny.

/// , 544 bajty

Cóż, teraz wszyscy robią /// odpowiedzi:

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

Wymieniłem \s0przez \s9z Apotem Eprzez M, 0 0z C, \n00 0z P, /\sze Zwreszcie //z |, dodając wszystkie te z przodu kodu jak poszedłem.

Wypróbuj online!

Python 3, 66 bajtów

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

Perl 5 , 45 bajtów

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

Wypróbuj online!