Códigos de barras de 4 estados

Muchos servicios postales (Royal Mail UK, Canada Post, US Mail, etc.) utilizan un código de barras de 4 estados para codificar información sobre su correo. Representado en ASCII, puede verse más o menos así:

El | El | El | El | El | El | El | El | El | El |
El | El | El | El | El | El | El | El | El | El | El | El | El | El | El | El | El |
    El | El | El | El | El | El | El | El |

Un código de barras de 4 estados es una fila de barras. Cada barra se puede extender hacia arriba, hacia abajo o ambas, permitiendo 4 posibilidades. Esto significa que cada barra representa esencialmente una base de 4 dígitos:

            El | El |
Bar: | El | El | El |
                El | El |

Dígito: 0 1 2 3

El problema con esta simbología es que cada código de barras es un código de barras válido y diferente al revés: cambiando drásticamente el significado si la orientación es incorrecta. Por lo tanto, normalmente se implementa una secuencia de inicio y parada para que el escáner pueda calcular de qué manera se supone que debe leerse.

Para el propósito de este desafío, utilizaremos la secuencia de inicio / parada especificada por Australia Post: cada código de barras comienza y termina con una 1 0secuencia.

El reto

Su tarea es escribir un programa o función que, dado un entero positivo N, lo convierta en un código de barras ASCII de 4 estados, donde cada barra (excepto las secuencias de inicio / parada) representa un dígito en la representación de base 4 N.

Ejemplo:

Dado el número entero 19623, tendríamos primero convertirlo a su representación de base 4, 10302213.

Luego mapearíamos cada dígito a la barra correspondiente:

1 0 3 0 2 2 1 3

El | El | El | El |
El | El | El | El | El | El | El | El |
    El | El | El | El |

Finalmente, agregaríamos las secuencias de inicio / parada:

Inicio fin:
1 0 1 0

El | El | El | El | El | El |
El | El | El | El | El | El | El | El | El | El | El | El |
        El | El | El | El |

El código de barras resultante debe ser la salida del programa.

Reglas:

• La entrada será un número entero positivo, dentro del rango del tamaño entero estándar de su idioma.
• La salida:
  • Puede ser una lista de líneas o una cadena que contiene nuevas líneas.
  • Puede contener líneas / espacios iniciales o finales, siempre que la forma permanezca intacta.
  • Debe mostrar el código de barras con el formato anterior: debe usar el carácter de tubería ( |) y el carácter de espacio ( ) al dibujar barras, y debe haber 1 espacio entre cada barra vertical.
• Este es el código de golf , por lo que gana el programa más corto (en bytes).

Casos de prueba

4095:

El | El | El | El | El | El | El | El |  
El | El | El | El | El | El | El | El | El | El |
    El | El | El | El | El | El |    

4096:

El | El | El |  
El | El | El | El | El | El | El | El | El | El | El |

7313145:

El | El | El | El | El | El | El | El | El | El |  
El | El | El | El | El | El | El | El | El | El | El | El | El | El | El | El |
      El | El | El | El | El | El | El | El |      

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

Pruébalo en línea!

MATL , 34 30 29 28 bytes

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

Pruébalo en línea!

Explicación

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

Jalea , 16 15 bytes

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

Pruébalo en línea!

Cómo 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.

Jalea , 19 bytes

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

Pruébalo en línea!

-1 gracias al Sr. Xcoder .

Octava , 78 77 75 74 70 69 bytes

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

Pruébalo en línea!

A diferencia del enfoque original, este utiliza una tabla de búsqueda simple para mapear los valores de base 4 en su equivalente binario. La tabla de búsqueda también agrega el espacio entre cada barra al agregar un cero entre cada número (que se asigna a una barra de todos los espacios).

La tabla de búsqueda se asigna directamente a 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

La conversión de binario a |y  ahora se realiza indexando en una cadena de esos dos caracteres, básicamente el mismo principio que la tabla de búsqueda para la conversión binaria.

* Guardado 1 byte, gracias @LuisMendo

Original:

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

Pruébalo en línea!

Función anónima que devuelve el código de barras como una cadena.

Esto se basa en el hecho de que si sumamos 4 a los dígitos de base4, entonces podemos representar barra / espacio por el número convertido a binario con los bits 1 y 2 intercambiados:

   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

La parte difícil desde una perspectiva de golf es agregar los espacios entre las barras y convertir de 0/1a '|'/' '.

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 prueba

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

¿Cómo?

Nota : en la versión siguiente, los literales de plantilla se han reemplazado por cadenas estándar para que el código se pueda sangrar correctamente.

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

Pruébalo en línea!

Ahorró un montón de bytes indexando y usando en catlugar de construir una matriz y usando write, así como 6 de una conversión ligeramente diferente a la base 4. Imprime con un espacio inicial en cada fila y sin líneas nuevas.

La indexación se lleva a cabo utilizando algo de aritmética modular, no muy diferente de otras respuestas, pero dado que R usa indización basada en 1, la aritmética es algo diferente.

Explicación:

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

Carbón de leña , 50 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Ingrese un número.

Ｆ²⊞υι

Empuje la secuencia de detención a la lista vacía predefinida.

¿θ

Si el número es positivo,

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

aplica repetidamente divmod para convertirlo a la base 4 invertida,

  ⊞υθ

de lo contrario solo empújalo.

Ｆ²⊞υι

Empuje la secuencia de inicio a la lista.

Ｅ⟦ |¦|¦  ||⟧

Mapa sobre tres cuerdas. Cada cadena representa la traducción del código de barras para los dígitos 0123de cada fila.

⪫Ｅ⮌υ§ιλω

Asigne los dígitos (invertidos nuevamente en el orden habitual), conviértalos en barras o espacios usando la traducción, luego combine los resultados en tres cadenas que luego se imprimen implícitamente en líneas separadas.

Japt , 32 31 bytes

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

¡Pruébelo en línea!

Todavía no estoy satisfecho con esto, pero es un comienzo ...

Explicación

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]

Pruébalo en línea! Devuelve una lista de líneas.

La misma alternativa de conteo de bytes para la primera línea:

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

J , 57 49 47 bytes

10 bytes gracias a FrownyFrog!

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

Cómo funciona:

1 0,4&#.inv,1,0: - convierte el número en una lista de dígitos de base 4, agrega 1 0 al principio y al final de la lista

((#:2 6 3 7){' |') - tabla de búsqueda para el cifrado, 0 binario corresponde al espacio, 1 a '|'

{~ - encripta los 4 dígitos base seleccionando una cadena de la tabla de búsqueda anterior (argumento invertido)

|: - transpone la matriz resultante de 3 columnas a 3 filas

[: - tapa el tenedor

,.2{."0 - pone espacios entre las barras

Pruébalo en línea!

APL + WIN, 63 bytes

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

Explicación:

(⍉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 gracias 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)

Pruébalo en línea!

05AB1E , 19 bytes

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

Pruébalo en línea!

Este es un medio puerto del enfoque de Dennis, que es solo un byte más corto que el método que usé antes (con el que estoy bastante satisfecho):

05AB1E , 20 bytes

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

Pruébalo en línea!

¿Cómo funciona?

4BT.øS2 ‰ í1ýøT „| ‡ € S »| Programa completo Toma entrada de STDIN, salidas a STDOUT.

4B | Convertir a base 4.
  T | Empuja un 10 a la pila.
   .ø | Surrond (anteponer y agregar el 10 a la representación de base 4).
     S | Dividir en caracteres / dígitos individuales.
                      + ------------------------------------------------- --------------
                      El | Esta parte solía ser ¸4.ø4в˜ en la versión anterior, que
                      El | significa: rodear con 4, convertir cada uno a la base 4 (4 -> [1, 0])
                      El | y finalmente aplanar profundamente la lista.
                      + ------------------------------------------------- --------------
      2 ‰ | Divmod 2 ([N // 2, N% 2]).
        í | Reverso (elemento-sabio).
         1ý | Agregue un 1 en el medio (elemento-sabio).
           ø | Transponer.
            T „| ‡ | Traduzca (‡) de "10" (T) a "|" („|).
                 € S »| Formatear como una cuadrícula.
                 € S | Empuja los personajes de cada uno.
                   »| Únase por líneas nuevas, mientras se unen listas internas por espacios.

Le pregunté a Adnan (el creador de 05AB1E) acerca de la cuadrícula en el chat , y me ayudaron a ahorrar 2 bytes, señalando una característica de 05AB1E: al unir listas multidimensionales por nuevas líneas, las listas internas se unen usando espacios también , entonces ðýes innecesario.

APL (Dyalog Classic) , 33 bytes

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

Pruébalo en línea!

J , 42 40 39 bytes

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

Afeitado 2 bytes gracias a Dennis. 1 byte gracias a ngn.

Pruébalo en línea!

Cómo 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

Utiliza .toString para convertir el número a base 4, y luego el trabajo de caso con cada línea y OR a nivel de bits para construir la salida línea por línea. Emite una lista de líneas.

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

Pruébalo en línea!

Explicación

El dcbit se convierte en base 4, anteponiendo y agregando un4 (se convierte 10en la salida) y usando npara mantener todo en una línea.

El resto sucede en 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
|

Pruébalo en línea! El enlace incluye los casos de prueba más rápidos. Explicación:

.+
$*

Convierte a unario.

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

Convierte a base 4 como números unarios separados por ;s.

^
1;;

Anteponer la secuencia de inicio.

$
;1;;

Agregue a ;, convirtiéndolo en un terminador de dígitos en lugar de un separador, y la secuencia de parada.

1*;
$.&

Convierte a decimal, pero suma 1 a cada dígito.

.+
$&¶$&¶$&

Triplicarlo.

T`13` `^.+

En la primera fila, 1S y 3s (que representan 0s y 2s) se convierten en espacios.

T`12` `.+$

En la última fila, 1S y 2s (que representan 0s y 1s) se convierten en espacios.

\d
|

Todos los demás dígitos se convierten en barras.

Pip , 33 31 29 27 26 bytes

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

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

Pruébalo en línea!

Explicación

Observamos un patrón en los cuatro tipos de barras:

• La primera fila es un espacio si el dígito es par, la tubería si es impar.
• La segunda fila es siempre una tubería.
• La tercera fila es un espacio si el dígito es 0 o 1, la tubería si 2 o 3.

Asi que:

                           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

Pruébalo aquí!

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

Pruébalo en línea!

Ligeramente menos terriblemente formateado (menos golfizado):

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

Explicación

Primero, considere el siguiente código para leer un número entero y generar la versión 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);}

Esto utiliza la recursividad de cola para invertir el orden de la salida. Cada paso recursivo cambia de bit por 2 (corta los últimos 2 bits y divide por 4). Emite el resultado enmascarado con 3 (0b11), que solo muestra los dos últimos bits, que es la última base de 4 dígitos.

La llamada a la función se incluye printfcomo argumento final (no se imprime, pero se evalúa) para evitar la necesidad de utilizar {} (+2 bytes) para agrupar la printfllamada a la función.

La solución aquí extiende este código de base 4. Primero, m se define como n, pero tal que en la base 4 tendrá 10 antepuestos y anexados. Luego imprimimos m.

En la impresión de la base 4 regularmente, usamos una máscara de bits de 3 para obtener el dígito. En el código de correo, la línea superior es el bit de orden inferior de ese dígito (una máscara de bits de 1) y la línea inferior es el bit de orden superior (una máscara de bits de 2). En consecuencia, el rde f(n,r)es la máscara de bits - nuestros principales llamadas a funciones f(m,1)para la primera línea y f(m,2)para la última línea.

Para que la línea media funcione (siempre imprima "|"), agregamos ||!ral condicional: si r es 0, siempre se evaluará como verdadero e imprimirá un "|". Luego llamamos f(m,0)a la línea media.

Finalmente, queremos que las nuevas líneas se comporten. Incluir un extra printfes costoso en lo que respecta a los bytes del código fuente, por lo que en su lugar agregamos otro especificador% c al existente printf. n?32:10imprime una nueva línea si n es 0 (falso) y un espacio en caso contrario. 32 y 10 se utilizan en lugar de '\ n' y '' para guardar bytes.

Lisp común, 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))))

Pruébalo en línea!

PHP, 99 + 1 bytes

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

"[$c*3+$y];

requiere PHP> = 5.5 para la indexación de cadenas literales y <7.1 para que la indexación no produzca una advertencia.

Ejecutar como tubería con -nRo probarlo en línea .

Inserte una nueva línea más para obtener una línea final.

Python 2, 142126 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') 

Muchas gracias a los ovs!

Traté de no copiar los métodos de las otras respuestas y ... qué asco.

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:"";}

Pruébalo en línea!

Estoy seguro de que me he perdido algunas mejoras.

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 comprueba que el carácter no sea '3', no la segunda fila, y luego algo de magia binaria para ver si la primera o tercera fila debe contener el espacio.

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

Pruébalo en línea!

Toma entrada de base 10 de la var $x

Japt , 42 bytes

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

Pruébalo en línea!

Pyth , 32 bytes

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

Pruébalo aquí!

C, 120 bytes

Lamentablemente solo funciona en Windows, ya que itoaes demasiado conveniente para ser estándar.

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