Ваше завдання - роздрукувати таблицю шістнадцяткових разів:

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 

Технічні умови:

• Ви можете надрукувати шістнадцяткові великі літери.
• Ваші рядки можуть закінчуватись пробілом, а вихід програми може закінчуватися останнім рядком.
• Кожне значення шістнадцятки повинно бути зафіксовано до двох цифр з 0s, як показано.

Це код-гольф , тому найкоротша відповідь (вимірюється в байтах) виграє.

Стакс , 11 байт

äΔ←ùûv╚ö♦.J

Запустіть і налагоджуйте його

Python 2 , 60 байт

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

Спробуйте в Інтернеті!

Як це працює

Для всіх цілих чисел n від 0 до 255 робимо наступне.

• Обчислюємо (n / 16) × (n% 16) .

  У діапазоні n і n / 16, і n% 16 незалежно охоплюють діапазон 0,…, 15 , тому це генерує всі записи таблиці множення.

• Повторюємо символ передачі рядка ( '\n') (n% 16) / 15 разів, що призводить до того ж символу, коли n% 16 = 15, а порожній рядок в іншому випадку.

• Рядок формату '%02x%s'перетворює два попередні результати в одну рядок, спочатку в шістнадцятковий цілочисельний подання, з нульовим значенням до (принаймні) двох цифр, а потім у створеній рядку.

• Нарешті, print...,друкуються відформатовані результати.

  Оскільки оператор друку закінчується комою, Python не додає рядковий рядок. Також перед тим, як надрукувати наступний рядок, Python додасть пробіл, якщо ми не знаходимося на початку нового рядка. ( джерело ) Це трапляється для форматування виводу точно так, як ми хочемо.

Желе , 12 байт

⁴Ḷ×þ`d⁴‘ịØhG

Спробуйте в Інтернеті!

Як це працює

⁴Ḷ×þ`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 байти

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

Друкує таке:

      [,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 байт збережено завдяки @MitchellSpector

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

• Bash розширює дугові розширення перед арифметичними розширеннями, тому рядок $[{0..15}*{0..15}]спочатку розгортається до $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
• Вищенаведені серії арифметичних розширень потім розширюються на вміст таблиці числових знаків у вигляді десяткових цілих чисел.
• printf '%02x 'Висловлює цей список десяткових чисел в вигляді шестнадцатеричной, доповнені нулі до двох символів
• fmt -52формує цілі числа у вигляді широких ліній 47 символів, надаючи бажане вирівнювання. Примітка fmtнамагається зробити символи цілей рядків широкими. За замовчуванням це на 7% коротше ширини. 52 * 93% -1 (для нового рядка) = 47.

Спробуйте в Інтернеті .

C # 6, 98 байт

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

repl.it демонстрація

Стандартний вкладений цикл. Єдина хитрість - друкувати новий рядок, коли j> = 15.

JavaScript (ES6), 79 78 77 байт

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

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

Редагувати: Збережено 1 байт завдяки @ETHproductions та ще один байт завдяки @YairRand.

MATL , 19 18 байт

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

Спробуйте в Інтернеті!

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 байт

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

Спробуйте в Інтернеті!

Цикли від 0до 15, встановлюється $iтаким поточним номером, а потім знову петлі. Використовує -fоператор ormat з X2позначенням, щоб вказати вихід, чи є він Xадекватним за допомогою 2пробілів з провідними нулями.

Окремо слід зазначити, і насправді єдиним гольфом є ​​те, що замість того, щоб використовувати a (...)-join' 'для отримання шестигранних результатів, інкапсулювати їх у масив і об'єднати їх у рядок, ми використовуємо той факт, що $OutputFieldSeparatorзначенням за замовчуванням для струфікації масиву є значення простір. Це означає, що ми можемо зробити рядок із блоком скрипту, "$(...)"а зберегти 6 байт.

Ці рядки залишені на конвеєрі, і вихід через неявне Write-Outputпо завершенні програми дає нам новий рядок між ними безкоштовно.

Haskell , 87 байт

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

Спробуйте в Інтернеті!

Я думаю, що є кращий спосіб. Може залежати від printfпакета….

К7, 36 байт

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

Рубін, 49 байт

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

Досить просто використання %оператора, еквівалентне sprintf.

$/- змінна роздільника рядків ( \nза замовчуванням)

Зверніть увагу на використання завдань, таких як j/=15уникнення довгих дужок(j/15)

Математика, 46 байт

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

Пряма реалізація за допомогою вбудованого IntegerStringв основу 16підкладки по довжині 2. Array[...,{16,16},0]Має дві змінні кожен запуск від 0 до 15.

Матлаб, 53 байти

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

Вибірка зразка:

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 байт

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

Спробуйте в Інтернеті!

Я впевнений, що це не оптимально гольф, але я буду проклятий, якщо зможу знайти щось краще.

Розбивка коду:

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 байти

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

Спробуй це

Розширено:

.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 байт

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

Дзвінок за допомогою змінної s:

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

Невикористаний код:

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 байт

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

-2 байти завдяки стельовій кішці!

Безголівки:

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

Друкує нульовий результат і пробіл, або новий рядок.

Python 3, 55 байт

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

Використання форматування% економить досить багато байтів за [2:] використання. Так само і використання * символів на функції друку.

Japt -R , 20 15 байт

GÆGÇ*X sGÃùT2 ¸

Спробуйте в Інтернеті!

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

Октава, 34 байти

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

05AB1E , 17 байт

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

Спробуйте в Інтернеті!

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

Можливо, буде кращий спосіб впоратися з цим у 05AB1E.

C, 61 байт

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

Wandbox

Python2, 102 97 92 90 89 байт

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

Вихід:

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

Спробуйте в Інтернеті!

SmileBASIC, 56 51 47 байт

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

k, 50 байт

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

На жаль, цьому заважає відсутність вбудованого шістнадцяткового принтера.

Читання справа наліво, більш-менш:

                                               !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 байт

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

Більш прочитана версія з новими рядками:

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

Досить просто, якщо ви знаєте, як /// працює. Це лише кілька замін рядків.

/// , 544 байт

Що ж, все роблять /// відповідає зараз:

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

Я замінив \s0через \s9з Aпотім Eчерез M, 0 0з C, \n00 0з Р, /\sз Zі , нарешті , //з |, додаючи все це в передній частині коду , як я пішов.

Спробуйте в Інтернеті!

Python 3, 66 байт

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

Perl 5 , 45 байт

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

Спробуйте в Інтернеті!