Göreviniz onaltılık zaman tablosunu yazdırmaktır:

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 

Özellikler:

• Onaltılık değerleri büyük harf olarak yazdırabilirsiniz.
• Satırlarınız sondaki boşlukla bitebilir ve program çıktısı sondaki yeni satırla bitebilir.
• Her altıgen değer 0, gösterildiği gibi s ile 2 haneye kadar doldurulmalıdır .

Bu kod golf , yani en kısa cevap (bayt cinsinden ölçülen) kazanır.

Stax , 11 bayt

äΔ←ùûv╚ö♦.J

Koş ve hata ayıkla

Python 2,60 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Tüm tamsayılar için n den 0 kadar 255 , aşağıdakileri yapın.

• (N / 16) × (n% 16) değerini hesapladık .

  Aralığında , n , her ikisi de n / 16 ve n,% 16 , bağımsız bir şekilde aralık kapak 0, ..., 15 , bu çarpım tablosunun bütün kayıtlar oluşturur böylece.

• Satır karakterini ( '\n') (n% 16) / 15 kez tekrarlıyoruz; bu, n% 16 = 15 olduğunda aynı karakterle sonuçlanır ve bunun dışında boş bir dize.

• Biçim dizgisi '%02x%s'önceki iki sonucu tek bir dizgeye dönüştürür, önce küçük harf onaltılık tamsayı gösterimi, (en az) iki basamağa sıfır dolgulu, sonra üretilen dizgiye.

• Son olarak, print...,biçimlendirilmiş sonuçları yazdırır.

  Print cümlesi virgülle sona erdiğinden, Python satır besleme eklemeyecektir. Ayrıca, bir sonraki dizgeyi basmadan önce, Python yeni bir satırın başında olmadıkça bir boşluk hazırlayacaktır . ( kaynak ) Bu, çıktıyı tam olarak bizim istediğimiz gibi biçimlendirir.

Jöle , 12 bayt

⁴Ḷ×þ`d⁴‘ịØhG

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Aşağıdakileri yazdırır:

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

• @MitchellSpector sayesinde 1 bayt kurtarıldı

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

• Bash, aritmetik genişlemeden önce küme parantezi genişlemelerini genişletir, bu nedenle dize $[{0..15}*{0..15}]ilk önce genişler $[0*0] $[0*1] $[0*2] ... $[0*15] $[1*0] ... $[15*15].
• Yukarıdaki aritmetik genişleme dizisi daha sonra ondalık tamsayılar olarak sayısal tablo içeriğine genişler.
• printf '%02x 'Onaltılık olarak ondalık tamsayılar bu listeyi ifade, iki karaktere sıfır yastıklı
• fmt -52tamsayıları 47 karakter genişliğinde çizgiler olarak biçimlendirir ve istenen hizalamayı verir. Not fmtçalışır hatları yapmak için hedef geniş karakterler. Varsayılan olarak, bu genişlikten% 7 daha kısadır. 52 * 93% -1 (yeni satır için) = 47.

Çevrimiçi deneyin .

C # 6, 98 bayt

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

Standart döngü için iç içe geçmiş. Sadece numara, j> = 15 olduğunda newline yazdırmaktır.

JavaScript (ES6), 79 78 77 bayt

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

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

Düzenleme: @ETHproductions ve 1YairRand sayesinde başka bir byte sayesinde 1 bayt kaydedildi.

MATL , 19 18 bayt

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

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

Dan Döngüler 0için 15setler, $imevcut sayısı, sonra tekrar döngüler olduğunu olmak. -fÇıktıyı X2belirtmek için atama ile ormat işlecini kullanır, başında sıfır Xbulunan 2boşluklara yastıklıdır .

Özel not, ve gerçekten tek golf, (...)-join' 'onaltılı sonuçları almak, bunları bir diziye yerleştirmek ve bunları bir dizeye birleştirmek yerine kullanmak yerine, diziyi $OutputFieldSeparatordizelemek için varsayılan değerin bir dizi olduğu gerçeğinden yararlanıyoruz. alan, boş yer, mekan. Bunun anlamı "$(...)", içinde 6 byte tasarruf sağlayan bir komut dosyası bloğu bulunan bir dize yapabiliriz .

Bu dizgilerin tümü boru hattında bırakılır ve Write-Outputprogramın tamamlanmasında örtük olarak verilen çıktılar bize aralarında ücretsiz yeni bir satır verir.

Haskell , 87 bayt

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

Çevrimiçi deneyin!

Daha iyi bir yol olduğunu hayal ediyorum. Belki printfpakete bağlı ....

K7, 36 bayt

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

Ruby, 49 bayt

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

%Eşdeğer operatörün oldukça basit kullanımı sprintf.

$/çizgi ayırıcı değişkenidir ( \nvarsayılan olarak.)

j/=15Uzun parantezleri önlemek gibi ödevlerin kullanılmasına dikkat edin.(j/15)

Mathematica, 46 bayt

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

Yerleşik IntegerString, tabanda 16, uzunluğa kadar doldurma kullanarak basit uygulama 2. Array[...,{16,16},0]İki değişken, 0 ile 15 arasında her bir çalışma vardır.

Matlab, 53 Bayt

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

Örnek çıktı:

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 bayt

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

Çevrimiçi deneyin!

Olumluyum bu en iyi golf değil, ama daha iyi bir şey bulabilirsem lanetleneceğim.

Kod dökü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 bayt

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

Dene

Expanded:

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

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

Değişkeni kullanarak ara s:

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

Ungolfed 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 bayt

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

Ceilingcat sayesinde -2 bayt!

Ungolfed:

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

Sıfır dolgulu sonucu ve boşluk veya yeni satır yazdırır.

Python 3, 55 bayt

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

% Biçimlendirmeyi kullanmak [2:] kullanımına göre bir kaç bayttan tasarruf sağlar. Baskı işlevinde * uyarıları kullanmak da öyle.

Japt -R , 20 15 bayt

GÆGÇ*X sGÃùT2 ¸

Çevrimiçi Deneyin!

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

Oktav, 34 bayt

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

05AB1E , 17 bayt

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

Çevrimiçi deneyin!

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

Bunu 05AB1E'de ele almanın daha iyi bir yolu olabilir.

C, 61 bayt

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

Wandbox

Python2, 102 97 92 90 89 bayt

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

Çıktı:

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

Çevrimiçi deneyin!

SmileBASIC, 56 51 47 bayt

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

k, 50 bayt

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

Ne yazık ki, dahili onaltılık yazıcının olmaması nedeniyle engelleniyor.

Sağdan sola, az ya da çok okumak:

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

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

Newlines ile daha okunaklı bir sürüm:

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

/ / Nasıl çalıştığını biliyorsanız, oldukça basit. Bu sadece bir kaç string değişimi.

/// , 544 bayt

Herkes şimdi /// cevap veriyor:

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

Ben yerini \s0aracılığıyla \s9ile Asonra Earacılığıyla M, 0 0ile C, \n00 0P ile /\sbirlikte Zve son olarak //birlikte |gittim olarak kod önünde bütün bu ekleme.

Çevrimiçi deneyin!

Python 3, 66 bayt

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

Perl 5 , 45 bayt

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

Çevrimiçi deneyin!