打印f×f次表

46

您的任务是打印十六进制时间表：

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

规格：

  • 您可以大写打印十六进制值。
  • 您的行可以以尾随空格结尾，而程序输出可以以尾随换行结尾。
  • 0如图所示，每个十六进制值都必须用s 填充到两位数。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

code-golf  kolmogorov-complexity  hexadecimal 
— 硕果累累
source
— 路易斯·门多
也相关
— Digital Trauma'December
4
乘法表通常不包含因数0 ... :-)
— Luis Mendo
28
@路易斯·门多：小学生还能怎样记住数字的0倍？：P
— 牛奶
1
达恩，我想使用hexdump提出解决方案，但是将其分成4个字节的块。：（
— HyperNeutrino

Answers:

14

Python 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'将前面的两个结果转换为单个字符串，首先是小写的十六进制整数表示形式，将其填充零（至少）两位数（至少），然后是生成的字符串。

  • 最后，print...,打印格式化的结果。

    由于print语句以逗号结尾，因此Python不会追加换行符。另外，在打印下一个字符串之前，Python会在前面加上一个空格，除非我们在新行的开头。（源）这恰好是完全按照我们想要的格式格式化输出。

— 丹尼斯
source
14

果冻，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.
— 丹尼斯
source
那是12个字符，而不是字节。根据问题，答案以字节为单位，您的答案是25 个字节和12个字符。至少根据该网站的信息mothereff.in/byte-counter
— Ciprum '16
18
当然，在UTF-8中。但是，Jelly使用SBCS，因此可以使用单个字节对每个字符进行编码。
— 丹尼斯
11

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"
— 贾德
source
1
怎么样：as.hexmode（outer（0：15,0：15，`*`））
— ixodesbeta
2
或更好的是，as.hexmode(0:15%o%0:15)
— Giuseppe
10

Bash + coreutils，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 '十六进制整数列表表示为十六进制，零填充两个字符
  • fmt -52将整数格式化为47个字符的宽行，以提供所需的对齐方式。 注意fmt尝试使行目标字符变宽。 默认情况下，它比宽度短7％。52 * 93％-1（对于换行符）= 47。

在线尝试。

— 数字创伤
source
1
不错的解决方案。看来您可以使用fmt -52（不带w）将一个字节剃掉。
— 米切尔·史派克
真好！顺便说一句 在zsh中它可能是{0..15}\*{0..15}其为2个字节短:)
— ბიმო
5

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

复制演示

标准嵌套的for循环。唯一的技巧是在j> = 15时打印换行符。

— 吴连杰
source
+1，但似乎repl.it不喜欢$""
— Metoniem
@Metoniem tio.run/#要好得多
— HyperNeutrino
4

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())
展开摘要

编辑：感谢@ETHproductions保存了1个字节，感谢@YairRand保存了另一个字节。

— 尼尔
source
@ETHproductions Bah，那.slice(-2)是我在做的时候留下来的('0'+toString(16))。我想我已经尝试过了，' \n'[+!(~i&15)]但是长度是一样的。
— 尼尔
@ETHproductions我还保存了1个字节...
— 尼尔
您可以将替换(~i&15?' ':'\n')为来保存一个字节' \n'[~i&15&&1]。
— Yair Rand
@YairRand我想你的意思是，'\n '但我明白了，谢谢！
— 尼尔
3

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
— 路易斯·门多
source
3

PowerShell，46字节

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

在线尝试！

从循环0到15，设置$i为当前编号，然后再次循环。使用-f带有X2指定名称的ormat运算符来指定将X十进制填充到2前导零的空格的输出。

需要特别注意的是，而且实际上是唯一的解决方法，它不是使用a (...)-join' '来获取十六进制结果，而是将它们封装在一个数组中，然后将它们连接成一个字符串，而是利用了以下事实：将$OutputFieldSeparator数组字符串化的默认值为空间。这意味着我们可以在其中包含脚本块的字符串中"$(...)"保存6个字节。

这些字符串都留在管道上，Write-Output在程序完成时通过隐式输出可以使我们在它们之间免费换行。

— AdmBorkBork
source
2

Ruby，49个字节

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

相当简单的%运算符用法等效于sprintf。

$/是行分隔符变量（\n默认情况下。）

请注意分配的使用，例如j/=15避免较长的括号(j/15)

— Level River St
source
2

Mathematica，46个字节

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

使用内置的IntegerString基础直接实现16长度为padding 2。在Array[...,{16,16},0]有两个变量每次运行从0到15。

— 格雷格·马丁
source
2

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
— 欧文·摩根（Owen Morgan）
source
在线尝试！（有点...）
— Pavel
2

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
— 加布里埃尔·贝纳米（Gabriel Benamy）
source
2

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
— 布拉德·吉尔伯特b2gills
source
2

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
}
— 朱利安·拉希涅（Julian Lachniet）
source
是不是"\n"换行？哇，有人曾经使用过一次纯 ECMA。
— 扎卡里
而且您应该能够使用s+=2>c.length?" 0"+c:" "+c。
— 扎卡里
我知道这已经很久了，但是我注意到一些节省可能也有助于将来的挑战！您可以同时设置a和s，""因为""*0它仍然是0。可以将您的行内联b++到a*b另一个被使用的地方，以进行另一次轻微的保存，但是如果您将字符串重写为：s+=" "+(0+(a*b++).toString(16)).substr(-2)将会保存一个块。用那些应该是86字节！希望有帮助！
— Dom Hastings
2

C，68 66字节

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

-2个字节，感谢ceilingcat！

取消高尔夫：

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

打印填充零的结果以及空格或换行符。

— 卡尔·纳普夫
source
是i隐式推论为intC的标准功能吗？
— sergiol
@sergiol是，int是默认假设。
— Karl Napf
遗憾的是，根据C标准（C99-6.5.2.2函数调用），输出未定义。
— Jasmes，
建议~i%16而不是i%16<15
— ceilingcat
2

Python 3，55个字节

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

使用％formatting比[2：]用法节省了很多字节。在打印功能上使用* splats也是如此。

— 牛f
source
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
— 毛茸茸
source
你很容易会所做®的不是Ë，P
— ETHproductions
@ETHproductions：是的，但是我想玩闪亮的新快捷键！：D
— 毛茸茸的
1

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中可能有更好的方法来处理此问题。

— Osable
source
— 凯文·克鲁伊森
确实！;）当时不存在这样的命令；将256推入2字节命令žz。请参阅2016年11月12日的Info.txt。很高兴看到该语言仍在不断发展，人们正在使用它：D。
— 奥萨卜莱
喔好吧。我知道小数常数很新，但是认为₁for的256存在时间更长。但是我看到您的答案是从2016年12月开始的，所以我可以知道当时还没有。:)我已经看到了一些05AB1E答案从2016年甚至没有过隐输入尚未..
— 凯文Cruijssen
1

C，61字节

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

魔盒

— o79y
source
是i隐式推论为intC的标准功能吗？
— sergiol
1

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

在线尝试！

— 伊西
source
1

SmileBASIC，56 51 47字节

I=RND(16)J=RND(16)LOCATE I*3,J?HEX$(I*J,2)EXEC.
— 12Me21
source
1

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
— zgrep
source
1

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

如果您知道///的工作原理，则非常简单。只是一些字符串替换。

— 硕果累累
source
1

///，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最后//有|，将所有这些在代码的前面，我就去了。

在线尝试！

— Boboquack
source
1

Python 3，66个字节

r=range(16)
for i in r:print(*[('0'+hex(j*i)[2:])[-2:]for j in r])
— 0WJYxW9FMN
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.