Códigos de barras de 4 estados

Muitos serviços postais (Royal Mail UK, Correio do Canadá, Correio dos EUA, etc.) usam um código de barras de quatro estados para codificar informações sobre seus e-mails. Renderizado em ASCII, pode ser algo como isto:

| | | | | | | | | |
| | | | | | | | | | | | | | | | |
    | | | | | | | |

Um código de barras de 4 estados é uma linha de barras. Cada barra pode ser estendida para cima, para baixo ou ambas, permitindo quatro possibilidades. Isso significa que cada barra representa essencialmente um dígito de base 4:

            | |
Bar: | | | |
                | |

Dígito: 0 1 2 3

O problema com esta simbologia é que cada código de barras é um código de barras diferente válido e de cabeça para baixo: alterando drasticamente o significado se a orientação estiver incorreta. Portanto, uma sequência de início e parada é normalmente implementada para que o scanner possa calcular de que maneira deve ser lido.

Para o objetivo deste desafio, usaremos a sequência de início / parada especificada pelo Australia Post: cada código de barras começa e termina com uma 1 0sequência.

O desafio

Sua tarefa é escrever um programa ou função que, dado um número inteiro positivo N, o converta em um código de barras ASCII de 4 estados, onde cada barra (exceto as seqüências de início / parada) representa um dígito na representação de base 4 de N.

Exemplo:

Dado o número inteiro 19623, primeiro o converteríamos em sua representação base-4 10302213,.

Em seguida, mapeamos cada dígito para a barra correspondente:

1 0 3 0 2 2 1 3

| | | |
| | | | | | | |
    | | | |

Por fim, adicionaríamos as seqüências de início / parada:

Inicio fim:
1 0 1 0

| | | | | |
| | | | | | | | | | | |
        | | | |

O código de barras resultante deve ser a saída do programa.

Regras:

• A entrada será um número inteiro positivo, dentro do intervalo do tamanho inteiro padrão do seu idioma.
• A saída:
  • Pode ser uma lista de linhas ou uma sequência contendo novas linhas.
  • Pode conter novas linhas / espaços iniciais ou finais, desde que a forma permaneça intacta.
  • Deve mostrar o código de barras com o formato acima - ele deve usar o caractere de barra vertical ( |) e o caractere de espaço ( ) ao desenhar barras, e deve haver 1 espaço entre cada barra vertical.
• Isso é código-golfe , então o programa mais curto (em bytes) vence!

Casos de teste

4095:

| | | | | | | |  
| | | | | | | | | |
    | | | | | |    

4096:

| | |  
| | | | | | | | | | |

7313145:

| | | | | | | | | |  
| | | | | | | | | | | | | | | |
      | | | | | | | |      

Python 3 , 103 99 96 bytes

def f(i,r=[]):
 while i:r=[' | |||||  ||'[i%4::4]]+r;i//=4
 k='|| ',' | ';[*map(print,*k,*r,*k)]

Experimente online!

MATL , 34 30 29 28 bytes

TFiK_YAyhhH&\EQE+t~vB!P'|'*c

Experimente online!

Explicação

TF      % Push array [1 0] (start sequence)
i       % Push input
K_YA    % Convert to base 4. Gives an array of 4-ary digits
y       % Duplicate from below: pushes [1 0] again (stop sequence)
hh      % Concatenate horizontally twice. Gives array of 4-ary digits
        % including start and stop sequences
H&\     % Two-output modulo 2: pushes array with remainders and array
        % with quotients of dividing by 2
EQE     % Times 2, plus 1, times 2, element-wise. This effectively
        % multiplies each entry by 4 and adds 2
+       % Add element-wise to the array of remainders. The stack now 
        % contains an array of numbers 2, 3, 6 or 7. Each number
        % encodes, in binary form, a column of the output. The
        % previous multiplication of the quotients by 4 will have the
        % effect of shifting one row down (one binary digit upwards),
        % to make room for the central row. The addition of 2 will
        % create the central row, which is always full
t~      % Duplicate, logical negate. Gives an array of zeros of the
        % same length
v       % Concatenate vertically into a 2-row matrix
B       % Convert to binary. Gives a matrix, where each row is the
        % binary representation of one of the numbers of the input
        % matrix, read in column-major order
!P      % Transpose, flip vertically
'|'*    % Multiply by '|'. This transforms 1 into 124 (ASCII code of
        % '|') and leaves 0 as is
c       % Convert to char. Char 0 is shown as space. Implicitly display

Geléia , 16 15 bytes

4;jƓb|ṃ⁾| ẎZṙ2G

Experimente online!

Como funciona

4;jƓb|ṃ⁾| ẎZṙ2G  Main link. No arguments.

4                Set the argument and the return value to 4.
 ;               Concatenate the return value with the argument, yielding [4, 4].
   Ɠ             Read an integer n from STDIN.
  j              Join, yielding [4, n, 4].
    b            Convert 4, n, and 4 to base 4. Note that 4 is [1, 0] in base 4.
     |           Perform bitwise OR of each resulting quaternary digit and 4.
                 This pads the binary representation of a digit d to three digits: 
                 [1, d:2, d%2]
      ṃ⁾|        Convert the results to base " |", i.e., binary where ' '
                 represents 0 and '|' represents 1.
          Ẏ      Concatenate the resulting arrays that correspond to 4, n, and 4.
           Z     Zip; transpose rows and columns.
            ṙ2   Rotate 2 units yo the left, correcting the order of [1, d:2, d%2]
                 to [d%2, 1, d:2].
              G  Grid; separate columns by spaces, rows by linefeeds.

Geléia , 19 bytes

;4⁺;b4Fd2Uj€1Zị⁾| G

Experimente online!

-1 graças ao Sr. Xcoder .

Oitava , 78 77 75 74 70 69 bytes

@(x)' |'(dec2bin([2 6 3 7;~(1:4)](:,[2 1 dec2base(x,4)-47 2 1]))-47)'

Experimente online!

Diferentemente da abordagem original, esta usa uma tabela de pesquisa simples para mapear os valores da base-4 em seu equivalente binário. A tabela de pesquisa também adiciona o espaçamento entre cada barra, adicionando um zero entre cada número (que é mapeado para uma barra de todos os espaços).

A tabela de pesquisa é mapeada diretamente para as barras como:

   base4:  0 1 2 3 -

  lookup:  2 6 3 7 0

  binary:  0 1 0 1 0
           1 1 1 1 0
           0 0 1 1 0

A conversão de binário para |e  agora é feita indexando em uma sequência desses dois caracteres - basicamente o mesmo princípio da tabela de pesquisa para conversão binária.

* Salvo 1 byte, obrigado @LuisMendo

Original:

@(x)['' circshift(dec2bin([a=[5 4 dec2base(x,4)-44 5 4];a*0](:))'*92,1)-4384]

Experimente online!

Função anônima que retorna o código de barras como uma string.

Isso se baseia no fato de que se adicionarmos 4 aos dígitos base4, poderemos representar barra / espaço pelo número convertido em binário com os bits 1 e 2 trocados:

   base4:  0 1 2 3

    add4:  4 5 6 7

  binary:  0 1 0 1
           0 0 1 1
           1 1 1 1

swap 2/1:  0 1 0 1
           1 1 1 1
           0 0 1 1

A parte complicada do ponto de vista do golfe é adicionar os espaços entre as barras e converter de 0/1para '|'/' '.

JavaScript (ES6), 89 87 83 bytes

n=>`|  ${(g=(a,k=n)=>k?g(a,k>>2)+(k&a?'| ':'  '):' ')(1)}|
| |${g(~0)}| |
   `+g(2)

Casos de teste

let f =

n=>`|  ${(g=(a,k=n)=>k?g(a,k>>2)+(k&a?'| ':'  '):' ')(1)}|
| |${g(~0)}| |
   `+g(2)

console.log(f(4095))
console.log(f(4096))
console.log(f(7313145))

Quão?

Nota : na versão abaixo, os literais de modelo foram substituídos por sequências padrão para que o código possa ser recuado corretamente.

n =>                        // given the input n
  '|  ' +                   // append the top leading pattern
  (g = (a,                  // g is a recursive function taking a = mask
           k = n) =>        // and using k = value, initially set to n
    k ?                     //   if k is not zero:
      g(a, k >> 2) +        //     do a recursive call for the next group of 2 bits
      (k & a ? '| ' : '  ') //     append '| ' if the bit is set or '  ' otherwise
    :                       //   else:
      ' '                   //     append an extra leading space and stop the recursion
  )(1) +                    // invoke g() with mask = 0b01
  '|\n' +                   // append the top leading pattern and a linefeed
  '| |' +                   // append the middle leading pattern
  g(~0) +                   // invoke g() with all bits set in the mask
  '| |\n' +                 // append the middle trailing pattern and a linefeed
  '   ' +                   // append the bottom leading pattern
  g(2)                      // invoke g() with mask = 0b10

R , 154 109 bytes

function(n,d=c(1,0,n%/%4^floor(log(n,4):0)%%4,1,0),o=c(" ","|"))cat("",o[1+d%%2],"
",o[2+0*d],"
",o[1+(d>1)])

Experimente online!

Salvou um monte de bytes indexando e usando cat vez de construir uma matriz e usando write, além de 6 de uma conversão ligeiramente diferente para a base 4. Imprime com um espaço à esquerda em cada linha e sem novas linhas à direita.

A indexação ocorre usando alguma aritmética modular, não diferente de outras respostas, mas como R usa a indexação baseada em 1, a aritmética é um pouco diferente.

Explicação:

function(n,
 d=c(1,0,                         # d contains the padding and 
   n%/%4^floor(log(n,4):0)%%4,   # the base 4 digits
   1,0),                         # 
 o=c("|"," ")                    # the vector to index into
 cat("",                         # cat separates things with spaces by default
                                 # so the empty string will print a leading space
  o[1+d%%2],"                    # odds have a | above
",                               # literal newline, a space will follow it (hence leading spaces)
 o[2+0*d],"                      # array of 2s since the middle is always |
",                               # another literal newline
 o[1+(d>1)])                     # digits greater than 1 have a | below

Carvão , 50 bytes

ＮθＦ²⊞υι¿θＷθ«⊞υ﹪θ⁴≧÷⁴θ»⊞υθＦ²⊞υιＥ⟦ |¦|¦  ||⟧⪫Ｅ⮌υ§ιλω

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

Ｎθ

Digite um número.

Ｆ²⊞υι

Empurre a sequência de parada para a lista vazia predefinida.

¿θ

Se o número for positivo,

  Ｗθ«⊞υ﹪θ⁴≧÷⁴θ»

aplique repetidamente o divmod para convertê-lo na base reversa 4,

  ⊞υθ

caso contrário, basta empurrá-lo.

Ｆ²⊞υι

Empurre a sequência inicial para a lista.

Ｅ⟦ |¦|¦  ||⟧

Mapeie mais de três strings. Cada sequência representa a tradução do código de barras para os dígitos0123 de cada linha.

⪫Ｅ⮌υ§ιλω

Mapeie os dígitos (revertidos para a ordem usual), converta-os em barras ou espaços usando a tradução e junte os resultados em três cadeias que são impressas implicitamente em linhas separadas.

Japonês , 32 31 bytes

A¤i2Us4)¬®n s|iS)ù2 w i|1ÃqR² y

Teste online!

Ainda não estou satisfeito com isso, mas é um começo ...

Explicação

A¤  i2Us4)¬ ®   n s |iS)ù2 w i |1Ã qR²  y
As2 i2Us4)q mZ{Zn s'|iS)ù2 w i'|1} qRp2 y
                                           Implicit: U = input, A = 10, R = newline, S = space
As2                                        Convert 10 to a binary string.
    i2   )                                 At index 2, insert
      Us4                                    the input converted to base 4.
          q                                Split into chars.
            mZ{                  }         Map each char Z to
               Zn                            Z converted to a number,
                  s'|iS)                     converted to base " |" (binary using ' ' as 0 and '|' as 1),
                        ù2                   left-padded to length 2 with spaces,
                           w                 reversed,
                             i'|1            with another pipe inserted at index 1.
                                   q       Join the resulting list on
                                    Rp2      a newline repeated twice (adds in blank columns).
                                        y  Transpose the entire string.
                                           Implicit: output result of last expression

Haskell , 91 90 bytes

h s=[do a<-4%s++0%0;x!!a:" "|x<-[" | |","||||","  ||"]]
_%0=[1,0]
b%n=b%div n b++[mod n b]

Experimente online!Retorna uma lista de linhas.

Alternativa de contagem de mesmos bytes para a primeira linha:

h s=[do a<-4%s++0%0;" | |  ||||"!!(x+a):" "|x<-[0,6,4]]

J , 57 49 47 bytes

10 bytes graças ao FrownyFrog!

[:,.2{."0[:|:' |'{~#:@2 6 3 7{~1 0,4&#.inv,1,0:

Como funciona:

1 0,4&#.inv,1,0: - converte o número em uma lista de dígitos da base 4, adiciona 1 0 ao início e ao final da lista

((#:2 6 3 7){' |') - tabela de pesquisa para a criptografia, o binário 0 corresponde ao espaço, 1 a '|'

{~ - criptografa o dígito base 4, selecionando uma string da tabela de pesquisa acima (argumento invertido)

|: - transpõe a matriz resultante de 3 colunas para 3 linhas

[: - tampe o garfo

,.2{."0 - coloca espaços entre as barras

Experimente online!

APL + WIN, 63 bytes

(⍉5 3⍴' | ||  |||||   ')[;,⍉(2 1,(1+((⌈4⍟n)⍴4)⊤n←⎕),2 1),[.1]5]

Explicação:

(⍉5 3⍴' | ||  |||||   ') create a matrix where columns represent bars plus one for separator spaces

(1+((⌈4⍟n)⍴4)⊤n←⎕) prompt for screen input and convert to base 4 and add 1 to convert to index origin 1

2 1,...,2 1 concatenate start stop

,[.1]5 concatenate separator space indices

(.....)[.....] index into bar matrix to display

Python 2 , 116 114 bytes

^{-2 bytes graças a notjagan}

c=a=0,1
n=input()
while n:c+=n%4,;n/=4
for l in zip(*[' |'[n%2]+'|'+' |'[n/2]for n in c+a][::-1]):print' '.join(l)

Experimente online!

05AB1E , 19 bytes

4BT.øS4~bT„| ‡øÁ€S»

Experimente online!

Essa é uma meia porta da abordagem de Dennis, que é apenas um byte menor que o método que eu usei antes (com o qual estou muito feliz):

05AB1E , 20 bytes

4BT.øS2‰í1ýøT„| ‡€S»

Experimente online!

Como funciona?

4BT.øS2 ‰ í1ýøT „| ‡ S »| Programa completo. Pega a entrada de STDIN, sai para STDOUT.

4B Converta para a base 4.
  T Empurre um 10 para a pilha.
   .ø Surrond (adicione e acrescente o 10 à representação de base 4).
     S Divida em caracteres / dígitos individuais.
                      + ------------------------------------------------- --------------
                      | Esta parte costumava ser ø4.ø4º na versão anterior, que
                      | significa: surround com 4's, converta cada um na base 4 (4 -> [1, 0])
                      | e, finalmente, aplainar profundamente a lista.
                      + ------------------------------------------------- --------------
      2 ‰ Divmod 2 ([N // 2, N% 2]).
        í Reverso (elemento a elemento).
         1ý Adicione 1 no meio (em elementos).
           ø Transpor.
            T ‡ Traduzir (‡) de "10" (T) para "|" („|).
                 S »| Formate como uma grade.
                 € S | Empurre os caracteres de cada um.
                   » Associe-se por novas linhas, enquanto associa listas internas por espaços.

Perguntei a Adnan (o criador do 05AB1E) sobre o grid no chat , e eles me ajudaram a economizar 2 bytes, apontando um recurso do 05AB1E: ao ingressar em listas multi-dimensionais por novas linhas, as listas internas também são unidas por espaços , então ðýé desnecessário.

APL (Dyalog Classic) , 33 bytes

' |'[≠\2/2⊖1⍪2 2⊤1 0(,,⊣)4⊥⍣¯1⊢⎕]

Experimente online!

J , 42 40 39 bytes

' |'{~[:#:4#.2|.0|:4#:@+1 0(,,[)4#.inv]

Raspou 2 bytes graças a Dennis. 1 byte graças a ngn.

Experimente online!

Como funciona

                                4#.inv]      to base 4
                        1 0(,,[)             append (1 0) on both sides
                   4#:@+                     add 4 to each digit and convert to binary
                0|:                          transpose
             2|.                             rotate the rows
      [:#:4#.             from base 4 to base 2, it's supposed to separate the columns
' |'{~                                       to characters

JavaScript (ES6) 79 bytes

Usa .toString para converter o número em base 4 e, em seguida, consulta com cada linha e OR bit a bit para criar a linha de saída por linha. Produz uma lista de linhas.

n=>[2,3,1].map(d=>[...'10'+n.toString(4)+'10'].map(q=>(q|d)>2?"|":" ").join` `)

f = n=>[2,3,1].map(d=>[...'10'+n.toString(4)+'10'].map(q=>(q|d)>2?"|":" ").join` `)

console.log(f(19623))
console.log(f(4095))
console.log(f(4096))
console.log(f(7313145))

Bash + coreutils, 71 67 bytes

dc -e4ddon?np|sed 's/./& /g;h;y/01/23/;G;y/12/21/;H;x;y/0123/ | |/'

Experimente online!

Explicação

O dcbit se converte na base 4, acrescentando e anexando com um 4(transforma-se 10na saída) e usando npara manter tudo em uma linha.

O resto acontece em sed:

s/./& /g;     Add a space after each digit
h;            Make a copy in hold space
y/01/23/;     Prepare up the second row (2/3 will turn to pipes)
G;y/12/21/;   Append what will be the third row and prep it (1/3 will turn to pipes)
H;x;          Prepend hold space
y/0123/ | |/  Make 1 and 3 pipes, 0 and 2 spaces

Retina , 83 bytes

.+
$*
+`(1+)\1{3}
${1};
^
1;;
$
;1;;
1*;
$.&
.+
$&¶$&¶$&
T`13` `^.+
T`12` `.+$
\d
|

Experimente online! O link inclui os casos de teste mais rápidos. Explicação:

.+
$*

Converta para unário.

+`(1+)\1{3}
${1};

Converta na base 4 como números unários separados por ;s.

^
1;;

Anexe a sequência inicial.

$
;1;;

Acrescente a ;, transformando-o em um terminador de dígitos, em vez de um separador, e a sequência de parada.

1*;
$.&

Converta em decimal, mas adicionando 1 a cada dígito.

.+
$&¶$&¶$&

Triplicar isso.

T`13` `^.+

Na primeira linha, 1s e 3s (representando 0s e2 s) tornam-se espaços.

T`12` `.+$

Na última linha, 1s e 2s (representando 0s e 1s) tornam-se espaços.

\d
|

Todos os outros dígitos se tornam barras.

Pip , 33 31 29 27 26 bytes

25 bytes de código, +1 para -Ssinalizador.

Y^aTB4WRt" |"@[y%2oMyy/2]

Experimente online!

Explicação

Observamos um padrão nos quatro tipos de barra:

• A primeira linha é um espaço se o dígito for par, e o canal será ímpar.
• A segunda linha é sempre um cano.
• A terceira linha é um espaço se o dígito for 0 ou 1, canalizar se 2 ou 3.

Tão:

                           a is cmdline arg; o is 1; t is 10 (implicit)
  aTB4                     Convert a to base 4
      WRt                  Wrap it before and after with 10
 ^                         Split into a list of digits
Y                          and yank into y
              [         ]  List of:
               y%2          0 if even, 1 if odd for each item in y
                  oMy       1 mapped to y, i.e. constant 1 for each item in y
                     y/2    Each item in y divided by 2 (0, 0.5, 1, or 1.5)
         " |"@             Use the elements of that list as indices into this string
                           Note that indices are truncated to integers!
                           Autoprint, separating rows with newline and elements of
                           each row with space (-S flag)

SOGL V0.12 , 28 bytes

4─10¹:h++{»1F2%¹{Ƨ| W}¹∑ā}⁰H

Experimente aqui!

C (gcc) , 176 bytes

#include<stdio.h>
int n,m;f(n,r){if(n)f(n>>2);printf("%c%c",n?32:10,(n&r||!r)&&n?'|':32);}main(){scanf("%d",&n);m=(n+(4<<(32-__builtin_clz(n)/2*2)))*16+4;f(m,1);f(m,0);f(m,2);}

Experimente online!

Um pouco menos terrivelmente formatado (menos golfe):

#include<stdio.h>
int n,m;
f(n,r) {
    if(n)
        f(n>>2);
    printf("%c%c",n?32:10,(n&r||!r)&&n?'|':32);
}

main() {
    scanf("%d",&n);
    m=(n+(4<<2*(16-__builtin_clz(n)/2)))*16+4;
    f(m,1);
    f(m,0);
    f(m,2);
}

Explicação

Primeiro, considere o código a seguir para ler um número inteiro e gerar a versão base 4:

#include <stdio.h>
int n;
f(n) {if(n)printf("%d\n",n&3,f(n>>2));}
main(){scanf("%d",&n);f(n);}

Isso usa a recursão de cauda para reverter a ordem da saída. Cada passo recursivo muda de bits em 2 (corta os últimos 2 bits e divide em 4). Ele gera o resultado com máscara de bits com 3 (0b11), que mostra apenas os dois últimos bits, que é a última base de dígitos 4.

A chamada de função é incluída no printfargumento como final (não é impressa, mas é avaliada) para evitar a necessidade de usar {} (+2 bytes) para agrupar oprintf chamada de função e.

A solução aqui estende esse código base-4. Primeiro, m é definido como n, mas tal que na base 4 ele terá 10 anexados e anexados a ele. Em seguida, imprimimos m.

Na impressão base 4 regularmente, usamos uma máscara de bit 3 para obter o dígito. No código de correio, a linha superior é o bit de ordem inferior desse dígito (uma máscara de bit 1) e a linha inferior é o bit de ordem superior (uma máscara de bit 2). Consequentemente, o rin f(n,r)é a máscara de bits - nossa principal função exige f(m,1)a primeira linha ef(m,2) a última linha.

Para fazer a linha do meio funcionar (sempre imprima "|"), adicionamos ||!rà condicional - se r for 0, ela sempre será avaliada como verdadeira e imprimirá uma "|". Então chamamos f(m,0)a linha do meio.

Finalmente, queremos que as novas linhas se comportem. Incluir um extra printfé caro no que diz respeito a bytes de código-fonte; portanto, adicionamos outro especificador% c ao existente printf. n?32:10imprime uma nova linha se n for 0 (falso) e um espaço caso contrário. 32 e 10 são usados ​​em vez de '\ n' e '' para salvar bytes.

Lisp comum, 191 bytes

(lambda(n &aux(k`(1 0,@((lambda(n &aux r f)(do()((= n 0)f)(setf(values n r)(floor n 4))(push r f)))n)1 0)))(format t"~3{~{~:[  ~;| ~]~}~%~}"`(,(mapcar'oddp k),k,(mapcar(lambda(c)(> c 1))k))))

Experimente online!

PHP, 99 + 1 bytes

for($n=10 .base_convert($argn,10,4). 104;(~$c=$n[$i++])||3>$y+=$i=1;)echo" | ||  |||||

"[$c*3+$y];

requer PHP> = 5.5 para indexação literal de cadeias e <7.1 para que a indexação não produza um aviso.

Executar como tubo com -nRou experimente online .

Insira mais uma nova linha para obter uma à direita.

Python 2, 142 126 bytes

B=lambda n:n<4and`n`or B(n/4)+`n%4`
def F(i):
 for r in 0,1,2:print' '.join(" |"[(int(x)%2,1,x>'1')[r]]for x in'10'+B(i)+'10') 

Muito obrigado aos ovs!

Tentei não copiar os métodos das outras respostas e ... eca.

C # (.NET Core) , 160 bytes

i=>{string s=$"10{B(i)}10",a="";for(int y=0;y<3;y++,a+="\n")foreach(var t in s)a+=t<51&y!=1&t-(y>>1)!=49?"  ":"| ";return a;string B(int n)=>n>0?B(n/4)+n%4:"";}

Experimente online!

Tenho certeza de que perdi algumas melhorias.

DeGolfed

i=>{
    string s = $"10{B(i)}10", // prepend and append 10 to the base 4 number
           a="";

    for (int y=0; y<3; y++, a+="\n") // go through each row
        foreach (var t in s)         // go through each char digit
            a += t<51 & y != 1 & t-(y>>1) != 49 ? "  " : "| "; // check if bar or space occurs

    return a;

    string B(int n) => n>0? B(n/4) + n%4 : ""; // convert int to base 4
}

t<51 & y != 1 & t-(y>>1) != 49 verifica se o caractere não é '3', não a segunda linha e, em seguida, alguma mágica binária para ver se a primeira ou a terceira linha deve conter o espaço.

Zsh , 156 154 151 133 bytes

y(){for i (${(s//)$(echo 10$(([##4]x))10)});printf "$a[(i+1)] ";echo};a=(' ' '|' ' ' '|');y;a[1]='|';a[3]='|';y;a=(' ' ' ' '|' '|');y

Experimente online!

Obtém a entrada da base 10 do var $x

Japonês , 42 bytes

s4 +A iA)d1"|| "0" | "2" ||"3'|³ ò3 miR ·y

Experimente online!

Pitão , 32 bytes

jjL;CmXX1jk_d1`T"| ".DR2sj[4Q4)4

Experimente aqui!

C, 120 bytes

Infelizmente, só funciona no Windows, pois itoaé muito conveniente para ser padrão.

char*p,s[21]="10";g(a){for(p=s;*p;)printf(!a|*p++&a?" |":"  ");puts(p);}f(n){strcat(itoa(n,s+2,4),"10");g(1);g(0);g(2);}