Nhiệm vụ của bạn là in bảng lần thập lục phân:

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 

Thông số kỹ thuật:

• Bạn có thể in các giá trị hex bằng chữ hoa.
• Các dòng của bạn có thể kết thúc bằng một khoảng trắng ở cuối và đầu ra của chương trình có thể kết thúc bằng một dòng mới.
• Mỗi giá trị hex phải được đệm thành 2 chữ số với 0s như được hiển thị.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Stax , 11 byte

äΔ←ùûv╚ö♦.J

Chạy và gỡ lỗi nó

Python 2 , 60 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Đối với tất cả các số nguyên n từ 0 đến 255 , chúng tôi thực hiện như sau.

• Chúng tôi tính toán (n / 16) × (n% 16) .

  Trong phạm vi n , cả n / 16 và n% 16 độc lập bao gồm phạm vi 0, Khác, 15 , do đó, điều này tạo ra tất cả các mục của bảng nhân.

• Chúng tôi lặp lại ký tự linefeed ( '\n') (n% 16) / 15 lần, kết quả là cùng một ký tự khi n% 16 = 15 và một chuỗi trống khác.

• Chuỗi định dạng '%02x%s'biến hai kết quả trước đó thành một chuỗi, đầu tiên là biểu diễn số nguyên thập lục phân chữ thường, không đệm cho (ít nhất) hai chữ số, sau đó là chuỗi được tạo.

• Cuối cùng, print...,in kết quả được định dạng.

  Vì câu lệnh in kết thúc bằng dấu phẩy, Python sẽ không nối thêm nguồn cấp. Ngoài ra, trước khi in chuỗi tiếp theo, Python sẽ thêm một khoảng trắng trừ khi chúng ta bắt đầu một dòng mới. ( nguồn ) Điều này xảy ra để định dạng đầu ra chính xác như chúng ta muốn.

Thạch , 12 byte

⁴Ḷ×þ`d⁴‘ịØhG

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

In như sau:

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

• Lưu 1 byte nhờ @MitchellSpector

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

• Bash mở rộng mở rộng cú đúp trước khi mở rộng số học, do đó, chuỗi $[{0..15}*{0..15}]đầu tiên mở rộng thành $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
• Chuỗi mở rộng số học ở trên sau đó mở rộng sang nội dung bảng số, dưới dạng số nguyên thập phân.
• Biểu printf '%02x 'thị danh sách các số nguyên thập phân này dưới dạng hex, không đệm cho hai ký tự
• fmt -52định dạng các số nguyên dưới dạng các dòng rộng 47 ký tự, cho sự liên kết mong muốn. Lưu ý fmtcố gắng làm cho các dòng nhân vật mục tiêu rộng. Theo mặc định, nó ngắn hơn 7% so với chiều rộng. 52 * 93% -1 (đối với dòng mới) = 47.

Hãy thử trực tuyến .

C # 6, 98 byte

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

thay thế bản demo

Tiêu chuẩn lồng nhau cho vòng lặp. Bí quyết duy nhất là in dòng mới khi j> = 15.

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

Chỉnh sửa: Đã lưu 1 byte nhờ @ETHproductions và một byte khác nhờ @YairRand.

MATL , 19 18 byte

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

Hãy thử trực tuyến!

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*$_)})"}

Hãy thử trực tuyến!

Vòng lặp từ 0đến 15, đặt $ithành số hiện tại, sau đó lặp lại. Sử dụng -ftoán tử ormat với X2chỉ định để xác định đầu ra là anh ta được Xđệm vào các 2khoảng trống có các số 0 đứng đầu.

Đặc biệt lưu ý và thực sự là môn đánh gôn duy nhất, thay vì sử dụng (...)-join' 'để lấy kết quả hex, gói chúng trong một mảng và ghép chúng lại thành một chuỗi, chúng tôi tận dụng thực tế là $OutputFieldSeparatorgiá trị mặc định để xâu chuỗi một mảng là một không gian. Điều đó có nghĩa là chúng ta có thể thực hiện một chuỗi với một khối tập lệnh trong đó "$(...)", tiết kiệm 6 byte.

Các chuỗi đó đều được để lại trên đường ống và đầu ra thông qua ẩn Write-Outputkhi hoàn thành chương trình cung cấp cho chúng tôi một dòng mới giữa chúng miễn phí.

Haskell , 87 byte

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

Hãy thử trực tuyến!

Tôi tưởng tượng có một cách tốt hơn. Có lẽ phụ thuộc vào printfgói ....

K7, 36 byte

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

Ruby, 49 byte

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

Khá đơn giản sử dụng các %toán tử tương đương sprintf.

$/là biến phân cách dòng ( \ntheo mặc định.)

Lưu ý việc sử dụng các bài tập như j/=15để tránh dấu ngoặc đơn dài hơn(j/15)

Toán học, 46 byte

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

Thực hiện đơn giản bằng cách sử dụng tích hợp IntegerString, trong cơ sở 16, đệm theo chiều dài 2. Các Array[...,{16,16},0]có hai biến mỗi lần chạy 0-15.

Matlab, 53 byte

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

Đầu ra mẫu:

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 byte

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

Hãy thử trực tuyến!

Tôi khẳng định điều này không tối ưu khi chơi golf, nhưng tôi sẽ bị nguyền rủa nếu tôi có thể tìm thấy thứ gì đó tốt hơn.

Sự cố mã:

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 byte

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

Thử nó

Mở rộng:

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

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

Gọi sử dụng biến s:

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

Mã bị đánh cắp:

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 byte

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

-2 byte nhờ trần nhà!

Ung dung:

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

In kết quả đệm không và không gian hoặc dòng mới.

Python 3, 55 byte

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

Sử dụng định dạng% giúp tiết kiệm khá nhiều byte trong quá trình sử dụng [2:]. Vì vậy, sử dụng * splats trên chức năng in.

Japt -R , 20 15 byte

GÆGÇ*X sGÃùT2 ¸

Dùng thử trực tuyến!

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

Octave, 34 byte

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

05AB1E , 17 byte

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

Hãy thử trực tuyến!

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

Có thể có một cách tốt hơn để xử lý việc này trong 05AB1E.

C, 61 byte

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

Cây đũa phép

Python2, 102 97 92 90 89 byte

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

Đầu ra:

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

Hãy thử trực tuyến!

SmileBASIC, 56 51 47 byte

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

k, 50 byte

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

Than ôi, nó bị cản trở bởi việc thiếu một máy in thập lục phân tích hợp.

Đọc từ phải sang trái, nhiều hay ít:

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

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

Một phiên bản dễ đọc hơn với dòng mới:

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

Khá đơn giản nếu bạn biết cách /// hoạt động. Nó chỉ là một vài thay thế chuỗi.

/// , 544 byte

Vâng, mọi người đang làm /// câu trả lời ngay bây giờ:

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

Tôi thay thế \s0thông qua \s9với Asau đó Ethông qua M, 0 0với C, \n00 0với P, /\svới Zvà cuối cùng //với |, thêm tất cả những ở phía trước của các mã như tôi đã đi.

Hãy thử trực tuyến!

Python 3, 66 byte

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

Perl 5 , 45 byte

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

Hãy thử trực tuyến!