Desafio

Dados dois dígitos de 0 a 9 como entrada, produza um dominó (do conjunto de nove dominós ) com esse número de pips (pontos) nas duas faces. As dez faces possíveis são assim (separadas por tubos):

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

Ou em linhas separadas:

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

Formatos de entrada

Você pode receber informações em qualquer formato razoável, incluindo, entre outros:

• Dois inteiros, cadeias de caracteres ou matrizes singleton separadas;
• Um único número inteiro de 0 a 99;
• Uma matriz de dois números inteiros;
• Uma sequência de dois dígitos.

Formatos de saída

• As duas faces podem estar alinhadas horizontalmente, separadas por tubos da seguinte maneira:

    o|o   o
     |  o  
o    |o   o

• Ou eles podem estar alinhados verticalmente, separados por hífens da seguinte forma:

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

• Você pode enviar uma borda ao redor do dominó, se desejar.
• Você também pode optar por imprimir uma lista de linhas, uma lista das duas faces ou uma combinação delas.
• Você pode usar qualquer caractere que não seja um espaço em branco para os pips (eu usei o).
• Se você realmente deseja, pode usar 0para espaço em branco e 1para os pips, ou False/ True(ou o equivalente do seu idioma) se estiver produzindo uma matriz.
• Você pode remover o espaço em branco entre as colunas; esta é uma saída válida para 7, 7:

ooo|ooo
 o | o 
ooo|ooo

• Qualquer uma das faces pode ser girada em 90 graus. Essa também é uma saída válida para 7, 7:

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

• Você pode ter o espaço em branco inicial / final desejado, contanto que a parte principal da saída ainda se enquadre nas outras restrições.
• Cada face deve ter 3 linhas de altura, mesmo se as linhas estiverem vazias. Para 0, 1, você não pode emitir isso:

-----

  o

Mas você pode gerar isso:

-----

  o

Da mesma forma, se você estivesse produzindo uma lista de duas listas de linhas, poderia fazer [["", "", ""], ["", " o", ""]], mas não [[""], [" o "]].

Pontuação

Isso é código-golfe , então o código mais curto em bytes em cada idioma vence.

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]

Experimente online!

Créditos

• Reduzido de 101 bytes para 92 pelo Sr. Xcoder
• Reduzido de 92 bytes para 68 por Jonathan Allan ( Dennis )
• Reduzido de 68 bytes para 64 por totallyhuman

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

Eu estava no estouro de pilha para soquetes em python, quando isso apareceu, disse por que não? primeiro código de golfe, então não tenho certeza se segui as regras 100% (e se não, e alguém quer roubar meu proverbial cookie e corrigi-lo, que assim seja). Com 'o' e '', 255 245 272 265 244 238 228 bytes. substitua +48 por * 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);}}

Experimente online!

Como funciona:
eu uso um deslocamento de bits e bit a bit e para descobrir se um ponto deve ser limpo ou um pip, depois desloque o 0 ou 1 para o valor ASCII correto. ele estraga em 4 e 5, então eles precisavam de alguma correção. realmente adicionou alguns bytes. conseguiu remover vários bytes removendo uma máscara e usando apenas 1 (doh)

Agradecimentos especiais ao Sr. Xcoder pelos menos 7 bytes removendo um excesso de #define
Changes: removeu o memset -21 bytes. refez a lógica do bit para 6, 4, 2 para depender de 8 | 4 e 2, 8 | 4, 8 | 4 | 2, respectivamente. -6 bytes. removeu novas linhas extras usando put em vez de printf, que também é mais curto. reduziu a matriz para 11, removendo a atribuição extra. -15 bytes. Agora acho que é o melhor que posso fazer.

Gelatina , 20 bytes

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

Experimente online!

Versão alternativa, saída original, 33 32 31 bytes

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

Graças a @ user202729 por jogar fora 1 byte!

Experimente online!

Como funciona

Primeiro, “¤o.ƤẸʠṚ’- um literal inteiro na base bijetiva 250 - define o valor de retorno para 1086123479729183 .

Em seguida, B¬converte o valor de retorno em binário e pega o NOT lógico de cada dígito, produzindo a matriz

00001001000010110100101011110011101111101111100000

Em seguida, s5ŒBdivide essa matriz em pedaços de comprimento 5 e depois salta cada pedaço, transformando abcde em abcdedcba , produzindo

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

Agora, ị@recupera o j ^th e k ^th item desse array, onde j, k é o primeiro argumento do programa. Observe que a indexação é baseada em 1 e modular, portanto, o elemento zeroth também é o décimo.

Finalmente, s€3divide cada pedaço de comprimento nove em três pedaços de comprimento três.

Gelatina , 13 bytes

⁽½ÑD<;ḂŒBs3µ€

Experimente online!

Combinando a idéia de Dennis de usar ŒB(rejeição) nesta resposta e a observação de Xcali nesta resposta para obter 13 bytes.

Gelatina , 28 bytes

(com impressão bonita)

Só agora eu sei que o literal da string Jelly é automaticamente encerrado ...

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

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

É preciso uma matriz de números inteiros como entrada. Para teste:

d([1,2]);

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

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

Formato de saída:

---

 0 

---
  0

0  

Confira ao vivo aqui

Minha solução

Para minha solução, usei uma matriz composta por números bit a bit (potências de 2). Pode ser visualizado assim:

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

E, em seguida, uma matriz de armazenamento que consiste nas posições de bits dos pips de cada dominó correlacionados pelo índice numerado:

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

Então, só para esclarecer:

• exemplo 0: índice 0ou valor 0seria o dominó em branco, que é sempre falso.
• exemplo 1: índice 1ou valor 16seria o dominó número um e na matriz que está no centro16 .
• exemplo 2: índice 2ou valor 68seria o dominó número dois e na matriz que é superior direita 4e inferior esquerda 64 ou4|64
• exemplo 3: índice 5ou valor 341seria o dominó número cinco e na matriz que é1|4|16|64|256
• exemplo 4: índice 9ou valor 511seria o número nove no dominó e na matriz é a combinação de todos os bits.

Uma vez estabelecido, é uma questão bastante simples de fazer um loop para as 9 posições na matriz e definir $x a 2ao poder de$i

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

Então fazemos um pouco e &, ao percorrermos esses pontos. Portanto, para exemplos, o sake usará o exemplo 2 acima e, em xvez disso, utilizarei os espaços para maior clareza visual:

• iteração 1, 68 & 1 ? 0 : 'x'que resulta em'x'
• iteração 2, 68 & 2 ? 0 : 'x'que resulta em'x'
• iteração 3, 68 & 4 ? 0 : 'x'que resulta em0
• iteração 4, 68 & 8 ? 0 : 'x' que resulta em'x'
• iteração 5, 68 & 16 ? 0 : 'x' que resulta em'x'
• iteração 6, 68 & 32 ? 0 : 'x' que resulta em'x'
• iteração 7, 68 & 64 ? 0 : 'x' que resulta em0
• iteração 8, 68 & 128 ? 0 : 'x' que resulta em'x'
• iteração 9, 68 & 256 ? 0 : 'x'que resulta em'x'

Quando o loop está completo, terminamos com essa string "xx0xxx0xx" .

Em seguida, adicionar o limite "---xx0xxx0xx"para ele (eu realmente começar com a fronteira, mas qualquer que seja) .

E finalmente nós chunk_split () em 3's para:

---
xx0
xxx
0xx

Sinta-se livre para me falar o que você pensa.

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

Experimente online!

Usa 0 para espaços em branco e 1 para pips. Método bastante simples: observe que, à medida que o dígito sobe, uma vez que um pip está "ligado", ele nunca "apaga", exceto o do meio. Na posição do meio, está ativado para todos os números ímpares. Assim, para cada posição, é simples verificar se o dígito é maior que o último dígito para o qual está desativado. A ||0saída cria quando a condição é falsa. No Perl, false é o undefresultado que é nulo.

JavaScript (ES6), 79 78 bytes

Guardado 1 byte graças a @ETHproductions

Recebe entrada na sintaxe de curry (a)(b)e gera um dominó ASCII vertical.

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

Versão horizontal, 80 79 bytes

Guardado 1 byte graças a @ETHproductions

Recebe a entrada como uma matriz de 2 números inteiros e gera um dominó ASCII horizontal.

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¨

Experimente online!

-2 graças a ngn .

O formato de saída é um pouco estranho: essa função retorna uma matriz contendo duas matrizes de formato 3,3, cada uma contendo 0s e 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);}

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

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

Pega uma lista de dois números indicando as faces, retorna uma lista de lista de lista de bool. Não é tão curto, mas acho a solução interessante.

Pip , 32 27 24 21 bytes

^{-3 bytes graças a @DLosc}

FcgP[Yc>_M3517c%2RVy]

Experimente online!

Explicação:

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

Experimente Online . Saídas como dominó vertical com 1s para pontos, 0s para espaço em branco e 9s para separadores da seguinte forma:

001
000
100
999
111
111
111

Tecnicamente, isso pode ser estendido para até 12 valores introduzidos.

Versão antiga:

> <> , 76 + 3 = 79 bytes

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

Experimente Online . Saídas como um dominó vertical com 1s para pontos e 0s para espaço em branco da seguinte maneira:

001
000
100
---
111
111
111

Carvão , 46 44 43 39 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

ＥＥ²℅§@APQTUVW^_Ｎ

Leia dois números inteiros e mapeie-os na tabela de pesquisa. Em seguida, mapeie o resultado. (Isso efetivamente captura o resultado de forma temporária.)

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

Os resultados são impressos implicitamente em linhas separadas, com uma linha em branco extra entre cada face, porque os resultados estão aninhados.

Ｍ⁵↑⁵

Mova para cima e desenhe a linha divisória entre as faces.

Versão horizontal anterior de 43 bytes:

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

Experimente online! Link é a versão detalhada do código. Explicação:

↶

Trabalhe verticalmente.

Ｐ³

Imprima a linha divisória.

Ｍ⁷←

Posição para o início da primeira face.

ＦＥ²℅§@APQTUVW^_Ｎ

Leia dois números inteiros e mapeie-os na tabela de pesquisa.

Ｆ⁹«

Prepare para produzir até 9 os.

Ｆ¬﹪κ³⸿⸿

Mas comece uma nova coluna a cada três osegundos.

§ o÷ιＸ²↔⁻⁴κ

Converta os 5 bits inferiores do código ASCII em binário e espelhe a saída pelos 4 os restantes .

Gelatina , 16 bytes

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

Experimente online!

Usava estratégia de Neil e a descompressão de base para gerar os valores; saídas como uma matriz binária. Leva uma lista como entrada.

Explicação:

Ç€
 € 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)[⎕]

Editado de acordo com o comentário de Adam, obrigado, para ser executado com a origem zero do índice.

Solicita a entrada na tela como um vetor de números inteiros um para cada face.

A saída é da forma:

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

para uma entrada de 7 3 e0 5

Explicação:

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

Experimente online!

Reduzido para 121 usando um lambda depois de voltar e reler as regras. Agora gera uma lista de linhas.

Versão anterior com saída bem formatada:

Python 2 , 156 153 147 141 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

Experimente online!

-3 com graças a @NieDzejkob

Recebe a entrada como 2 números inteiros e as saídas no formato vertical com 0 = espaço e 1 = ponto.

Pyt , 220 154 bytes

Segunda tentativa (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↔ŕ↔ŕ↔

Explicação:

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

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

Explicação:

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

Experimente online!

05AB1E , 34 bytes

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

Experimente online!

Isso foi difícil porque 05AB1E tem preenchimento ruim.

Explicação básica:

• Existem 4 padrões significativos aqui, que são 2, 4, 6 e 8.
• 3,5,7 e 9 são os outros padrões mais 1.
• 1 não é significativo devido à simetria; se a entrada for par, subtraia 1 para alternar o bit do meio.
• Alternar o LSB permite que o bit do meio seja invertido devido ao espelhamento.

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

Exemplo:

? 7,2
111
010
111
777
001
000
100

É o que acontece quando suas regras não são suficientemente rígidas.

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

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

ainda trabalhando nisso ...

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

Experimente online!

Entrada é uma sequência de dígitos. Usa zeros como os pips. Desenha os pips para um número, lê o próximo byte de entrada. Se nenhum próximo byte terminar, desenhe o divisor e comece.

Cada Z(ou z) corresponde a um caractere de saída, eles são posicionados para disparar na ordem de cima para baixo. O capitalizado A, B, C, e Dcorrespondem aos baixos quatro bits de entrada (que é tudo o que olhar, de modo "34" == "CD" == "st" ...). A minúsculab , d, e, fcorrespondem a vários bits de saída.

Também pode fazer dominós de comprimento infinito; tente dar 0123456789como entrada.

PHP, 116 bytes

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

requer PHP 5.5 ou posterior. Corra com -nrou experimente online .

C (gcc) , 150 146 bytes

• Economizou quatro bytes graças ao 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);}

Experimente online!