Tugas Anda adalah mencetak tabel waktu heksidecimal:

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 

Spesifikasi:

• Anda dapat mencetak nilai hex dalam huruf besar.
• Baris Anda dapat diakhiri dengan spasi tambahan dan output program dapat diakhiri dengan baris tambahan tambahan.
• Setiap nilai hex harus diisi hingga 2 digit dengan 0s seperti yang ditunjukkan.

Ini adalah kode-golf , jadi jawaban tersingkat (diukur dalam byte) menang.

Stax , 11 byte

äΔ←ùûv╚ö♦.J

Jalankan dan debug itu

Python 2 , 60 byte

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

Cobalah online!

Bagaimana itu bekerja

Untuk semua bilangan bulat n dari 0 hingga 255 , kami melakukan hal berikut.

• Kami menghitung (n / 16) × (n% 16) .

  Pada rentang n , baik n / 16 dan n% 16 secara independen mencakup kisaran 0, ..., 15 , jadi ini menghasilkan semua entri dari tabel perkalian.

• Kami mengulangi karakter linefeed ( '\n') (n% 16) / 15 kali, yang menghasilkan karakter yang sama ketika n% 16 = 15 dan string kosong sebaliknya.

• Format string '%02x%s'mengubah dua hasil sebelumnya menjadi string tunggal, pertama representasi bilangan bulat heksadesimal huruf kecil, nol-empuk untuk (setidaknya) dua digit, kemudian string yang dihasilkan.

• Akhirnya, print...,cetak hasil yang diformat.

  Karena pernyataan cetak berakhir dengan koma, Python tidak akan menambahkan umpan baris. Juga, sebelum mencetak string berikutnya, Python akan menambahkan sebuah spasi kecuali kita berada di awal baris baru. ( sumber ) Ini terjadi untuk memformat output persis seperti yang kita inginkan.

Jelly , 12 byte

⁴Ḷ×þ`d⁴‘ịØhG

Cobalah online!

Bagaimana itu bekerja

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

Mencetak berikut ini:

      [,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 byte disimpan berkat @MitchellSpector

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

• Bash memperluas ekspansi brace sebelum ekspansi aritmatika, jadi string $[{0..15}*{0..15}]pertama kali mengembang $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
• Rangkaian ekspansi aritmatika di atas kemudian diperluas ke konten tabel numerik, sebagai bilangan bulat desimal.
• Yang printf '%02x 'menyatakan daftar ini bilangan bulat desimal sebagai hex, nol-empuk untuk dua karakter
• fmt -52memformat bilangan bulat sebagai garis lebar 47 karakter, memberikan perataan yang diinginkan. Note fmtmencoba membuat karakter garis sasaran melebar. Secara default, ini 7% lebih pendek dari lebar. 52 * 93% -1 (untuk baris baru) = 47.

Cobalah online .

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

demo repl.it

Standar bersarang untuk-loop. Satu-satunya trik adalah mencetak baris baru saat 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())

Sunting: Disimpan 1 byte berkat @ETHproductions dan byte lain berkat @YairRand.

MATL , 19 18 byte

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

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

Cobalah online!

Loop dari 0ke 15, setel $imenjadi angka saat itu, lalu loop lagi. Menggunakan -foperator ormat dengan X2penunjukan untuk menentukan output apakah dia Xadekimal2 ruang dengan nol terkemuka.

Dari catatan khusus, dan benar-benar satu-satunya golf, adalah bahwa alih-alih menggunakan a (...)-join' 'untuk mengambil hasil hex, merangkumnya dalam sebuah array, dan menggabungkannya menjadi sebuah string, kami memanfaatkan fakta bahwa nilai default $OutputFieldSeparatoruntuk pengurutan array adalah ruang. Itu berarti kita bisa melakukan string dengan blok skrip di dalamnya "$(...)"sebagai gantinya, menghemat 6 byte.

String-string itu semuanya ditinggalkan di dalam pipa, dan output melalui implisit Write-Outputpada penyelesaian program memberi kita garis baru di antara mereka secara gratis.

Haskell , 87 byte

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

Cobalah online!

Saya membayangkan ada cara yang lebih baik. Mungkin tergantung printfpaketnya ....

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}

Cukup mudah digunakan %setara dengan operator sprintf.

$/adalah variabel pemisah garis ( \nsecara default.)

Perhatikan penggunaan tugas seperti j/=15untuk menghindari kurung lagi(j/15)

Mathematica, 46 byte

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

Implementasi langsung menggunakan built-in IntegerString, in base 16, padding to length 2. The Array[...,{16,16},0]memiliki dua variabel masing-masing berjalan 0-15.

Matlab, 53 Bytes

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

Output sampel:

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*$_,@%}

Cobalah online!

Saya yakin ini bukan golf yang optimal, tetapi saya akan terkutuk jika saya dapat menemukan sesuatu yang lebih baik.

Rincian kode:

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

Cobalah

Diperluas:

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

Panggilan menggunakan variabel s:

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

Kode tidak dikunci:

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 bytes berkat ceilingcat!

Tidak Disatukan:

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

Mencetak hasil nol empuk dan spasi atau baris baru.

Python 3, 55 byte

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

Menggunakan% format menghemat beberapa byte lebih dari penggunaan [2:]. Begitu juga dengan menggunakan * percikan pada fungsi cetak.

Japt -R , 20 15 byte

GÆGÇ*X sGÃùT2 ¸

Cobalah secara 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

Oktaf, 34 byte

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

05AB1E , 17 byte

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

Cobalah 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

Mungkin ada cara yang lebih baik untuk menangani ini di 05AB1E.

C, 61 byte

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

Wandbox

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

Keluaran:

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

Cobalah online!

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

Sayangnya, itu terhalang oleh kurangnya printer heksadesimal built-in.

Membaca dari kanan ke kiri, lebih atau kurang:

                                               !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 

Versi yang lebih mudah dibaca dengan baris baru:

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

Cukup sederhana jika Anda tahu cara /// bekerja. Itu hanya beberapa penggantian string.

/// , 544 byte

Baiklah, semua orang melakukan /// jawaban sekarang:

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

Aku diganti \s0melalui \s9dengan Aitu Emelalui M, 0 0dengan C, \n00 0dengan P, /\sdengan Zdan akhirnya //dengan |menambahkan semua ini di depan kode saat aku pergi.

Cobalah online!

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}

Cobalah online!