4状态条形码

许多邮政服务（英国皇家邮政，加拿大邮政，美国邮政等）都使用4状态条形码对有关其邮件的信息进行编码。以ASCII呈现，可能看起来像这样：

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

4状态条形码是一行条。每个杆都可以向上，向下或两者同时延伸，从而有4种可能性。这意味着每个条形图基本上代表一个以4为底的数字：

            | |
酒吧：| | |
                | |

位数：0 1 2 3

该符号体系的问题在于，每个条形码都是有效的，上下颠倒的不同条形码：如果方向不正确，则会大大改变含义。因此，通常会执行开始和停止序列，以便扫描仪可以计算应该以哪种方式读取它。

为了解决这一挑战，我们将使用澳大利亚邮政指定的开始/停止序列：每个条形码以一个1 0序列开头和结尾。

挑战

您的任务是编写一个程序或函数，将给定的正整数N将其转换为ASCII 4状态条形码，其中每个小节（起始/停止序列除外）代表的以4为基的数字N。

例：

给定整数19623，我们首先将其转换为以4为基数的表示形式10302213。

然后，我们将每个数字映射到相应的条形：

1 0 3 0 2 2 1 3

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

最后，我们将添加开始/停止序列：

开始：结束：
1 0 1 0

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

产生的条形码应该是程序的输出。

规则：

• 输入将是一个正整数，在您语言的标准整数大小范围内。
• 输出：
  • 可以是行列表，也可以是包含换行符的字符串。
  • 只要形状保持不变，就可以包含前导或尾随的换行符/空格。
  • 应该以上述格式显示条形码- 绘制条时必须使用竖线字符（|）和空格字符（），并且每根竖线之间必须有1个空格。
• 这是代码高尔夫球，因此最短的程序（以字节为单位）获胜！

测试用例

4095：

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

4096：

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

7313145：

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

Python 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

在线尝试！

-1感谢Xcoder先生。

八度，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值映射到它们的等效二进制值。查找表还通过在每个数字之间添加零（映射到所有空格的条形）来增加每个条形之间的间距。

查找表直接映射到条形为：

   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]

在线尝试！

匿名函数，将条形码作为字符串返回。

这是基于这样一个事实，如果我们将4加到base4位数上，那么我们可以用交换为1和2的二进制数将数字表示为bar /空格：

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

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

怎么样？

注意：在以下版本中，模板文字已被标准字符串替换，以便可以正确缩进代码。

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

Haskell，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字节

10字节感谢FrownyFrog！

[:,.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

Python 2中，116个 114字节

^{-2个字节，感谢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)

在线尝试！

05AB1E，19个字节

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

在线尝试！

这是丹尼斯方法的一半，比我以前使用的方法（我很满意）仅短了一个字节：

05AB1E，20个字节

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

在线尝试！

这个怎么运作？

4BT.øS2‰í1ýøT„ | ‡€S | | 完整程序。从STDIN接收输入，然后输出到STDOUT。

4B | 转换为基数4。
  T | 将10推入堆栈。
   .ø| Surrond（将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个字节：当通过换行符连接多维列表时，内部列表也使用空格连接，所以ðý没有必要。

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个字节。1字节感谢ngn。

在线尝试！

这个怎么运作

                                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字节

使用.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*;
$.&

转换为十进制，但向每个数字加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和函数调用进行分组。

这里的解决方案扩展了此base-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:10如果n为0（假），则打印换行符，否则为空格。使用32和10代替'\ n'和''保存字节。

通用Lisp，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或在线尝试。

再插入一个换行符以获得尾随的换行符。

Python 2中，142个 126字节

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 Core），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 检查char是否不是'3'，而不是第二行，然后使用某种二进制魔术检查第一行或第三行是否应包含空格。

岩组，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获取以10为底的输入 $x

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