Draw me a domino

Question

Challenge

Given two digits 0-9 as input, output a domino (from the double-nine domino set) with these number of pips (dots) on the two faces. The ten possible faces look like this (separated by pipes):

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

Or on separate lines:

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

Input formats

You may take input in any reasonable format, including but not limited to:

• Two separate integers, strings, or singleton arrays;
• A single integer from 0-99;
• An array of two integers;
• A string of two digits.

Output formats

• The two faces may be horizontally aligned, separated by pipes like so:

    o|o   o
     |  o  
o    |o   o

• Or they may be vertically aligned, separated by hyphens like so:

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

• You may output a border around the domino if you wish.
• You may also choose to output a list of lines, a list of the two faces, or a combination of these.
• You may use any non-whitespace character for the pips (I used o).
• If you really wish, you can use 0 for whitespace and 1 for the pips, or False/True (or your language's equivalent) if outputting an array.
• You may remove the whitespace between columns; this is a valid output for 7, 7:

ooo|ooo
 o | o 
ooo|ooo

• Any of the faces may be rotated by 90 degrees. This is also a valid output for 7, 7:

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

• You may have as much/little leading/trailing whitespace as you like, as long as the main part of the output still fits the other constraints.
• Each face must be 3 lines tall, even if the lines are empty. For 0, 1 you could not output this:

-----

  o

But you could output this:

-----

  o

Similarly, if you were outputting a list of two lists of lines, you could do [["", "", ""], ["", " o", ""]], but not [[""], [" o "]].

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Answer 1

Python 2, 101 97 92 68 64 bytes

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

Try it online!

Credits

• Reduced from 101 bytes to 92 by Mr. Xcoder
• Reduced from 92 bytes to 68 by Jonathan Allan (Dennis)
• Reduced from 68 bytes to 64 by totallyhuman

Answer 2

C (gcc), 252 242 269 262 241 235 220 bytes

I was on stack overflow for sockets in python, when this popped up, said why not? first code golf, so i'm not entirely sure if I followed the rules 100% (and if not and someone wants to steal my proverbial cookie and fix it, so be it). With 'o' and ' ', 255 245 272 265 244 238 228 bytes. replace +48 with *79+32.

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

Try it online!

How it works:
I use a bit shift and bitwise and to find if a spot should be clear or a pip, then offset the 0 or 1 to the correct ASCII value. it messes up on 4 and 5, so they needed some fixing. actually added a few bytes. was able to remove several bytes by removing a mask and just using 1 (doh)

Special thanks to Mr. Xcoder for the 7 less bytes by removing an excess #define
Changes: removed memset -21 bytes. redid the bit logic for 6, 4, 2 to depend on 8|4&2, 8|4, 8|4|2, respectively. -6 bytes. removed extra newlines by using puts instead of printf, which is also shorter. shortened the array to 11, removing extra assignment. -15 bytes. NOW I think that's the best I can do.

Answer 3

Jelly, 20 bytes

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

Try it online!

Alternate version, original output, 33 32 31 bytes

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

Thanks to @user202729 for golfing off 1 byte!

Try it online!

How it works

First, “¤o.ƤẸʠṚ’ – an integer literal in bijective base 250 – sets the return value to 1086123479729183.

Then, B¬ converts the return value to binary and takes the logical NOT of each digit, yielding the array

00001001000010110100101011110011101111101111100000

Next, s5ŒB splits that array into chunks of length 5, then bounces each chunk, turning abcde into abcdedcba, yielding

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Now, ị@ retrieves the j^th and k^th item of this array, where j, k is the program's first argument. Note that indexing is 1-based and modular, so the zeroth element is also the tenth.

Finally, s€3 splits each chunk of length nine into three chunks of length three.

Answer 4

Jelly, 13 bytes

⁽½ÑD<;ḂŒBs3µ€

Try it online!

Combining Dennis' idea of using ŒB (bounce) in this answer and Xcali's observation in this answer to get 13 bytes.

---

Jelly, 28 bytes

(with pretty printing)

Only now do I know that Jelly string literal is automatically terminated...

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

Try it online!

Answer 5

Perl 5, 107 76 70 + 1 (-a) = 70 bytes

Perl 5, 70 bytes

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

Try it online!

Uses 0 for whitespace and 1 for pips. Pretty simple method: observe that as the digit goes up, once a pip is "on", it never goes "off," except for the one in the middle. In the middle position, it is on for all odd numbers. Thus, for each position, it's a simple matter of checking if the digit is greater than the last digit for which it is off. The ||0 creates output when the condition is false. In Perl, false is undef which outputs as null.

Answer 6

PHP 155, 150 bytes

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

It takes an array of integers as the input. For testing:

d([1,2]);

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

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

Output Format:

---

 0 

---
  0

0  

Check it out live here

My Solution

For my solution I used a matrix consisting of bitwise numbers ( powers of 2 ). It can be visualized like this:

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

And then a storage array consisting of the bit positions for the pips of each domino correlated by the numbered index:

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

So just to clarify:

• example 0: index 0 or value 0 would be the blank domino, which is always false.
• example 1: index 1 or value 16 would be the number one domino and in the matrix that is in the center 16.
• example 2: index 2 or value 68 would be the number two domino and in the matrix that is top right 4 and bottom left 64 or 4|64
• example 3: index 5 or value 341 would be the number five domino and in the matrix that is 1|4|16|64|256
• example 4: index 9 or value 511 would be the number nine domino and in the matrix its the combination of all the bits.

Once that is established it's a fairly simple matter of looping for the 9 positions in the matrix, and setting $x to 2 to the power of $i

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

Then we do a bitwise And & as we iterate through those spots. So for examples sake will use example 2 from above and I will use x's instead spaces for sake of visual clarity:

• iteration 1, 68 & 1 ? 0 : 'x' which results in 'x'
• iteration 2, 68 & 2 ? 0 : 'x' which results in 'x'
• iteration 3, 68 & 4 ? 0 : 'x' which results in 0
• iteration 4, 68 & 8 ? 0 : 'x' which results in 'x'
• iteration 5, 68 & 16 ? 0 : 'x' which results in 'x'
• iteration 6, 68 & 32 ? 0 : 'x' which results in 'x'
• iteration 7, 68 & 64 ? 0 : 'x' which results in 0
• iteration 8, 68 & 128 ? 0 : 'x' which results in 'x'
• iteration 9, 68 & 256 ? 0 : 'x' which results in 'x'

When the loop is complete we wind up with this string "xx0xxx0xx".

Then we add the border "---xx0xxx0xx" to it ( I actually start with the border, but whatever).

And finally we chunk_split() it on 3's for:

---
xx0
xxx
0xx

Feel free to let me know what you think.

Answer 7

JavaScript (ES6), 79 78 bytes

Saved 1 byte thanks to @ETHproductions

Takes input in currying syntax (a)(b) and outputs a vertical ASCII domino.

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

Demo

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

---

Horizontal version, 80 79 bytes

Saved 1 byte thanks to @ETHproductions

Takes input as an array of 2 integers and outputs a horizontal ASCII domino.

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

Demo

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]))

Answer 8

APL (Dyalog), 25 bytes

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

Try it online!

-2 thanks to ngn.

The output format is a little bit weird: this function returns an array containing two shape-3,3 arrays each containing 0s and 1s.

Answer 9

C (gcc), 115 bytes

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

Try it online!

Answer 10

Javascript (ES6), 87 bytes

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>

Answer 11

Haskell - 88 characters

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

Takes a list of two numbers indicating the faces, returns a list of list of list of bool. Not that short but I find the solution interesting.

Answer 12

Pip, 32 27 24 21 bytes

^{-3 bytes thanks to @DLosc}

FcgP[Yc>_M3517c%2RVy]

Try it online!

Explanation:

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.

Answer 13

Charcoal, 46 44 43 39 bytes

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

Try it online! Link is to verbose version of code. Explanation:

ＥＥ²℅§@APQTUVW^_Ｎ

Read two integers and map them in the lookup table. Then map over the result. (This effectively captures the result in a temporary.)

  Ｅ⁹                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

The results are then implicitly printed on separate lines, with an extra blank line between each face because the results are nested.

Ｍ⁵↑⁵

Move up and draw the dividing line in between the faces.

Previous 43-byte horizontal version:

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

Try it online! Link is to verbose version of code. Explanation:

↶

Work vertically.

Ｐ³

Print the dividing line.

Ｍ⁷←

Position to the start of the first face.

ＦＥ²℅§@APQTUVW^_Ｎ

Read two integers and map them in the lookup table.

Ｆ⁹«

Prepare to output up to 9 os.

Ｆ¬﹪κ³⸿⸿

But start a new column every three os.

§ o÷ιＸ²↔⁻⁴κ

Convert the lower 5 bits of the ASCII code to binary, and then mirror the output for the remaining 4 os.

Answer 14

><>, 57+3 = 60 bytes

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

Try It Online. Outputs as a vertical domino with 1s for dots, 0s for whitespace and 9s for separators like so:

001
000
100
999
111
111
111

Technically this can be extended to up to 12 inputted values.

Old Version:

><>, 76+3 = 79 bytes

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

Try It Online. Outputs as a vertical domino with 1s for dots and 0s for whitespace like so:

001
000
100
---
111
111
111

Answer 15

Jelly, 16 bytes

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

Try it online!

Used Neil's strategy and base decompression to generate the values; outputs as a binary array. Takes a list as input.

Explanation:

Ç€
 € 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

Answer 16

APL+WIN, 49 47 bytes

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

Edited as per Adam's comment, thanks, to run with index origin zero.

Prompts for screen input as a vector of integers one for each face.

The output is of the form:

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

for an inputs of 7 3 and 0 5

Explanation:

(+\∊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 

Answer 17

C (gcc), 150 146 bytes

• Saved four bytes thanks to 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);}

Try it online!

Answer 18

Python 2, 121 bytes

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

Try it online!

Reduced to 121 using a lambda after going back and re-reading the rules. Now outputs a list of lines.

Previous version with nicely formatted output:

Python 2, 156 153 147 141 bytes

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

Try it online!

-3 with thanks to @NieDzejkob

Takes input as 2 integers and outputs in vertical format with 0=space and 1=dot.

Answer 19

Pyt, 220 154 bytes

Second attempt (154 bytes)

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↔ŕ↔ŕ↔

Explanation:

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

---

First attempt (220 bytes):

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ᴇ↔⁻łŕ↔ŕŕŕŕŕŕáƇǰ

Explanation:

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

Try it online!

Answer 20

05AB1E, 34 bytes

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

Try it online!

---

This was difficult because 05AB1E has bad padding.

---

Basic explanation:

• There are 4 significant patterns here which are 2, 4, 6 and 8.
• 3,5,7 and 9 are the other patterns plus 1.
• 1 is not significant due to symmetry, if the input is even, subtract 1 to toggle the middle bit.
• Toggling the LSB allows the middle bit to be flipped due to mirroring.

Answer 21

SmileBASIC, 92 69 bytes

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

Example:

? 7,2
111
010
111
777
001
000
100

This is what happens when your rules aren't strict enough.

Answer 22

FALSE, 116 80 78 70 69 66 63 61 59 58 bytes

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

still working on this...

Answer 23

Chip, 142 135 bytes

! 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

Try it online!

Input is a string of digits. Uses zeroes as the pips. Draws the pips for one number, reads next input byte. If no next byte, terminate, else draw the divider and go to start.

Each Z (or z) corresponds to one character of output, they are positioned to fire in order top to bottom. The capitalized A, B, C, and D correspond to the low four bits of the input (that's all we look at, so "34" == "CD" == "st" ...). The lowercase b, d, e, f correspond to various bits of the output.

Can make infinite-length dominoes too; try giving 0123456789 as input.

Answer 24

PHP, 116 bytes

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

requires PHP 5.5 or later. Run with -nr or try it online.