挑战

给定两个数字0-9作为输入，输出一个多米诺骨牌（来自二重多米诺骨牌集），在两个面上都具有这些点数（点）。十个可能的面看起来像这样（用管道分隔）：

     |     |    o|    o|o   o|o   o|o o o|o o o|o o o|o o o
     |  o  |     |  o  |     |  o  |     |  o  |o   o|o o o
     |     |o    |o    |o   o|o   o|o o o|o o o|o o o|o o o

或在单独的行上：

     
     
     
-----
     
  o  
     
-----
    o
     
o    
-----
    o
  o  
o    
-----
o   o
     
o   o
-----
o   o
  o  
o   o
-----
o o o
     
o o o
-----
o o o
  o  
o o o
-----
o o o
o   o
o o o
-----
o o o
o o o
o o o

输入格式

您可以采用任何合理的格式输入信息，包括但不限于：

• 两个单独的整数，字符串或单例数组；
• 0-99之间的单个整数；
• 两个整数的数组；
• 一串两位数字。

输出格式

• 两个面可以水平对齐，并用管道隔开，如下所示：

    o|o   o
     |  o  
o    |o   o

• 或者它们可以垂直对齐，并用连字符分隔，如下所示：

    o
     
o    
-----
o   o
  o  
o   o

• 如果愿意，可以在多米诺骨牌周围输出边框。
• 您也可以选择输出线列表，两个面的列表或这些的组合。
• 您可以使用任何非空白字符作为点（我使用o）。
• 如果您确实希望，可以将其0用于空格和1pip，如果输出数组，则可以使用False/ True（或您的语言的等效语言）。
• 您可以删除列之间的空格；这是7、7的有效输出：

ooo|ooo
 o | o 
ooo|ooo

• 任何一个面都可以旋转90度。这也是7、7的有效输出：

o   o|o o o
o o o|  o  
o   o|o o o

• 只要输出的主要部分仍然适合其他约束，您就可以拥有任意数量的/很少的前导/尾随空格。
• 即使线是空的，每个面也必须高3行。对于0，1，您将无法输出：

-----

  o

但是您可以输出以下内容：

-----

  o

同样，如果输出的是两行列表，则可以这样做[["", "", ""], ["", " o", ""]]，但不能[[""], [" o "]]。

计分

这是代码高尔夫球，因此每种语言中以字节为单位的最短代码获胜。

Python 2中，101个 97 92 68 64字节

lambda*a:[[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]]for n in a]

在线尝试！

学分

• Xcoder先生将其从101个字节减少到92个字节
• Jonathan Allan（Dennis）从92个字节减少到68个字节
• 全人类从68个字节减少到64个字节

C（GCC） ，252个 242 269 262 241 235 220字节

我在python套接字上的堆栈溢出中，当这个弹出窗口时，为什么不呢？第一次打高尔夫，所以我不能完全确定我是否遵守100％的规则（如果不遵守，有人要窃取我的谚语cookie并修复它，就这样吧）。与'o'及''，255个245 272 265 244 238 228字节。用* 79 + 32替换+48。

#define Q(P,R)(R>>P&1)+48
char a[11];i=0;f(char*c){char b=c[0];a[3]=a[7]='\n';a[5]=Q(0,b);a[1]=a[9]=Q(3,b);a[2]=a[8]=Q(2,b)|a[1];a[0]=a[10]=Q(1,b)|a[2];a[4]=a[6]=a[1]|Q(2,b)&Q(1,b);puts(a);if(i++<1){puts("---");f(c+1);}}

在线尝试！

工作原理：
我使用了按位和逐位移位的方法，以查找是否应该清除斑点或点子，然后将0或1偏移为正确的ASCII值。它搞砸了4和5，所以他们需要一些修复。实际上增加了几个字节。能够通过删除掩码并仅使用1（doh）来删除几个字节

特别感谢Xcoder先生，通过删除多余的#define减少了7个字节
：删除了memset -21个字节。将6、4、2的位逻辑重新分配为分别取决于8 | 4＆2、8 | 4、8 | 4 | 2。-6个字节。通过使用puts而不是printf删除了多余的换行符，后者也更短。将数组缩短为11，从而消除了额外的分配。-15个字节。现在，我认为这是我能做的最好的事情。

果冻，20字节

“¤o.ƤẸʠṚ’B¬s5ŒBị@s€3

在线尝试！

替代版本，原始输出，33 32 31字节

“¤o.ƤẸʠṚ’ṃ⁾ os5ŒBị@s€3K€€Zj€”|Y

感谢@ user202729打高尔夫球1个字节！

在线尝试！

怎么运行的

首先，“¤o.ƤẸʠṚ’以双射基数250为整数，将返回值设置为1086123479729183。

然后，B¬将返回值转换为二进制，并取每个数字的逻辑非，从而产生数组

00001001000010110100101011110011101111101111100000

接下来，s5ŒB将该数组拆分为长度为5的块，然后反弹每个块，将abcde变成abcdedcba，产生

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

现在，ị@检索此数组的^第j ^个和^第k ^个项目，其中j，k是程序的第一个参数。请注意，索引是基于1的并且是模块化的，因此第零个元素也是第十个元素。

最后，s€3将长度为9的每个块拆分为长度为3的三个块。

果冻，13个字节

⁽½ÑD<;ḂŒBs3µ€

在线尝试！

结合DennisŒB在此答案中使用（反弹）的想法和Xcali在此答案中的观察，得到13个字节。

果冻，28个字节

（印刷精美）

直到现在我才知道Jelly字符串文字会自动终止...

⁽½ÑD<;ḂŒBị⁾o Ks6Yµ€j“¶-----¶

在线尝试！

PHP 155，150字节

function d($a){foreach($a as$n){$o="---";for($i=0;$x=2**$i,$i<9;++$i)$o.=([0,16,68,84,325,341,365,381,495,511])[$n]&$x?0:' ';echo chunk_split($o,3);}}

它采用整数数组作为输入。供测试用：

d([1,2]);

echo "=========\n";

d([0,1,2,3,4,5,6,7,8,9]);

输出格式：

---

 0 

---
  0

0  

检查出来住在这里

我的解决方案

对于我的解决方案，我使用了由按位数字（2的幂）组成的矩阵。它可以像这样可视化：

 1  |  2  |  4
 8  | 16  | 32
 64 | 128 | 256

然后是一个存储阵列，该存储阵列由每个多米诺骨牌点的比特位置组成，这些比特位置与编号索引相关：

[0,16,68,84,325,341,365,381,495,511]

因此，请澄清一下：

• 示例0：索引0或值0将是空白的多米诺骨牌，始终为false。
• 示例1：索引1或值16将是位于中心的矩阵中的第一个多米诺骨牌16。
• 示例2：索引2或值68将是第二个多米诺骨牌，并且在矩阵的右上角4和左下角64 或4|64
• 示例3：索引5或值341将是矩阵中的数字5，即Domino1|4|16|64|256
• 示例4：索引9或值511将是数字9多米诺骨牌，矩阵中是所有位的组合。

一旦建立这是一个相当简单的循环在矩阵中的9个位置，并设置之事$x，以2向电力的$i

for($i=0;$x=2**$i,$i<9;++$i)

然后我们按位进行，然后&遍历这些点。因此，为了示例起见，将使用上面的示例2，并且x为了视觉清晰，我将使用的代替空格：

• 迭代1，68 & 1 ? 0 : 'x'导致'x'
• 迭代2，68 & 2 ? 0 : 'x'导致'x'
• 迭代3，68 & 4 ? 0 : 'x'结果0
• 迭代4，68 & 8 ? 0 : 'x'导致'x'
• 迭代5，68 & 16 ? 0 : 'x'导致'x'
• 迭代6，68 & 32 ? 0 : 'x'结果'x'
• 迭代7，68 & 64 ? 0 : 'x'结果0
• 迭代8，68 & 128 ? 0 : 'x'导致'x'
• 迭代9，68 & 256 ? 0 : 'x'导致'x'

循环完成后，我们将使用此字符串结束"xx0xxx0xx"。

然后，我们添加边框"---xx0xxx0xx"给它（其实我与边框，但不管开始）。

最后我们在3 上将其chunk_split（）用于：

---
xx0
xxx
0xx

随时让我知道您的想法。

Perl 5中，107 76 70 + 1（ -a） = 70字节

Perl 5，70个字节

$,="
---
";say map{$_='351
7 7
153'=~s/\d/$_>$&||0/ger=~s/ /$_%2/er}<>

在线尝试！

对空格使用0，对点使用1。很简单的方法：观察一下，随着数字上升，一个小点“打开”，除了中间的一个点，它永远不会“关闭”。在中间位置，所有奇数均打开。因此，对于每个位置，只需检查数字是否大于其关闭的最后一个数字即可。在||0当条件为假时产生输出。在Perl中，false是undef输出为null的值。

JavaScript（ES6），79 78字节

@ETHproductions节省了1个字节

以currying语法输入(a)(b)并输出垂直ASCII多米诺骨牌。

a=>b=>(g=n=>`351
707
153`.replace(/./g,d=>' o'[(+d?n>d:n)&1]))(a)+`
---
`+g(b)

演示版

let f =

a=>b=>(g=n=>`351
707
153`.replace(/./g,d=>' o'[(+d?n>d:n)&1]))(a)+`
---
`+g(b)

console.log(f(4)(2))
console.log(f(3)(7))

水平版本，80 79字节

@ETHproductions节省了1个字节

将输入作为2个整数的数组，并输出水平ASCII多米诺骨牌。

a=>`240|351
686|797
042|153`.replace(/\d/g,d=>' o'[(d<8?(x=a[d&1])>(d|1):x)&1])

演示版

let f =

a=>`240|351
686|797
042|153`.replace(/\d/g,d=>' o'[(d<8?(x=a[d&1])>(d|1):x)&1])

console.log(f([4,2]))
console.log(f([3,7]))

APL（Dyalog），25个字节

2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨

在线尝试！

-2感谢ngn。

输出格式有点奇怪：此函数返回一个数组，其中包含两个shape-3,3数组，每个数组分别包含0和1。

C（gcc），115个字节

i;g(x){for(i=0;++i<10;)printf("%c%c",32+(i^5?x>" CEAG@GAEC"[i]-64:x%2),i%3?32:10);}f(a,b){g(a),puts("-----"),g(b);}

在线尝试！

Javascript（ES6），87个字节

a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]

f=a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]

<div oninput="o.innerText=JSON.stringify(f(a.value)(b.value))"><input id=a type=number min=1 max=9 value=1><input id=b type=number min=1 max=9 value=1><pre id=o>

Haskell-88个字符

map$zipWith(zipWith($))[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]].repeat.repeat

取两个表示面孔的数字的列表，返回布尔列表的列表。没那么短，但是我发现解决方案很有趣。

点，32 27 24 21字节

^{-3个字节，感谢@DLosc}

FcgP[Yc>_M3517c%2RVy]

在线尝试！

说明：

F                      For each
 c                       character $c
  g                      in the list of inputs:
   P                     Print
    [               ]      an array consisting of
                             an array of bits representing whether
      c>                       $c is greater than
        _M                       each of
          3517                     3, 5, 1, and 7
     Y                       (call this bit array $y),
              c%2            $c mod 2,
                 RV          and the reverse
                   y           of $y.

> <>，57 + 3 = 60字节

>{:3)$:5)$:1)$:7)$:2%$\ao \
\?%cl999)3$)5:$)1:$)7:/nnn<rp

在线试用。输出为垂直多米诺骨牌，点为1，空白为0，分隔符为9，如下所示：

001
000
100
999
111
111
111

从技术上讲，它最多可以扩展到12个输入值。

旧版：

> <>，76 + 3 = 79字节

>{:3)$:5)$:1)$a$:7)$:2%$:7)\&?o~?!n\
\?(*a3la"---"a)3$)5:$)1:$a$/$&:)9::<r~p

在线试用。输出为垂直多米诺骨牌，点为1，空白为0，如下所示：

001
000
100
---
111
111
111

木炭，46 44 43 39字节

ＥＥ²℅§@APQTUVW^_ＮＥ⪪Ｅ⁹§ o÷ιＸ²↔⁻⁴λ³⪫λ Ｍ⁵↑⁵

在线尝试！链接是详细版本的代码。说明：

ＥＥ²℅§@APQTUVW^_Ｎ

读取两个整数并将其映射到查找表中。然后映射结果。（这可以有效地临时捕获结果。）

  Ｅ⁹                Loop `l` (!) from 0 to 8
            ⁻⁴λ     Subtract from 4
           ↔        Absolute value
         Ｘ²         Power of 2
       ÷ι           Divide into the looked-up value `i`
    § o             Convert to space or o
 ⪪             ³    Split into (3) groups of 3
Ｅ                   Map over each group
                ⪫λ  Join the 3 characters with spaces

然后将结果隐式打印在单独的行上，因为结果是嵌套的，所以每个面之间都有多余的空白行。

Ｍ⁵↑⁵

向上移动并在面之间绘制分界线。

以前的43字节水平版本：

↶Ｐ³Ｍ⁷←ＦＥ²℅§@APQTUVW^_ＮＦ⁹«Ｆ¬﹪κ³⸿⸿§ o÷ιＸ²↔⁻⁴κ

在线尝试！链接是详细版本的代码。说明：

↶

垂直工作。

Ｐ³

打印分隔线。

Ｍ⁷←

定位到第一张脸的开头。

ＦＥ²℅§@APQTUVW^_Ｎ

读取两个整数并将其映射到查找表中。

Ｆ⁹«

准备输出长达9 os。

Ｆ¬﹪κ³⸿⸿

但是每三秒开始一个新列o。

§ o÷ιＸ²↔⁻⁴κ

将ASCII码的低5位转换为二进制，然后镜像其余4 os 的输出。

果冻，16字节

>⁽¤xb8¤;ḂŒḄs3
Ç€

在线尝试！

使用Neil的策略和基本解压缩来生成值；输出为二进制数组。将列表作为输入。

说明：

Ç€
 € for €ach input,
Ç  execute the previous line.

>⁽¤xb8¤;ḂŒḄs3
 ⁽¤xb8¤       the array [3, 5, 1, 7]
>             1 if the input is greater than each element, 0 otherwise
       ;Ḃ     append input % 2
         ŒḄ   bounce array
           s3 split into chunks of 3

APL + WIN， 49 47字节

4⌽'|',⌽⍉6 3⍴,⍉(9⍴2)⊤(+\∊0 241 52 24 114,¨16)[⎕]

根据亚当的评论进行编辑，谢谢，以索引原点为零运行。

提示屏幕输入为每张面孔一个整数矢量。

输出的形式为：

1 1 1 | 0 0 1    0 0 0 | 1 0 1
0 1 0 | 0 1 0    0 0 0 | 0 1 0
1 1 1 | 1 0 0    0 0 0 | 1 0 1

输入7 3和0 5

说明：

(+\∊0 241 52 24 114,¨16) create a vector of integers whose binaries
                         represent the dots on the domino faces

[1+⎕] take input integers as indices to select from above vector

⍉6 3⍴,⍉(9⍴2)⊤ convert selected integers to a 9x2 binary matrix and reshape
              to match the orientation of the domino faces

4⌽'|',⌽ rotate, concatenate centre line markers and rotate again to centre 

Python 2，121字节

lambda x,y,d="001155777702020202570044557777":[("%03d"%int(bin(int(o))[2:]),"---")[o=="3"]for o in d[x::10]+"3"+d[y::10]]

在线尝试！

返回并重新阅读规则后，使用lambda减少为121。现在输出行列表。

先前版本的输出格式正确：

Python 2中，156个 153 147 141字节

x,y=input()
d="001155777702020202570044557777"
a=["%03d"%int(bin(int(o))[2:])for o in d[x::10]+d[y::10]]
for x in a[:3]+["---"]+a[3:]:print x

在线尝试！

-3感谢@NieDzejkob

将输入作为2个整数，以垂直格式输出，其中0 =空格和1 =点。

PYT，220个 154 字节

第二次尝试（154字节）

46281ᴇ8264áĐ9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔

说明：

46281ᴇ8264áĐ                                    Pattern matching for every cell but the middle
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹     Make top cell
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ      Make bottom cell
5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔                          Make boundary and combine

首次尝试（220字节）：

2`↔←Đ4≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2%Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3Ș4≥Đ6²⁺3**⇹¬5«+1ᴇ9△ĐĐĐĐ1ᴇ↔⁻łŕ↔ŕŕŕŕŕŕáƇǰ

说明：

2                           Push 2 (this is how many 'cells' to make)
`     ... ł                 While the top of the stack is not zero, loop
↔                           Flip the stack (useless at the beginning, undoes the flip at the end of the loop)
←Đ4≥Đ6²⁺3**⇹¬5«+            Set top-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set top-middle pip
2⁵⇹3Ș                       Space
Đ2≥Đ6²⁺3**⇹¬5«+             Set top-right pip
1ᴇ⇹3Ș                       New line
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-left pip
2⁵⇹3Ș                       Space
Đ2%Đ6²⁺3**⇹¬5«+             Set center pip
2⁵⇹3Ș                       Space
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-right pip
1ᴇ⇹3Ș                       New line
Đ2≥Đ6²⁺3**⇹¬5«+             Set bottom-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set bottom-middle pip
2⁵⇹3Ș                       Space
4≥Đ6²⁺3**⇹¬5«+              Set bottom-right pip
1ᴇ                          New line
9△ĐĐĐĐ                      Add 5 dashes
1ᴇ                          New line
↔⁻ł                         Decrement counter (if >0, loop; otherwise, exit loop)
ŕ↔ŕŕŕŕŕŕ                    Remove all unnecessary items on the stack
áƇǰ                         Push stack to an array, get characters at unicode codepoints given by values in the array, join characters with empty string

在线尝试！

05AB1E，34个字节

•ΩõIº•R2ô¹2÷è¹È-bDg5s-ú.∞3ô»TR„ o‡

在线尝试！

这很困难，因为05AB1E的填充错误。

基本说明：

• 这里有4个重要模式，分别是2、4、6和8。
• 3,5,7和9是其他模式加1。
• 由于对称性，1不重要，如果输入为偶数，则减去1即可切换中间位。
• 切换LSB可使中间位由于镜像而翻转。

SmileBASIC，92 69字节

INPUT N,M
DEF Q?N>3;N>5;N>1?N>7;1AND N;N>7?N>1;N>5;N>3
END
Q?777N=M
Q

例：

? 7,2
111
010
111
777
001
000
100

如果您的规则不够严格，就会发生这种情况。

FALSE，116 80 78 70 69 66 63 61 59 58字节

[$3[>_$.\$]$p:!5p;!1p;!"
"7p;!%1&.."
"..."
"]$s:!"---
"s;!

仍在为此...

芯片，142 135字节

! CvDvB
>v-]-x.
|Z-]-]e
|Z]xe|
|ZR(-'
|Zx.AD
|Zxx]x.
|Zx^-]e
|Z<,(-.
|Zx]xe|
|Zx-]-]e
|Zx-]-x'
|Z<C^D^B
|>x~s
|Zx.
|Zx<
|Zxb
|Z+^~f
`zd

在线尝试！

输入是一串数字。使用零作为点。为一个数字画点，读取下一个输入字节。如果没有下一个字节，则终止，否则绘制分隔线并开始。

每个Z（或z）对应于输出的一个字符，它们的位置按从上到下的顺序触发。资本化A，B，C，以及D对应于输入的低四位（这就是我们看一下，这样"34" == "CD" == "st" ...）。小写b，d，e，f对应于输出的各个比特。

也可以制作无限长的多米诺骨牌；尝试给予0123456789作为输入。

PHP，116字节

while($i<6)echo strtr(sprintf("%03b",[_011557777,_202020267,_044557777][$i/2][$argv[$i%2+1]]),10,"o "),"|
"[$i++%2];

需要PHP 5.5或更高版本。运行-nr或在线尝试。

C（GCC） ，150个 146字节

• 多亏了ceilingcat，节省了四个字节。

p(b){printf(" %c",33-b);}P(a){p(a<4),p(a<6),p(a<2),p(23),p(a<8),p(~a&1),p(a<8),p(23),p(a<2),p(a<6),p(a<4),p(23);}f(a,b){P(a),puts(" -----"),P(b);}

在线尝试！