당신의 작업은 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 

사양:

• 16 진수 값을 대문자로 인쇄 할 수 있습니다.
• 줄은 후행 공백으로 끝나고 프로그램 출력은 후행 줄 바꿈으로 끝날 수 있습니다.
• 모든 16 진수 값은 0그림과 같이 s로 2 자리로 채워 져야합니다 .

이것은 code-golf 이므로 가장 짧은 답변 (바이트 단위로 측정)이 이깁니다.

Stax , 11 바이트

äΔ←ùûv╚ö♦.J

실행 및 디버깅

파이썬 2 , 60 바이트

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

온라인으로 사용해보십시오!

작동 원리

0 에서 255 까지의 모든 정수 n에 대해 다음을 수행합니다.

• 우리는 (n / 16) × (n % 16)을 계산 합니다.

  의 범위 N 양 N / 16 및 N 16 %, 별도로 커버 범위 0, ..., 15 , 이것은 곱셈 테이블의 모든 엔트리를 생성하므로.

• 우리는 줄 바꿈 문자 ( '\n') (n % 16) / 15 번을 반복하여 n % 16 = 15 일 때 동일한 문자를, 그렇지 않으면 빈 문자열을 만듭니다.

• 형식 문자열 '%02x%s'은 두 개의 이전 결과를 하나의 문자열로, 먼저 소문자 16 진수 정수 표현으로, 적어도 두 자리 숫자로 0으로 채워진 다음 생성 된 문자열로 바꿉니다.

• 마지막으로 print...,서식이 지정된 결과를 인쇄합니다.

  print 문은 쉼표로 끝나기 때문에 파이썬은 줄 바꿈을 추가하지 않습니다. 또한 다음 문자열을 인쇄하기 전에 새 줄의 시작 부분에 있지 않으면 Python은 공백을 추가합니다 . ( source ) 이것은 원하는대로 출력 형식을 지정합니다.

젤리 , 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" 

배쉬 + 코어 유틸리티, 40

• @MitchellSpector 덕분에 1 바이트 절약

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 '십진 정수 목록을 16 진수로 표현하고 두 문자로 0으로 채워짐
• 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 데모

표준 중첩 for 루프. j> = 15 일 때 개행을 인쇄하는 것만 트릭입니다.

자바 스크립트 (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())

편집 : @ETHproductions 덕분에 1 바이트를 저장하고 @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현재의 숫자가, 다시 루프 것을 할 수 있습니다. -format 연산자를 X2지정 과 함께 사용하여 맨 앞에 0 X이있는 2공백에 출력을 지정합니다 .

특히 주목할만한 사실은 a (...)-join' '를 사용하여 16 진수 결과를 가져 와서 배열로 캡슐화하고 문자열로 연결하는 대신 배열을 문자열 $OutputFieldSeparator화하는 기본값 이 우주. 즉 "$(...)", 대신 스크립트 블록으로 문자열을 수행하여 6 바이트를 절약 할 수 있습니다 .

이러한 문자열은 모두 파이프 라인에 남아 Write-Output있으며 프로그램 완료시 암시 적 출력 은 무료로 줄 바꿈을 제공합니다.

하스켈 , 87 바이트

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

온라인으로 사용해보십시오!

더 좋은 방법이 있다고 생각합니다. printf패키지 에 따라 다를 수 있습니다 ....

K7, 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까지 각 실행이 있습니다.

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

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

펄 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

자바 스크립트, 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)

Ungolfed 코드 :

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

ceilingcat 덕분에 -2 바이트!

언 골프 드 :

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

채워지지 않은 결과와 공백 또는 줄 바꿈을 인쇄합니다.

파이썬 3, 55 바이트

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

% formatting을 사용하면 [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);}

완드 박스

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 진수 프린터가 없기 때문에 방해가됩니다.

오른쪽에서 왼쪽으로 읽기 또는 거의 읽기 :

                                               !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, P와 /\s함께 Z마지막 //으로 |내가 갔던 코드의 앞에 모든 추가.

온라인으로 사용해보십시오!

파이썬 3, 66 바이트

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

펄 5 , 45 바이트

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

온라인으로 사용해보십시오!