4 상태 바코드

많은 우편 서비스 (Royal Mail UK, Canada Post, US Mail 등)는 4 가지 상태 바코드를 사용하여 메일 정보를 인코딩합니다. ASCII로 렌더링하면 다음과 같이 보일 수 있습니다.

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

4 상태 바코드는 일련의 막대입니다. 각 막대를 위, 아래 또는 둘 다 확장하여 4 가지 가능성을 허용합니다. 즉, 각 막대는 기본적으로 기본 4 자리를 나타냅니다.

            | |
바 : | | | |
                | |

자리 : 012 3

이 기호의 문제점은 각 바코드가 유효하고 다른 바코드가 거꾸로되어 있다는 것입니다. 방향이 잘못된 경우 의미를 크게 변경합니다. 따라서 시작 및 중지 순서는 일반적으로 구현되므로 스캐너는 읽을 방향을 계산할 수 있습니다.

이 과제를 위해 Australia Post에서 지정한 시작 / 중지 시퀀스를 사용합니다. 각 바코드는 1 0시퀀스로 시작하고 끝납니다 .

도전

당신의 임무는 양의 정수가 주어지면 NASCII 4 상태 바코드로 변환 하는 프로그램이나 함수를 작성하는 것입니다. 여기서 각 막대 (시작 / 정지 시퀀스 제외)는의 기본 4 표현에서 숫자를 나타냅니다 N.

예:

integer가 주어지면 19623먼저이를 기본 4 표현으로 변환합니다 10302213.

그런 다음 각 숫자를 해당 막대에 매핑합니다.

1,030 2 1 3

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

마지막으로 시작 / 중지 시퀀스를 추가합니다.

시작 : 끝 :
1,010

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

결과 바코드는 프로그램의 출력이어야합니다.

규칙 :

• 입력은 언어의 표준 정수 크기 범위 내에서 양의 정수가됩니다.
• 출력 :
  • 행 목록이거나 개행을 포함하는 문자열 일 수 있습니다.
  • 모양이 그대로 유지되는 경우 선행 또는 후행 줄 바꿈 / 공백이 포함될 수 있습니다.
  • 위의 형식으로 바코드를 표시해야합니다. 막대를 그릴 때 파이프 문자 ( |)와 공백 문자 ( )를 사용해야하며 각 수직 막대 사이에 1 개의 공백이 있어야합니다.
• 이것은 code-golf 이므로 가장 짧은 프로그램 (바이트)이 이깁니다!

테스트 사례

4095 :

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

4096 :

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

7313145 :

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

파이썬 3 , 103 99 96 바이트

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

온라인으로 사용해보십시오!

MATL , 34 30 29 28 바이트

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

온라인으로 사용해보십시오!

설명

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

젤리 , 16 15 바이트

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

온라인으로 사용해보십시오!

작동 원리

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.

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

Xcoder 씨께 -1 감사합니다 .

옥타브 , 78 77 75 74 70 69 바이트

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

온라인으로 사용해보십시오!

원래 접근 방식과 달리이 방법은 간단한 조회 테이블을 사용하여 base-4 값을 이진 값으로 매핑합니다. 또한 룩업 테이블은 각 숫자 사이에 0을 추가하여 각 막대 사이의 간격을 추가합니다 (모든 공간의 막대에 매핑 됨).

조회 테이블은 다음과 같이 막대에 직접 매핑됩니다.

   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

바이너리에서로 변환 |하고는  이제 두 문자의 문자열로 인덱싱하여 수행됩니다 - 기본적으로 같은 원리를 바이너리 변환을위한 룩업 테이블로.

* 1 바이트 저장, @LuisMendo 덕분에

기발한:

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

온라인으로 사용해보십시오!

바코드를 문자열로 반환하는 익명 함수

이것은 우리가 base4 숫자에 4를 더하면 비트 1과 2가 교환 된 이진수로 변환 된 숫자로 막대 / 공간을 나타낼 수 있다는 사실에 근거합니다.

   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

골프 관점에서 까다로운 부분은 막대 사이에 공백을 추가하고에서 0/1로 변환하는 것 '|'/' '입니다.

자바 스크립트 (ES6), 89 87 83 바이트

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

테스트 사례

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

어떻게?

NB : 아래 버전에서는 템플릿 리터럴 이 표준 문자열로 바뀌어 코드를 올바르게 들여 쓸 수 있습니다.

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 바이트

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

온라인으로 사용해보십시오!

cat행렬을 생성하는 대신 인덱싱 및 사용 과 write기본 4 로의 약간 다른 변환에서 6을 사용하는 대신 전체 바이트 수를 절약했습니다.

인덱싱은 다른 답변과 달리 모듈 식 산술을 사용하여 수행되지만 R은 1 기반 인덱싱을 사용하므로 산술은 다소 다릅니다.

설명:

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

숯 , 50 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

숫자를 입력하십시오.

Ｆ²⊞υι

중지 시퀀스를 사전 정의 된 빈 목록으로 푸시하십시오.

¿θ

숫자가 양수이면

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

반복적으로 divmod를 적용하여 반전 된 기본 4로 변환하십시오.

  ⊞υθ

그렇지 않으면 그냥 밀어 넣으십시오.

Ｆ²⊞υι

시작 순서를 목록으로 밉니다.

Ｅ⟦ |¦|¦  ||⟧

세 줄로 매핑하십시오. 각 문자열은 0123각 행 의 숫자에 대한 바코드 변환을 나타냅니다 .

⪫Ｅ⮌υ§ιλω

자릿수 (일반 순서로 되돌림)를 매핑하고 변환을 사용하여 막대 또는 공백으로 변환 한 다음 결과를 세 개의 문자열로 결합한 다음 암시 적으로 별도의 행에 인쇄합니다.

Japt , 32 31 바이트

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

온라인으로 테스트하십시오!

아직 이것에 만족하지는 않지만 시작입니다 ...

설명

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

하스켈 , 91 90 바이트

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

온라인으로 사용해보십시오! 줄 목록을 반환합니다.

첫 번째 줄의 동일한 바이트 수 대안 :

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

J , 57 49 47 바이트

FrownyFrog 덕분에 10 바이트!

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

작동 방식 :

1 0,4&#.inv,1,0: -숫자를 기본 4 자리 목록으로 변환하고 목록의 시작과 끝에 1 0을 더합니다.

((#:2 6 3 7){' |') -암호화 조회 테이블, 이진 0은 공간, 1에서 '|'에 해당

{~ -위의 룩업 테이블에서 문자열을 선택하여 기본 4 자리를 암호화합니다 (인수를 반대로).

|: -결과 배열을 3 열에서 3 행으로 바꿉니다.

[: -포크 캡

,.2{."0 -막대 사이에 공백을 넣습니다.

온라인으로 사용해보십시오!

APL + WIN, 63 바이트

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

설명:

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

파이썬 2 , 116114 바이트

^{notjagan 덕분에 -2 바이트}

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)

온라인으로 사용해보십시오!

05AB1E , 19 바이트

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

온라인으로 사용해보십시오!

이것은 Dennis의 접근 방식의 절반 포트이며 이전에 사용한 방법보다 1 바이트 짧습니다 (매우 만족합니다).

05AB1E , 20 바이트

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

온라인으로 사용해보십시오!

어떻게 작동합니까?

4BT.øS2 ‰ í1ýøT „| ‡ € S»| 전체 프로그램. STDIN에서 입력을 받아서 STDOUT으로 출력합니다.

4B | 베이스 4로 변환합니다.
  T | 10을 스택으로 밉니다.
   .ø | 서론 (10을 기본 4 표현 앞에 붙임).
     S | 개별 문자 / 숫자로 나눕니다.
                      + ------------------------------------------------- --------------
                      | 이 부분은 이전 버전에서 ¸4.ø4в ~였습니다.
                      | 의미 : 4로 둘러싸고 각각을 기본 4로 변환하십시오 (4-> [1, 0])
                      | 마지막으로 목록을 깊게 만듭니다.
                      + ------------------------------------------------- --------------
      2 ‰ | Divmod 2 ([N // 2, N % 2]).
        í | 반대로 (요소 별).
         1ý | 중간에 1을 요소 단위로 추가하십시오.
           ø | 바꾸어 놓다.
            T „| ‡ | "10"(T)에서 "|"( „|)로 (‡)을 번역합니다.
                 € S»| 그리드로 형식화하십시오.
                 € S | 각각의 문자를 밀어 넣습니다.
                   »| 공백으로 내부 목록을 조인하면서 줄 바꿈으로 조인하십시오.

내가 물었다 아드 난 그리드 꼬추에 대해 (05AB1E의 창조자를) 채팅 , 그들은 05AB1E의 기능을 지적하여, 2 바이트 저장 나에게 도움이 : 줄 바꿈에 의해 멀티 dimenisional 목록에 가입 할 때 내부 목록이 너무 공간을 사용하여 연결된다 그래서 ðý불필요하다.

APL (Dyalog Classic) , 33 바이트

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

온라인으로 사용해보십시오!

J , 42 40 39 바이트

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

Dennis 덕분에 2 바이트가 줄었습니다. ngn 덕분에 1 바이트.

온라인으로 사용해보십시오!

작동 원리

                                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

자바 스크립트 (ES6) 79 바이트

.toString을 사용하여 숫자를 기수 4로 변환 한 다음 각 라인 및 비트 단위 OR을 사용하여 라인 단위로 출력을 빌드합니다. 라인리스트를 출력합니다.

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 바이트

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

온라인으로 사용해보십시오!

설명

dc베이스 4 붙이는와 함께 추가로 비트 변환 4(변신 10출력에서)를 사용하고 n하나 개의 라인에있는 모든 유지.

나머지는 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

망막 , 83 바이트

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

온라인으로 사용해보십시오! 링크에는 더 빠른 테스트 사례가 포함됩니다. 설명:

.+
$*

단항으로 변환합니다.

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

단수를 ;s로 구분하여 밑수 4로 변환합니다 .

^
1;;

시작 순서를 앞에 추가하십시오.

$
;1;;

을 추가하여 ;구분 기호가 아닌 숫자 종결 자 및 중지 시퀀스로 바꿉니다.

1*;
$.&

10 진수로 변환하지만 각 숫자에 1을 더합니다.

.+
$&¶$&¶$&

그것을 세 번.

T`13` `^.+

첫 번째 행에서 1s와 3s ( 0s와 2s를 나타냄 )는 공백이됩니다.

T`12` `.+$

마지막 행에서 1s와 2s ( 0s와 1s를 나타냄 )는 공백이됩니다.

\d
|

다른 모든 숫자는 막대가됩니다.

핍 , 33 31 29 27 26 바이트

25 바이트의 코드, -S플래그의 경우 +1

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

온라인으로 사용해보십시오!

설명

우리는 네 가지 막대 유형에서 패턴을 관찰합니다.

• 첫 번째 행은 숫자가 짝수이면 공백이고 홀수이면 파이프입니다.
• 두 번째 줄은 항상 파이프입니다.
• 세 번째 행은 숫자가 0 또는 1이면 공백이고 파이프는 2 또는 3입니다.

그래서:

                           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 바이트

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

여기 사용해보십시오!

C (gcc) , 176 바이트

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

온라인으로 사용해보십시오!

약간 덜 형식화 (골프가 적음) :

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

설명

먼저 다음 코드를 고려하여 정수를 읽고 기본 4 버전을 출력하십시오.

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

이것은 꼬리 재귀를 사용하여 출력 순서를 반대로합니다. 각 재귀 단계는 2 씩 시프트됩니다 (마지막 2 비트에서 벗어나 4로 나눕니다). 3 (0b11)으로 비트 마스킹 된 결과를 출력하며, 마지막 두 비트 (마지막 숫자베이스 4) 만 표시합니다.

함수 호출은 printf{} (+ 2 바이트)를 사용하여 printf및 함수 호출 을 그룹화하지 않아도되도록 후행 인수 (인쇄되지는 않지만 평가됨)로 포함됩니다 .

이 솔루션은이 기본 4 코드를 확장합니다. 먼저, m은 n으로 정의되지만 밑 4에서 10이 앞에 붙고 추가됩니다. 그런 다음 m을 인쇄합니다.

베이스 4를 정기적으로 인쇄 할 때 우리는 3의 비트 마스크를 사용하여 숫자를 얻었습니다. 메일 코드에서 맨 위 줄은 숫자의 하위 비트 (비트 1)이고 맨 아래 줄은 상위 비트 (비트 2)입니다. 따라서 rin f(n,r)은 비트 마스크입니다. 주요 함수 f(m,1)는 첫 번째 줄과 f(m,2)마지막 줄을 호출 합니다 .

중간 행이 작동하도록하려면 (항상 "|"를 인쇄) ||!r조건부에 추가 합니다. r이 0이면 항상 true로 평가되고 "|"를 인쇄합니다. 그런 다음 f(m,0)중간 줄을 요구합니다.

마지막으로, 줄 바꿈이 작동하기를 원합니다. 추가 printf소스를 포함하면 소스 코드의 바이트 수만큼 비용이 많이 들기 때문에 기존에 다른 % c 지정자를 추가합니다 printf. n?32:10n이 0 (거짓)이면 개행을 인쇄하고 그렇지 않으면 공백을 인쇄합니다. 바이트를 저장하기 위해 '\ n'및 ''대신 32와 10이 사용됩니다.

공통 리스프, 191 바이트

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

온라인으로 사용해보십시오!

PHP, 99 + 1 바이트

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

"[$c*3+$y];

리터럴 문자열 인덱싱에는 PHP> = 5.5가 필요하고 인덱싱에는 경고가 생성되지 않도록 <7.1이 필요합니다.

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

줄 바꿈을 하나 더 받으려면 줄 바꿈을 하나 더 삽입하십시오.

파이썬 2, 142126 바이트

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

ovs에게 큰 감사합니다!

나는 다른 답변의 방법을 복사하지 않으려 고 노력했다.

C # (. NET 코어) , 160 바이트

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

온라인으로 사용해보십시오!

개선 사항을 놓친 것 같습니다.

골프

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 문자가 두 번째 행이 아닌 '3'이 아닌지 확인한 다음 첫 번째 또는 세 번째 행에 공백이 포함되어 있는지 확인하는 이진 마술.

zsh을 , 156 154 151 133 바이트

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

온라인으로 사용해보십시오!

var에서 base-10 입력을받습니다. $x

apt , 42 바이트

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

온라인으로 사용해보십시오!

Pyth , 32 바이트

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

여기 사용해보십시오!

C, 120 바이트

슬프게도 Windows에서만 작동 itoa합니다. 표준이 되기에는 너무 편리하기 때문입니다.

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