Codici a barre a 4 stati

Molti servizi postali (Royal Mail UK, Canada Post, US Mail, ecc.) Utilizzano un codice a barre a 4 stati per codificare le informazioni sulla loro posta. Resi in ASCII, potrebbe assomigliare a questo:

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

Un codice a barre a 4 stati è una fila di barre. Ogni barra può essere estesa verso l'alto, verso il basso o entrambe, consentendo 4 possibilità. Ciò significa che ogni barra rappresenta essenzialmente una cifra di 4 cifre:

            | |
Bar: | | | |
                | |

Cifra: 0 1 2 3

Il problema con questa simbologia è che ogni codice a barre è un codice a barre valido diverso, capovolto: cambia drasticamente il significato se l'orientamento è errato. Pertanto, una sequenza di avvio e arresto viene normalmente implementata in modo che lo scanner possa calcolare il modo in cui dovrebbe essere letto.

Ai fini di questa sfida, utilizzeremo la sequenza di avvio / arresto specificata da Australia Post: ogni codice a barre inizia e termina con una 1 0sequenza.

La sfida

Il tuo compito è quello di scrivere un programma o una funzione che, dato un numero intero positivo N, lo converte in un codice a barre ASCII a 4 stati, dove ogni barra (ad eccezione delle sequenze di avvio / arresto) rappresenta una cifra nella rappresentazione base-4 di N.

Esempio:

Dato il numero intero 19623, avremmo prima convertirlo sua rappresentazione di base 4, 10302213.

Vorremmo quindi mappare ogni cifra sulla barra corrispondente:

1 0 3 0 2 2 1 3

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

Infine, aggiungeremmo le sequenze di avvio / arresto:

Inizio: Fine:
1 0 1 0

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

Il codice a barre risultante dovrebbe essere l'output del programma.

Regole:

• L'input sarà un numero intero positivo, all'interno dell'intervallo della dimensione intera standard della tua lingua.
• L'output:
  • Può essere un elenco di righe o una stringa contenente nuove righe.
  • Può contenere righe / linee iniziali o finali, purché la forma rimanga intatta.
  • Dovrebbe mostrare il codice a barre con il formato sopra - deve usare il carattere pipe ( |) e lo spazio ( ) quando si disegnano le barre, e dovrebbe esserci 1 spazio tra ciascuna barra verticale.
• Questo è code-golf , quindi vince il programma più breve (in byte)!

Casi test

4095:

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

4096:

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

7313145:

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

Python 3 , 103 99 96 byte

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

Provalo online!

MATL , 34 30 29 28 byte

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

Provalo online!

Spiegazione

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

Gelatina , 16 15 byte

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

Provalo online!

Come funziona

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.

Gelatina , 19 byte

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

Provalo online!

-1 grazie a Mr. Xcoder .

Ottava , 78 77 75 74 70 69 byte

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

Provalo online!

A differenza dell'approccio originale, questo utilizza una semplice tabella di ricerca per mappare i valori di base 4 sul loro equivalente binario. La tabella di ricerca aggiunge anche la spaziatura tra ciascuna barra aggiungendo uno zero tra ciascun numero (che mappa su una barra di tutti gli spazi).

La tabella di ricerca si associa direttamente alle barre come:

   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 conversione da binario a |e  viene ora eseguita indicizzando in una stringa di questi due caratteri, sostanzialmente lo stesso principio della tabella di ricerca per la conversione binaria.

* Salvato 1 byte, grazie @LuisMendo

Originale:

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

Provalo online!

Funzione anonima che restituisce il codice a barre come stringa.

Ciò si basa sul fatto che se aggiungiamo 4 alle cifre base4, possiamo rappresentare la barra / spazio dal numero convertito in binario con i bit 1 e 2 scambiati:

   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

Il punto difficile dal punto di vista del golf è l'aggiunta di spazi tra le barre e la conversione da 0/1a '|'/' '.

JavaScript (ES6), 89 87 83 byte

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

Casi test

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

Come?

NB : Nella versione seguente, i letterali dei template sono stati sostituiti con stringhe standard in modo che il codice possa essere rientrato correttamente.

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 byte

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

Provalo online!

Ho salvato un sacco di byte indicizzando e usando catinvece di costruire una matrice e usandowrite , così come 6 da una conversione leggermente diversa alla base 4. Stampa con uno spazio iniziale in ogni riga e nessuna nuova riga finale.

L'indicizzazione avviene usando un'aritmetica modulare, non diversamente da altre risposte, ma poiché R utilizza l'indicizzazione basata su 1, l'aritmetica è leggermente diversa.

Spiegazione:

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

Carbone , 50 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Inserisci un numero.

Ｆ²⊞υι

Spingere la sequenza di arresto nell'elenco vuoto predefinito.

¿θ

Se il numero è positivo,

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

applicare ripetutamente divmod per convertirlo in base inversa 4,

  ⊞υθ

altrimenti basta spingerlo.

Ｆ²⊞υι

Spingere la sequenza iniziale nell'elenco.

Ｅ⟦ |¦|¦  ||⟧

Mappa su tre stringhe. Ogni stringa rappresenta la traduzione del codice a barre per le cifre 0123per ogni riga.

⪫Ｅ⮌υ§ιλω

Mappa sulle cifre (invertite nell'ordine normale), convertile in barre o spazi usando la traduzione, quindi unisci i risultati in tre stringhe che vengono quindi implicitamente stampate su linee separate.

Japt , 32 31 byte

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

Provalo online!

Non sono ancora molto soddisfatto, ma è un inizio ...

Spiegazione

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 byte

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

Provalo online! Restituisce un elenco di righe.

Stessa alternativa conteggio byte per la prima riga:

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

J , 57 49 47 byte

10 byte grazie a FrownyFrog!

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

Come funziona:

1 0,4&#.inv,1,0: - converte il numero in un elenco di cifre in base 4, aggiunge 1 0 all'inizio e alla fine dell'elenco

((#:2 6 3 7){' |') - tabella di ricerca per la crittografia, 0 binario corrisponde allo spazio, 1 a '|'

{~ - crittografa la cifra di base 4 selezionando una stringa dalla tabella di ricerca sopra (argomento invertito)

|: - traspone l'array risultante da 3 colonne a 3 righe

[: - tappi la forcella

,.2{."0 - mette gli spazi tra le barre

Provalo online!

APL + WIN, 63 byte

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

Spiegazione:

(⍉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 byte

^{-2 byte grazie 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)

Provalo online!

05AB1E , 19 byte

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

Provalo online!

Questa è una mezza porta dell'approccio di Dennis, che è solo un byte più breve del metodo che ho usato prima (di cui sono abbastanza soddisfatto):

05AB1E , 20 byte

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

Provalo online!

Come funziona?

4BT.øS2 ‰ í1ýøT “| ‡ € S »| Programma completo. Riceve input da STDIN, output su STDOUT.

4B | Converti in base 4.
  T | Spingi un 10 nello stack.
   .ø | Surrond (anteponi e aggiungi il 10 alla rappresentazione base 4).
     S | Dividi in singoli caratteri / cifre.
                      + ------------------------------------------------- --------------
                      | Questa parte era "4" 4 nella versione precedente, che
                      | significa: circondare con 4, convertirli ciascuno in base 4 (4 -> [1, 0])
                      | e infine appiattire la lista.
                      + ------------------------------------------------- --------------
      2 ‰ | Divmod 2 ([N // 2, N% 2]).
        í | Inverti (dal punto di vista degli elementi).
         1ý | Aggiungi un 1 nel mezzo (elemento-saggio).
           ø | Trasporre.
            T “| ‡ | Traduci (‡) da "10" (T) a "|" („|).
                 € S »| Formatta come una griglia.
                 € S | Spingi i personaggi di ciascuno.
                   »| Partecipa con le nuove linee, unendo le liste interne per spazi.

Ho chiesto ad Adnan (il creatore di 05AB1E) della cosa della griglia nella chat e mi hanno aiutato a salvare 2 byte, sottolineando una funzione di 05AB1E: quando si uniscono liste multidimensionali con nuove linee, le liste interne vengono unite usando anche gli spazi , quindi ðýnon è necessario.

APL (Dyalog Classic) , 33 byte

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

Provalo online!

J , 42 40 39 byte

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

Rasato 2 byte grazie a Dennis. 1 byte grazie a ngn.

Provalo online!

Come funziona

                                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 byte

Utilizza .toString per convertire il numero in base 4, quindi casework per ogni riga e bit per bit OR per creare l'output riga per riga. Emette un elenco di righe.

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 byte

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

Provalo online!

Spiegazione

Il dcbit si converte in base 4, anteponendo e aggiungendo con un 4(si trasforma in 10in output) e usando nper mantenere tutto su una riga.

Il resto accade in 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 byte

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

Provalo online! Link include i casi di test più veloci. Spiegazione:

.+
$*

Converti in unario.

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

Converti in base 4 come numeri unari separati da ;s.

^
1;;

Prepara la sequenza iniziale.

$
;1;;

Aggiungi a ;, trasformandolo in un terminatore di cifre anziché in un separatore e nella sequenza di arresto.

1*;
$.&

Converti in decimale, ma aggiungendo 1 a ogni cifra.

.+
$&¶$&¶$&

Triplicalo.

T`13` `^.+

Nella prima riga, 1s e 3s (che rappresentano 0s e2 s) diventano spazi.

T`12` `.+$

Nell'ultima riga, 1s e 2s (che rappresentano 0s e1 s) diventano spazi.

\d
|

Tutte le altre cifre diventano barre.

Pip , 33 31 29 27 26 byte

25 byte di codice, +1 per la -Sbandiera.

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

Provalo online!

Spiegazione

Osserviamo uno schema nei quattro tipi di barre:

• La prima riga è uno spazio se la cifra è pari, pipe se dispari.
• La seconda fila è sempre una pipe.
• La terza riga è uno spazio se la cifra è 0 o 1, pipe se 2 o 3.

Così:

                           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 byte

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

Provalo qui!

C (gcc) , 176 byte

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

Provalo online!

Leggermente meno terribilmente formattato (meno golfizzato):

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

Spiegazione

Innanzitutto, considera il codice seguente per leggere un numero intero e generare la versione di 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);}

Questo utilizza la ricorsione della coda per invertire l'ordine dell'output. Ogni step ricorsivo si sposta di 2 (elimina gli ultimi 2 bit e divide per 4). Emette il risultato con maschera di bit con 3 (0b11), che mostra solo gli ultimi due bit, che è la base dell'ultima cifra 4.

La chiamata di funzione è inclusa printfcome argomento finale (non viene stampata, ma viene valutata) per evitare di dover utilizzare {} (+2 byte) per raggruppare la printfchiamata di funzione e.

La soluzione qui estende questo codice base-4. Innanzitutto, m è definito come n, ma tale che nella base 4 avrà 10 anteposto e aggiunto ad esso. Quindi stampiamo m.

Nella stampa di base 4 regolarmente, abbiamo usato una maschera di bit di 3 per ottenere la cifra. Nel codice postale, la riga superiore è il bit di ordine inferiore di quella cifra (una maschera di bit di 1) e la riga inferiore è il bit di ordine superiore (una maschera di bit di 2). Di conseguenza, rin f(n,r)è la maschera di bit - la nostra funzione principale richiede f(m,1)la prima riga ef(m,2) l'ultima riga.

Per far funzionare la linea di mezzo (stampa sempre "|"), aggiungiamo ||!ral condizionale - se r è 0, valuterà sempre come vero e stampa un "|". Quindi chiediamo f(m,0)la linea di mezzo.

Infine, vogliamo che le newline si comportino bene. Includere un extra printfè costoso per quanto riguarda i byte di codice sorgente, quindi aggiungiamo un altro identificatore% c all'esistente printf. n?32:10stampa una nuova riga se n è 0 (falso) e uno spazio in caso contrario. 32 e 10 sono usati al posto di '\ n' e '' per salvare i byte.

Lisp comune, 191 byte

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

Provalo online!

PHP, 99 + 1 byte

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

"[$c*3+$y];

richiede PHP> = 5.5 per l'indicizzazione della stringa letterale e <7.1 per l'indicizzazione per non generare un avviso.

Esegui come pipe -nRo provalo online .

Inserisci un'altra riga per ottenerne una successiva.

Python 2, 142 126 byte

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

Grazie mille a ovs!

Ho provato a non copiare i metodi delle altre risposte e ... schifo.

C # (.NET Core) , 160 byte

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

Provalo online!

Sono sicuro di aver perso alcuni miglioramenti.

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 controlla che il carattere non sia "3", non la seconda riga, quindi un po 'di magia binaria per vedere se la prima o la terza riga deve contenere lo spazio.

Zsh , 156 154 151 133 byte

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

Provalo online!

Prende l'input di base 10 dal var $x

Japt , 42 byte

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

Provalo online!

Pyth , 32 byte

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

Provalo qui!

C, 120 byte

Purtroppo funziona solo su Windows, poiché itoaè troppo comodo per essere standard.

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