剪了一个布尔矩阵在4×2块，并将其呈现为盲文字符U+2800... U+28FF。

[[0,1,0,0,1,0],
 [1,0,0,0,0,0],
 [1,0,0,0,1,0],
 [1,1,1,1,0,0]]

⣎⣀⠅

如果尺寸不是4和2的倍数，则以0-s填充。

[[0,1,0],
 [1,0,0],
 [1,1,1]]

⠮⠄

通常的打高尔夫球规则适用，输入格式灵活。输出应该具有矩阵的结构，或者看起来像矩阵，例如字符串列表；带换行符的单个字符串。

提示：chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)是圆点图案

b0 b3
b1 b4
b2 b5
b6 b7

更大的测试：

[[0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0],
 [0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1],
 [0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1],
 [1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1],
 [1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0],
 [1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0],
 [1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0],
 [1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1],
 [1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0],
 [1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0],
 [0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
 [0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0],
 [0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0]]

⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀

果冻， 31  30 字节

sz0Z
ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY

在线尝试！

怎么样？

sz0Z - Link 1, split & right-pad with zeros: list, items; number, chunkSize
s    - split items into chunks of length chunkSize
 z0  - transpose with filler zero
   Z - transpose

ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY - Main link: list of lists of numbers (1s & 0s), M
ç€2                       - call the last link (1) as a dyad for €ach (left=M, right=2)
                          -  ((left,right) bits read left-right then top-bottom)
   Z                      - transpose the resulting list of lists of lists
                          -  ((left, right) bits read top-bottom then left-right)
    F€                    - flatten €ach
      ç€8                 - call the last link (1) as a dyad for €ach (left=^, right=8)
         Z                - transpose the resulting list of lists of lists
                          -  ("blocks" each and all read left-right top-to bottom)
               -36        - literal -36
             €€           - for €ach (block-wise row) for €ach (block)
          œ?@             -   lexicographical permutation with reversed arguments
                          -    (get the permutation at index -36 (modular) in a list of
                          -     all permutations of the indexes sorted lexicographically.
                          -     That is the 8!-36 = 40284th - equivalently the values at
                          -     indexes [8,7,6,4,2,5,3,1])
                  Ḅ       - convert from binary list to integer (vectorises)
                    ⁽$ṁ   - base 250 literal = 10240
                   +      - add
                       Ọ  - cast to character (vectorises)
                        Y - join with newlines
                          - implicit print

的JavaScript ES7 210 207 201 200 198个 194 185 183字节

a=>eval('for(y=0,c="";A=a[y];y+=4,c+=`\n`)for(x=0;A[x]+1;x+=2)c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(X,Y=3)=>(a[Y+y]||0)[X+x]|0)(k>2,k%3)*2**k")|g(0)+g(1)*2<<6)')

多亏了ngn，节省了4个字节

感谢Luke，节省了3个字节

这个怎么运作

我将把代码分成几部分，分别讨论它们：

for(y=x=0, c=""; a[y]; x+=2)
    !((a[y] || [])[x]+1) && (y+=4,x=0,c+=`\n`)

这是声明每个变量的地方。x并且y是“光标”的位置（当前盲文字符的左上边缘）。当没有索引的行时，x坐标每次迭代增加2，然后停止y（undefined如果a [x] 不存在，则返回，并转换为false）。

第二行有很多技巧。(a[y] || [])[x]确保在该(x, y)位置查找值不会引发错误。的&&是通常的和运营商，并且它仅检查表达式的右侧，如果左侧是真实的。这可以翻译成

if (!((a[y] || [])[x] + 1)) 
    y+=4,x=0,c+=`\n`

下一部分：

c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k,N")+g(x,y+3)*64+g(x+1,y+3)*128)

String.fromCharCode只需将传递的数字转换为具有相同字符代码的Unicode字符。括号中的表达式计算盲文字符的索引：

for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k

通过中的位置

1 4
2 5
3 6

顺序，将这些位置的值乘以2 ⁱ，其中i是索引并将它们相加。的

g=(x,y)=>(a[y]||[])[x]||0

part声明了一个名为的lambda函数g，给定一个x和y坐标，则返回该(x, y)位置的值，或者如果该位置位于数组范围之外，则返回0。

+g(x,y+3)*64+g(x+1,y+3)*128

该部分使用之前定义的功能将具有正确权重的最后两个位置相加。

最后但并非最不重要的是

a=>eval('...')

部分具有2个功能。它定义了一个匿名lambda并确保for循环不会引起任何问题（像这样的单行lambda不能仅包含一个for循环，评估可以避免此问题）。

Mathematica，126 110 97 90

FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

该解决方案利用了在一个矩阵ListCorrelate上卷积一个（反转的）核，该矩阵本质上是一个滑动矩阵乘法（或点积）。在此处查看视觉说明。通过0用作第四个参数来完成填充。在以下示例中，我们希望结果与上面的提示匹配：

ListCorrelate[
  2^{{0, 3}, {1, 4}, {2, 5}, {6, 7}},
  {{b0, b3}, {b1, b4}, {b2, b5}, {b6, b7}}
]

(* returns {{b0 + 2 b1 + 4 b2 + 8 b3 + 16 b4 + 32 b5 + 64 b6 + 128 b7}} *)

请注意，ListConvolve它并不短，因为第三个参数是-1。

由于这将内核应用于矩阵的每个位置，因此我们只需要提取每第四行和第二列中的元素。我们用速记的Span和Part：[[;;;;4,;;;;2]]。

有用的是，FromCharacterCode可以采用字符代码矩阵并返回字符串列表。

此解决方案返回字符串列表，这是允许的输出格式之一。只需Column@在输出之前加上“看起来像矩阵”即可。

您可以在免费的在线Mathematica笔记本中进行操作。转到此处，单击“创建新笔记本”，稍等片刻，粘贴此代码，然后按shift+enter。

m1={{0,1,0,0,1,0},{1,0,0,0,0,0},{1,0,0,0,1,0},{1,1,1,1,0,0}};
m2={{0,1,0},{1,0,0},{1,1,1}};
m3={{0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0},{0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1},{0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1},{1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1},{1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0},{1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0},{1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0},{1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1},{1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0},{1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0},{0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},{0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0},{0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0}};

MatrixToBraille := Column@
  FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

MatrixToBraille/@{m1,m2,m3}

然后，您应该看到以下内容：

Dyalog APL，133 122 114 112 101 100 98 95 94 93 90 88个 86字节

假设 ⎕IO←0

{C⍴{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨(,b)/,⍳⍴b←{0 0≡A|⍵}¨⍳⍴S←⍵↑⍨A×C←⌈(⍴⍵)÷A←4 2}

- 8 9 12在聊天字节由于@亚当

-2个字节，感谢@ngn

在线尝试！

怎么样（输入是⍵）？

• A←4 2，将向量存储4 2在变量中A
• (⍴⍵)÷，尺寸⍵除以A
• ⌈天花板
• C←，存储在 C
• A×，乘以 A
• ⍵↑⍨，适合⍵这些尺寸
• S←，存储在 S
• ⍳⍴，的索引 S
• {0 0≡A|⍵}¨，1其中，剩一格的顶部，0在其他地方
• (,b)/,⍳⍴b←，真实指标
• {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨，将每个元素变成盲文
• C⍴，将尺寸调整为 C

JavaScript，136个字节

a=>(b=a.map(x=>[]),a.map((l,i)=>l.map((c,j)=>b[i>>2][j>>1]|=c<<'01263457'[i%4+j*4%8])),b.map(l=>l.map(c=>String.fromCharCode(10240+c))))

多亏了ngn，使用位移可以节省4个字节。

蟒2 + drawille，141个 125 120 116字节

由于ngn和L3viathan节省了16个字节

L3viathan节省了5个字节

由于使用了ngn，节省了4个字节

from drawille import*
def a(d,c=Canvas(),e=enumerate):[c.set(j,i)for i,x in e(d)for j,y in e(x)if y];print c.frame()

在线尝试！

tio没有安装绘图笔，因此无法正常工作

APL（Dyalog），57 54字节*

-3多亏了OP。提示输入布尔矩阵。打印字符矩阵。

1↓⎕UCS{2⊥40,⌽(,⍉3↑⍵),⊢⌿⍵}⌺(2 2⍴4 2)⊢0⍪⍣3⍪∘0⍣3⊢⎕,0

在线尝试！

⎕,0 在右边添加零（如果列数为偶数，则忽略）

⊢ 产生那个（分开3和⎕）

⍪∘0⍣3 在底部附加三次零（因为⌺会掉落部分窗口）

0⍪⍣3 在零位顶部堆叠零（因为⌺从左上角开始）

⊢ 产生的收益（将括号和分开0）

{… }⌺(2 2⍴4 2) 在每个4行2列窗口上，具有4行垂直和2行水平步进：

 ⊢⌿⍵ 最后一行（垂直减少垂直方向）； [b6,b7]

 (… ), 前置：

  3↑ 三排； [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ 转置 [[b0,b1,b2],[b3,b4,b5]]

  , 薄纱 [b0,b1,b2,b3,b4,b5]

 现在我们有 [b0,b1,b2,b3,b4,b5,b6,b7]

 ⌽ 相反; [b7,b6,b5,b4,b3,b2,b1,b0]

 40, 前置40（对于40×2 ⁹ = 10240）;[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ 以2为底进行评估（二进制）

⎕UCS 转换为角色

1↓ 删除第一行（由于⌺填充，全零）

*在经典计数⌺的⎕U233A。

Python 3中，168个 165 161字节

def f(m):
 while m:
  r,m,s=[*zip(*m)],m[4:],''
  while r:s+=chr(10240+sum(q<<int(w)for(q,w)in zip((r[0]+(0,)*3)[:4]+(r+[()])[1],'01263457')));r=r[2:]
  print(s)

在线尝试！

145字节的Haskell

(a!b)c=take b$c++repeat a
r([]:_)=[]
r l=['⠀'..]!!(sum.zipWith(*)[1,8,2,16,4,32,64,128]$l>>=0!2):r(drop 2<$>l)
b[]=[]
b s=r(([]!4)s):b(drop 4s)

在线尝试！

Python 3，169字节

a=[]
y=0
for l in eval(input()):
 y-=1;a+=y%4//3*[-~len(l)//2*[10240]];x=0
 for v in l:a[-1][x//2]|=v<<(6429374>>y%4*6+x%2*3&7);x+=1
for l in a:print(*map(chr,l),sep='')

在线尝试！

Perl 5、164字节

163个字节的代码+ 1个标志 -p

@a=eval}{for(;$r<@a;$r+=4){for($c=0;$c<@{$a[0]};$c+=2){$n="0b";map$n.=0|$a[$r+3][$c+$_],1,0;for$y(1,0){map$n.=0|$a[$r+$_][$c+$y],2,1,0}$\.=chr 0x2800+oct$n}$\.=$/}

在线尝试！

将每行逗号分隔在一行上。

APL（Dyalog），53字节

4 2∘{⎕ucs 2⊥40⍪(⍎¨⍕76531420)∘.⊃,¨⍺∘↑¨↓∘⍵¨⍺∘ר⍳⌈⍺÷⍨⍴⍵}

在线尝试！