ตัดเมทริกซ์บูลใน 4x2 บล็อกและทำให้พวกเขาเป็นตัวอักษรเบรลล์...U+2800U+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]]

⣎⣀⠅

แผ่นที่มี 0-s หากขนาดไม่ได้เป็นทวีคูณของ 4 และ 2

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

บันทึกได้ 4 ไบต์ด้วย ngn

บันทึกไปแล้ว 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(a [x] จะส่งกลับundefinedหากไม่มีอยู่ซึ่งจะถูกแปลงเป็นเท็จ)

มีลูกเล่นมากมายในแถวที่สอง (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

ส่วนประกาศฟังก์ชั่นแลมบ์ดาที่เรียกว่าgซึ่งได้รับxและyประสานงานส่งกลับค่าที่(x, y)ตำแหน่งหรือ 0 ถ้าตำแหน่งอยู่นอกขอบเขตของอาร์เรย์

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

ส่วนนี้จะรวมสองตำแหน่งสุดท้ายพร้อมกับน้ำหนักที่ถูกต้องโดยใช้ฟังก์ชั่นที่กำหนดไว้ก่อนหน้านี้เล็กน้อย

สุดท้าย แต่ไม่ท้ายสุด

a=>eval('...')

ส่วนที่มี 2 ฟังก์ชั่น มันกำหนดแลมบ์ดานิรนามและสร้างความมั่นใจว่าสำหรับลูปนั้นไม่ได้ทำให้เกิดปัญหาใด ๆ (แลมบ์ดาบรรทัดเดียวเช่นอันนี้ไม่สามารถมีลูปเดียวสำหรับลูปเท่านั้นเท่านั้น

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ที่ไม่สั้นตั้งแต่อาร์กิวเมนต์ที่สามจะเป็น

เนื่องจากสิ่งนี้ใช้เคอร์เนลในทุกตำแหน่งของเมทริกซ์เราจึงต้องแยกองค์ประกอบในแถวที่สี่และคอลัมน์ที่สอง เราใช้ shorthands สำหรับ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 ไบต์ขอบคุณ @ Adámในการแชท

-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

จาวาสคริปต์, 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 ไบต์

Python 2 + drawille , 141 125 120 116 ไบต์

บันทึกแล้ว 16 ไบต์ด้วย ngn และ L3viathan

บันทึก 5 ไบต์ด้วย L3viathan

บันทึกแล้ว 4 ไบต์ด้วย ngn

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 ไม่มี drawille ติดตั้งอยู่จึงไม่ทำงาน

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

  , Ravel; [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)

ลองออนไลน์!

Haskell , 145 ไบต์

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

รหัส 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)∘.⊃,¨⍺∘↑¨↓∘⍵¨⍺∘ר⍳⌈⍺÷⍨⍴⍵}

ลองออนไลน์!