¡Marque mi correo! - Códigos de barras ASCII

39

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 , 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 |      
FlipTack
fuente
Espacios principales permitidos? ;)
Erik the Outgolfer
@FlipTack El problema con esta simbología : no has visto a The Boondock Saints, ¿verdad?
Lord Farquaad
@EriktheOutgolfer Mientras el código de barras real, como una matriz 2D de caracteres, esté intacto, puede tener tantos espacios antes o después como sea necesario.
FlipTack
Otros desafíos relacionados con el código de barras: 1 , 2 , 3
FlipTack
¿Puede la salida tener ceros a la izquierda?
user230118

Respuestas:

9

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
Luis Mendo
fuente
8

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.
Dennis
fuente
Esta cadena tiene 15 caracteres unicode, ¿cómo puede tener 15 bytes?
jmster
2
@jmster Jelly tiene su propia página de códigos
Mr. Xcoder
@jmster Estos no son los personajes reales. El programa tiene 15 bytes específicos, que tienen estos mnemónicos. Compárelo con Bubblegum, en su mayoría parece, .......pero cada punto representa un byte diferente.
FrownyFrog el
¿Por qué bitwise OR en lugar de agregar?
FrownyFrog
@FrownyFrog Ambos funcionarían. Como el siguiente paso es la conversión a binario, fui con un operador bit a bit.
Dennis
7

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

Tom Carpenter
fuente
1
@LuisMendo inteligente! Gracias.
Tom Carpenter
7

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

¿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
Arnauld
fuente
Me encantaría que se explicara esta respuesta, están sucediendo algunas cosas raras: P
Brian H.
@BrianH. He añadido una explicación.
Arnauld
4

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

Giuseppe
fuente
3

Carbón de leña , 50 bytes

NθF²⊞υι¿θWθ«⊞υ﹪θ⁴≧÷⁴θ»⊞υθF²⊞υιE⟦ |¦|¦  ||⟧⪫E⮌υ§ιλω

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

Nθ

Ingrese un número.

F²⊞υι

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

¿θ

Si el número es positivo,

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

aplica repetidamente divmod para convertirlo a la base 4 invertida,

  ⊞υθ

de lo contrario solo empújalo.

F²⊞υι

Empuje la secuencia de inicio a la lista.

E⟦ |¦|¦  ||⟧

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

⪫E⮌υ§ιλω

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.

Neil
fuente
3

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
ETHproducciones
fuente
¡Sus 32 bytes me hacen sentir un poco mejor sobre este completo desastre ! ¡Realmente no debería intentar jugar golf mientras sirvo y bebo pintas!
Shaggy
3

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]]
Laikoni
fuente
3

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!

Galen Ivanov
fuente
@FrownyFrog ¡Gracias!
Galen Ivanov
2

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
Graham
fuente
2

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!

Barra
fuente
114 bytes.
notjagan
2

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.

Sr. Xcoder
fuente
2

APL (Dyalog Classic) , 33 bytes

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

Pruébalo en línea!

ngn
fuente
Oh, así es como se supone que debes rodear con 1 0 ...
FrownyFrog
Entonces, 2⊥⍣¯1¿cómo obtendrías una lista binaria?
FrownyFrog
@FrownyFrog No hay una única forma verdadera de rodear. Sí, 2⊥⍣¯1es el inverso ("anverso"?) De "dos decodificaciones". Se codifica en binario con tantos bits como sea necesario.
ngn
2

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
FrownyFrog
fuente
2

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

Kuilin Li
fuente
1
Enfoque genial con mapa y bit a bit O! Puede guardar un byte completo usando `10${n.toString(4)}10`:)
Chris M
2

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
Sophia Lechner
fuente
1
La conversión de la parte después de dc completamente a sed ahorra unos pocos bytes, tio.run/##S0oszvj/PyVZQTfVJCUlP88@r6CmODVFQb1YX09fTUE/…
Kritixi Lithos
¡Muy agradable! Intenté algo así, pero seguí intentando diferentes formas de ser inteligente con xlos espacios de espera / patrón para modificarlos y luego hacer stodo de una vez, y nada terminó más corto.
Sophia Lechner
@Cowsquack ¡Incluso logré bajar otros dos bytes según tu idea!
Sophia Lechner
Buena idea de combinar las transliteraciones, +1
Kritixi Lithos
1

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.

Neil
fuente
1

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)
DLosc
fuente
1

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.

Billy Graydon
fuente
1
Puede bajarlo a 146 si no le importan las advertencias:f(n,r){n&&f(n>>2);printf("%c%c",n?32:10,(n&r|!r)&&n?'|':32);}main(n){scanf("%d",&n);f(n=(n+(4<<(32-__builtin_clz(n)/2*2)))*16+4,1);f(n,0);f(n,2);}
gastropner
1

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!

Renzo
fuente
1

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.

Titus
fuente
Advertencia: Un valor no numérico encontrado en [...] la línea 7
RedClover
@Soaku La versión PHP debe ser de 5.5 a 7.0
Titus
1

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.

Daniel
fuente
128 bytes
ovs
1

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.

Ayb4btu
fuente
1

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

Noskcaj
fuente
0

Japt , 42 bytes

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

Pruébalo en línea!

Oliver
fuente
debe haber 1 espacio entre cada barra vertical
Erik the Outgolfer
0

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