Codes à barres de 4 états

De nombreux services postaux (Royal Mail UK, Postes Canada, US Mail, etc.) utilisent un code-barres à 4 états pour coder les informations relatives à leur courrier. Rendu en ASCII, cela peut ressembler à ceci:

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

Un code à barres à 4 états est une rangée de barres. Chaque barre peut être étendue vers le haut, vers le bas ou les deux, offrant ainsi 4 possibilités. Cela signifie que chaque barre représente essentiellement un chiffre de base 4:

            | |
Bar: | | | |
                | |

Chiffre: 0 1 2 3

Le problème de cette symbologie est qu’il s’agit d’un code à barres différent, valide et inversé: il change radicalement la signification si l’orientation est incorrecte. Par conséquent, une séquence de démarrage et une séquence d' arrêt sont normalement implémentées afin que l'analyseur puisse calculer dans quel sens il est censé être lu.

Pour les besoins de ce défi, nous utiliserons la séquence de démarrage / d'arrêt spécifiée par Australia Post: chaque code à barres commence et se termine par une 1 0séquence.

Le défi

Votre tâche consiste à écrire un programme ou une fonction qui, à partir d’un entier positif N, le convertit en code à barres ASCII à 4 états, chaque barre (à l’exception des séquences de démarrage / arrêt) représentant un chiffre dans la représentation en base 4 de N.

Exemple:

Compte tenu de l'entier 19623, il faudrait d' abord le convertir à sa représentation de base 4, 10302213.

Nous pourrions ensuite mapper chaque chiffre sur la barre correspondante:

1 0 3 0 2 2 1 3

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

Enfin, nous ajouterions les séquences start / stop:

Début Fin:
1 0 1 0

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

Le code à barres résultant doit être la sortie du programme.

Règles:

• L'entrée sera un entier positif, compris dans la plage de la taille de l'entier standard de votre langue.
• Le résultat:
  • Peut être soit une liste de lignes, soit une chaîne contenant des nouvelles lignes.
  • Peut contenir des sauts de ligne ou des espaces, tant que la forme reste intacte.
  • Doit montrer le code à barres avec le format ci-dessus - il doit utiliser le caractère de pipe ( |) et le caractère d'espacement ( ) pour dessiner des barres, et il devrait y avoir un espace entre chaque barre verticale.
• C'est du code-golf , donc le programme le plus court (en octets) gagne!

Cas de test

4095:

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

4096:

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

7313145:

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

Python 3 , 103 99 96 octets

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

Essayez-le en ligne!

MATL , 34 30 29 28 octets

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

Essayez-le en ligne!

Explication

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ée , 16 15 octets

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

Essayez-le en ligne!

Comment ça marche

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ée , 19 octets

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

Essayez-le en ligne!

-1 merci à M. Xcoder .

Octave , 78 77 75 74 70 69 octets

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

Essayez-le en ligne!

Contrairement à l'approche originale, celle-ci utilise une simple table de correspondance pour mapper les valeurs en base 4 sur leur équivalent binaire. La table de recherche ajoute également l'espacement entre chaque barre en ajoutant un zéro entre chaque nombre (ce qui correspond à une barre de tous les espaces).

La table de recherche mappe directement aux barres en tant que:

   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 conversion de binaire en |et  est maintenant effectuée par indexation dans une chaîne de ces deux caractères - essentiellement le même principe que la table de conversion pour la conversion binaire.

* Enregistré 1 octet, merci @LuisMendo

Original:

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

Essayez-le en ligne!

Fonction anonyme qui renvoie le code à barres sous forme de chaîne.

Ceci est basé sur le fait que si nous ajoutons 4 aux chiffres base4, alors nous pouvons représenter bar / espace par le nombre converti en binaire avec les bits 1 et 2 échangés:

   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

Le plus délicat dans une perspective de golf est d' ajouter les espaces entre les barres et la conversion de 0/1à '|'/' '.

JavaScript (ES6), 89 87 83 octets

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

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

Comment?

NB : Dans la version ci-dessous, les littéraux de modèle ont été remplacés par des chaînes standard afin que le code puisse être mis en retrait correctement.

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 octets

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

Essayez-le en ligne!

Sauvegardé de nombreux octets en indexant et en utilisant cat plutôt que de construire une matrice et en utilisant write, ainsi que 6 à partir d'une conversion légèrement différente en base 4. Imprime avec un espace de début dans chaque ligne et aucune nouvelle ligne.

L'indexation s'effectue à l'aide d'une arithmétique modulaire, pas très différente d'autres réponses, mais puisque R utilise une indexation basée sur 1, l'arithmétique est quelque peu différente.

Explication:

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

Charbon de bois , 50 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

Ｎθ

Entrez un nombre.

Ｆ²⊞υι

Poussez la séquence d'arrêt sur la liste vide prédéfinie.

¿θ

Si le nombre est positif,

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

appliquer plusieurs fois divmod pour le convertir en base inversée 4,

  ⊞υθ

sinon, il suffit de le pousser.

Ｆ²⊞υι

Poussez la séquence de démarrage à la liste.

Ｅ⟦ |¦|¦  ||⟧

Carte sur trois chaînes. Chaque chaîne représente la traduction du code à barres pour les chiffres 0123de chaque ligne.

⪫Ｅ⮌υ§ιλω

Carte sur les chiffres (inversé dans l'ordre habituel), convertissez-les en barres ou en espaces en utilisant la traduction, puis joignez les résultats en trois chaînes qui sont ensuite implicitement imprimées sur des lignes séparées.

Japt , 32 à 31 octets

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

Testez-le en ligne!

Pas vraiment satisfait de ça pour l'instant, mais c'est un début ...

Explication

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 octets

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

Essayez-le en ligne! Retourne une liste de lignes.

Alternative de même nombre d'octets pour la première ligne:

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

J , 57 49 47 octets

10 octets grâce à FrownyFrog!

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

Comment ça marche:

1 0,4&#.inv,1,0: - convertit le numéro en une liste de chiffres en base 4, ajoute 1 0 au début et à la fin de la liste

((#:2 6 3 7){' |') - table de consultation pour le chiffrement, binaire 0 correspondant à l'espace, 1 à '|'

{~ - chiffre le chiffre de base 4 en sélectionnant une chaîne dans la table de recherche ci-dessus (argument inversé)

|: - transpose le tableau résultant de 3 colonnes en 3 lignes

[: - ferme la fourche

,.2{."0 - met des espaces entre les barres

Essayez-le en ligne!

APL + WIN, 63 octets

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

Explication:

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

^{-2 octets grâce à 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)

Essayez-le en ligne!

05AB1E , 19 octets

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

Essayez-le en ligne!

C'est un demi-port de l'approche de Dennis, qui est juste un octet plus court que la méthode que j'ai utilisée auparavant (et dont je suis assez content):

05AB1E , 20 octets

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

Essayez-le en ligne!

Comment ça marche?

4BT.øS2 ‰ í1ýøT „| ‡ € S »| Programme complet. Prend l'entrée de STDIN, les sorties vers STDOUT.

4B | Convertir en base 4.
  T | Poussez un 10 dans la pile.
   .ø | Surrond (ajoutez et ajoutez les 10 à la représentation en base 4).
     S | Divisé en caractères / chiffres individuels.
                      + ----------------------------------------------------- --------------
                      | Cette partie était 4.ø4в¸ dans la version précédente, qui
                      | signifie: entourer de 4, convertir chacun en base 4 (4 -> [1, 0])
                      | et enfin aplatir la liste.
                      + ----------------------------------------------------- --------------
      2 | Divmod 2 ([N // 2, N% 2]).
        í | Inverser (au niveau des éléments).
         1ý | Ajoutez un 1 au milieu (élément par élément).
           ø | Transposer.
            T „| ‡ | Traduisez (‡) de "10" (T) en "|" („|).
                 € S »| Format comme une grille.
                 € S | Poussez les caractères de chacun.
                   »| Joindre par des lignes nouvelles, tout en joignant des listes internes par des espaces.

J'ai demandé Adnan (le créateur de 05AB1E) à propos de la grille thingy dans le chat , qui m'a aidé à sauver 2 octets, en signalant une caractéristique de 05AB1E: lors de l' adhésion des listes multi-dimenisional par de nouvelles lignes, les listes internes sont jointes à l' aide des espaces trop , ðýest donc inutile.

APL (Dyalog Classic) , 33 octets

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

Essayez-le en ligne!

J , 42 40 39 octets

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

Rasé 2 octets grâce à Dennis. 1 octet grâce à ngn.

Essayez-le en ligne!

Comment ça marche

                                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 octets

Utilise .toString pour convertir le nombre en base 4, puis pour traiter une ligne avec chaque ligne et au niveau du bit OU pour générer la sortie ligne par ligne. Affiche une liste de lignes.

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 octets

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

Essayez-le en ligne!

Explication

Le dcbit est converti en base 4, en ajoutant et en ajoutant un 4(se transforme 10en sortie) et en utilisant npour tout conserver sur une seule ligne.

Le reste se passe dans 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 octets

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

Essayez-le en ligne! Link inclut les cas de test les plus rapides. Explication:

.+
$*

Convertir en unaire.

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

Convertir en base 4 sous forme de nombres unaires séparés par ;s.

^
1;;

Prévoyez la séquence de démarrage.

$
;1;;

Ajoutez a ;, en le transformant en un terminateur de chiffres plutôt qu'en un séparateur et la séquence d'arrêt.

1*;
$.&

Convertir en décimal, mais en ajoutant 1 à chaque chiffre.

.+
$&¶$&¶$&

Tripliquez-le.

T`13` `^.+

Sur la première ligne, 1s et 3s (représentant 0s et 2s) deviennent des espaces.

T`12` `.+$

Sur la dernière ligne, 1s et 2s (représentant 0s et 1s) deviennent des espaces.

\d
|

Tous les autres chiffres deviennent des barres.

Pip , 33 31 29 27 26 octets

25 octets de code, +1 pour le -Sdrapeau.

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

Essayez-le en ligne!

Explication

Nous observons un motif dans les quatre types de barres:

• La première ligne est un espace si le chiffre est pair, pipe si impair.
• La deuxième rangée est toujours un tuyau.
• La troisième ligne est un espace si le chiffre est 0 ou 1, pipe si 2 ou 3.

Alors:

                           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 octets

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

Essayez-le ici!

C (gcc) , 176 octets

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

Essayez-le en ligne!

Un peu moins terriblement formaté (moins joué au golf):

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

Explication

Considérons d’abord le code suivant pour lire un entier et sortir la version de 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);}

Ceci utilise la récursion de la queue pour inverser l'ordre de la sortie. Chaque étape récursive décale de 2 bits (coupe les 2 derniers bits et divise par 4). Il émet le résultat masqué avec 3 (0b11), qui n’affiche que les deux derniers bits, soit le dernier chiffre de la base 4.

L'appel de fonction est inclus dans l' printfargument final (il n'est pas imprimé, mais il est évalué) pour éviter d'avoir à utiliser {} (+2 octets) pour grouper l' printfappel de fonction.

La solution ici étend ce code base-4. Tout d’abord, m est défini comme n, mais tel qu’en base 4, il sera préfixé et ajouté. Nous imprimons ensuite m.

En imprimant régulièrement en base 4, nous avons utilisé un masque de bits de 3 pour obtenir le chiffre. Dans le code postal, la ligne supérieure représente le bit de poids faible de ce chiffre (un masque de bits de 1) et la ligne inférieure représente le bit de poids fort (un masque de bits de 2). En conséquence, rin f(n,r)est le bitmask - notre fonction principale appelle f(m,1)la première ligne et f(m,2)la dernière ligne.

Pour que la ligne médiane fonctionne (toujours imprimer "|"), nous ajoutons ||!rau conditionnel - si r est égal à 0, il sera toujours évalué à vrai et affichera un "|". Ensuite, nous appelons f(m,0)à la ligne médiane.

Enfin, nous voulons que les nouvelles lignes se comportent. L'inclusion d'un extra printfcoûte cher en octets de code source. Nous ajoutons donc un autre spécificateur% c à l'existant printf. n?32:10affiche une nouvelle ligne si n vaut 0 (faux) et un espace sinon. 32 et 10 sont utilisés à la place de '\ n' et '' pour sauvegarder des octets.

Common Lisp, 191 octets

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

Essayez-le en ligne!

PHP, 99 + 1 octets

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

"[$c*3+$y];

requiert PHP> = 5.5 pour l'indexation de chaîne littérale et <7.1 pour l'indexation afin de ne pas générer d'avertissement.

Exécuter en pipe -nRou essayer en ligne .

Insérez une nouvelle ligne pour en obtenir une autre.

Python 2, 142 126 octets

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

Un grand merci aux ovs!

J'ai essayé de ne pas copier les méthodes des autres réponses et ... beurk.

C # (.NET Core) , 160 octets

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

Essayez-le en ligne!

Je suis sûr que j'ai raté certaines améliorations.

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 vérifie que le caractère n'est pas '3', pas la deuxième ligne, et ensuite une magie binaire pour voir si la première ou la troisième ligne doit contenir de l'espace.

Zsh , 156 154 151 133 octets

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

Essayez-le en ligne!

Prend une entrée base 10 de la var $x

Japt , 42 octets

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

Essayez-le en ligne!

Pyth , 32 octets

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

Essayez-le ici!

C, 120 octets

Malheureusement, ne fonctionne que sur Windows, car il itoaest trop pratique pour être 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);}