Herausforderung

Bei zwei Ziffern von 0 bis 9 als Eingabe wird ein Domino (aus der Gruppe der Doppel-Neun-Dominos ) mit dieser Anzahl von Pips (Punkten) auf den beiden Flächen ausgegeben . Die zehn möglichen Gesichter sehen so aus (durch Rohre getrennt):

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

Oder in getrennten Zeilen:

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

Eingabeformate

Sie können Eingaben in jedem vernünftigen Format vornehmen, einschließlich, aber nicht beschränkt auf:

• Zwei separate Ganzzahlen, Zeichenfolgen oder Singleton-Arrays.
• Eine einzelne ganze Zahl von 0 bis 99;
• Ein Array von zwei ganzen Zahlen;
• Eine zweistellige Zeichenfolge.

Ausgabeformate

• Die beiden Flächen können horizontal ausgerichtet sein und durch Rohre wie folgt voneinander getrennt sein:

    o|o   o
     |  o  
o    |o   o

• Oder sie sind vertikal ausgerichtet und durch Bindestriche wie folgt getrennt:

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

• Wenn Sie möchten, können Sie einen Rand um den Domino ausgeben.
• Sie können auch eine Liste von Linien, eine Liste der beiden Flächen oder eine Kombination davon ausgeben.
• Sie können für die Pips (die ich verwendet habe o) ein beliebiges Nicht-Leerzeichen verwenden .
• Wenn Sie es wirklich wünschen, können Sie bei der Ausgabe eines Arrays 0Whitespace und 1Pips verwenden oder False/ Trueoder das Äquivalent Ihrer Sprache.
• Sie können das Leerzeichen zwischen den Spalten entfernen. Dies ist eine gültige Ausgabe für 7, 7:

ooo|ooo
 o | o 
ooo|ooo

• Jedes der Gesichter kann um 90 Grad gedreht werden. Dies ist auch eine gültige Ausgabe für 7, 7:

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

• Sie können so viel / wenig führende / nachfolgende Leerzeichen verwenden, wie Sie möchten, solange der Hauptteil der Ausgabe noch den anderen Einschränkungen entspricht.
• Jedes Gesicht muss 3 Zeilen groß sein, auch wenn die Zeilen leer sind. Für 0, 1 konnte dies nicht ausgegeben werden:

-----

  o

Aber Sie könnten dies ausgeben:

-----

  o

Wenn Sie eine Liste mit zwei Zeilenlisten ausgeben, können Sie dies ebenfalls tun [["", "", ""], ["", " o", ""]], aber nicht [[""], [" o "]].

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache.

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]

Probieren Sie es online!

Credits

• Von Mr. Xcoder von 101 Byte auf 92 Byte reduziert
• Reduziert von 92 Byte auf 68 Byte von Jonathan Allan ( Dennis )
• Reduziert von 68 Bytes auf 64 Bytes von totalhuman

C (GCC) , 252 242 269 262 241 235 220 Bytes

Ich war auf Stapelüberlauf für Sockets in Python, als dies auftauchte, sagte, warum nicht? erster Code Golf, also bin ich mir nicht ganz sicher, ob ich die Regeln zu 100% befolgt habe (und wenn nicht und jemand mein sprichwörtliches Cookie stehlen und es reparieren möchte, soll es so sein). Mit 'o' und '' 255 245 272 265 244 238 228 Bytes. Ersetzen Sie +48 durch * 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);}}

Probieren Sie es online!

Wie es funktioniert:
Ich verwende ein bisschen Shift und bitweise und um herauszufinden, ob ein Punkt frei oder ein Pip sein soll, versetze die 0 oder 1 auf den korrekten ASCII-Wert. es bringt 4 und 5 durcheinander, so dass sie etwas repariert werden mussten. tatsächlich ein paar Bytes hinzugefügt. war in der Lage, mehrere Bytes durch Entfernen einer Maske und nur mit 1 (doh) zu entfernen

Besonderer Dank geht an Mr. Xcoder für die 7 Bytes weniger, die durch das Entfernen eines überzähligen #define
Changes: Memset -21 Bytes entfernt wurden. Die Bitlogik für 6, 4, 2 wurde so geändert, dass sie von 8 | 4 & 2, 8 | 4, 8 | 4 | 2 abhängt. -6 Bytes. Zusätzliche Zeilenumbrüche wurden entfernt, indem Puts anstelle von PrintF verwendet wurden, was ebenfalls kürzer ist. Das Array wurde auf 11 gekürzt, wodurch zusätzliche Zuweisungen entfernt wurden. -15 Bytes. JETZT denke ich, das ist das Beste, was ich tun kann.

Gelee , 20 Bytes

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

Probieren Sie es online!

Alternative Version, Originalausgabe, 33 32 31 Bytes

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

Vielen Dank an @ user202729 für das Golfen ab 1 Byte!

Probieren Sie es online!

Wie es funktioniert

Zunächst setzt “¤o.ƤẸʠṚ’- ein Ganzzahlliteral in der bijektiven Basis 250 - den Rückgabewert auf 1086123479729183 .

Dann B¬wandelt den Rückgabewert auf binär und nimmt den logischen NICHT jeder Ziffer, wodurch man das Array

00001001000010110100101011110011101111101111100000

Als nächstes s5ŒBteilt das Array in Stücke mit einer Länge von 5 , dann springt jeden Chunk, Drehen ABCDE in abcdedcba , wodurch man

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Ruft nun ị@das j- ^te und k- ^te Element dieses Arrays ab, wobei j, k das erste Argument des Programms ist. Beachten Sie, dass die Indizierung 1-basiert und modular ist, sodass das nullte Element auch das zehnte ist.

Zum Schluss wird s€3jeder Brocken mit der Länge neun in drei Brocken mit der Länge drei aufgeteilt.

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!

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.

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.

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

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.

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!

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>

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.

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.

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

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.

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

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 

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.

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!

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.

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.

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

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

still working on this...

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.

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.

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!