Schneiden Sie ein boolean Matrix in 4x2 Blöcke und machen sie als Braille - Zeichen 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]]

⣎⣀⠅

Mit 0-s auffüllen, wenn die Abmessungen nicht ein Vielfaches von 4 und 2 sind.

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

⠮⠄

Es gelten die üblichen Golfregeln, die sich nach dem Eingabeformat richten. Die Ausgabe sollte entweder die Struktur einer Matrix haben oder wie eine Matrix aussehen, z. B. eine Liste von Zeichenfolgen. Einzelsaite mit Zeilenumbrüchen.

Hinweis: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)ist das Punktmuster

b0 b3
b1 b4
b2 b5
b6 b7

Größerer Test:

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

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

Jelly ,  31  30 Bytes

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

Probieren Sie es online!

Wie?

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 Bytes

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 Bytes gespart dank ngn

3 Bytes gespart dank Luke

Wie es funktioniert

Ich werde den Code in Teile aufteilen und separat darüber sprechen:

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

Hier wird jede Variable deklariert. xund yist die Position des "Cursors" (der obere linke Rand des aktuellen Braillezeichens). Die x-Koordinate wird bei jeder Iteration um 2 erhöht und angehalten, wenn keine Zeile mit dem Index vorhanden ist y(a [x] wird zurückgegeben, undefinedwenn es nicht vorhanden ist, was in false konvertiert wird).

In der zweiten Reihe gibt es mehrere Tricks. (a[y] || [])[x]stellt sicher, dass das Nachschlagen des Werts an der (x, y)Position keinen Fehler verursacht. Das &&ist das Übliche und der Operator und überprüft nur die rechte Seite des Ausdrucks, wenn die linke wahr ist. Dies kann übersetzt werden in

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

Der nächste Teil:

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.fromCharCodekonvertiert einfach die übergebene Nummer in ein Unicode-Zeichen mit demselben Zeichencode. Der Ausdruck in Klammern berechnet den Index des Braillezeichens:

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

Geht die Position in der durch

1 4
2 5
3 6

order multipliziert die Werte an diesen Positionen mit 2 ⁱ , wobei i der Index ist, und addiert sie zusammen. Das

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

part deklariert eine aufgerufene Lambda-Funktion g, die bei xund y-Koordinate entweder den Wert an der (x, y)Position oder 0 zurückgibt, wenn die Position außerhalb der Grenzen des Arrays liegt.

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

Dieser Teil addiert die letzten beiden Positionen mit den korrekten Gewichten unter Verwendung der zuvor definierten Funktion.

Last but not least die

a=>eval('...')

Teil hat 2 Funktionen. Es definiert ein anonymes Lambda und stellt sicher, dass die for-Schleife keine Probleme verursacht (ein einzeiliges Lambda wie dieses kann keine einzige for-Schleife enthalten, eine Auswertung umgeht dies).

Mathematica, 126 110 97 90

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

Diese Lösung nutzt den Vorteil ListCorrelate, einen (umgekehrten) Kernel über eine Matrix zu falten , bei der es sich im Wesentlichen um eine Gleitmatrixmultiplikation (oder ein Skalarprodukt) handelt. Eine visuelle Erklärung finden Sie hier . Das Auffüllen erfolgt mit 0dem vierten Argument. Im folgenden Beispiel erwarten wir, dass das Ergebnis dem obigen Hinweis entspricht:

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

Beachten Sie, dass dies ListConvolvenicht kürzer ist, da das dritte Argument wäre -1.

Da dies den Kernel an jeder Position der Matrix anwendet, müssen wir nur die Elemente in jeder vierten Zeile und zweiten Spalte extrahieren. Wir verwenden Kürzel für Spanund Part: [[;;;;4,;;;;2]].

Hilfreich, FromCharacterCodekann eine Matrix von Zeichencodes nehmen und eine Liste von Zeichenfolgen zurückgeben.

Diese Lösung gibt eine Liste von Zeichenfolgen zurück, bei der es sich um eines der zulässigen Ausgabeformate handelt. Stellen Sie einfach vor, Column@dass die Ausgabe wie eine Matrix aussieht.

Sie können damit in einem kostenlosen Online-Mathematica-Notizbuch herumspielen. Gehen Sie hier , klicken Sie auf ein neues Notebook erstellen, warten Sie einen Moment, in diesem Code einfügen, dann drücken 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}

Dann solltest du folgendes sehen:

Dyalog APL, 133 122 114 112 101 100 98 95 94 93 90 88 86 Bytes

Geht davon aus ⎕IO←0

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

- 8 9 12 Bytes dank @ Adám im Chat

-2 Bytes dank @ngn

Probieren Sie es online!

Wie (Eingabe ist ⍵)?

• A←4 2Speichern Sie den Vektor 4 2in VariableA
• (⍴⍵)÷, die Dimensionen ⍵geteilt durchA
• ⌈Decke
• C←, gespeichert in C
• A×, multipliziert mit A
• ⍵↑⍨passen ⍵zu diesen Dimensionen
• S←, gespeichert in S
• ⍳⍴, Indizes von S
• {0 0≡A|⍵}¨, 1wo sich die obere linke Ecke einer Zelle befindet, 0überall sonst
• (,b)/,⍳⍴b←, wahrheitsgemäße Indizes
• {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, verwandle jedes Element in Braille
• C⍴Umformen der Maße auf C

JavaScript, 136 Bytes

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

Dank ngn sparen Sie mit Bitverschiebungen 4 Bytes.

Python 2 + Drawille , 141 125 120 116 Bytes

16 Bytes dank ngn und L3viathan eingespart

5 Bytes gespart dank L3viathan

4 Bytes gespart dank 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()

Probieren Sie es online!

tio hat keine Drawille installiert und funktioniert daher nicht

APL (Dyalog) , 57 54 Byte *

-3 dank OP. Fordert zur Eingabe einer Booleschen Matrix auf. Druckt die Zeichenmatrix.

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

Probieren Sie es online!

⎕,0 füge rechts eine Null an (ignoriert wenn gerade Anzahl von Spalten)

⊢ ergeben, dass (zu trennen 3und ⎕)

⍪∘0⍣3 füge dreimal Nullen am unteren Rand an (da ⌺Teilfenster wegfallen)

0⍪⍣3 stapeln Sie Nullen dreimal nach oben (weil ⌺in der oberen linken Ecke beginnt)

⊢ ergeben, dass (trennt die Klammer und 0)

{… In }⌺(2 2⍴4 2) jedem 4-zeiligen 2-Spalten-Fenster mit 4-zeiliger vertikaler und 2-zeiliger horizontaler Stufe:

 ⊢⌿⍵ letzte Reihe (lit. vertikale rechte Verkleinerung); [b6,b7]

 (… ), Voranstellen:

  3↑ Nimm drei Reihen. [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ transponieren; [[b0,b1,b2],[b3,b4,b5]]

  , Ravel; [b0,b1,b2,b3,b4,b5]

 jetzt haben wir [b0,b1,b2,b3,b4,b5,b6,b7]

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

 40, voranstellen 40 (für 40 × 2 ⁹ = 10240);[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ als Basis 2 (binär) auswerten

⎕UCS in Charakter umwandeln

1↓ Lasse die erste Zeile fallen (Null wegen der ⌺Polsterung)

* Bei Classic gilt ⌺als ⎕U233A.

Python 3 , 168 165 161 Bytes

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)

Probieren Sie es online!

Haskell , 145 Bytes

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

Probieren Sie es online!

Python 3 , 169 Bytes

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

Probieren Sie es online!

Perl 5 , 164 Bytes

163 Byte Code + 1 Flag -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}$\.=$/}

Probieren Sie es online!

Nimmt jedes Zeilenkomma getrennt in eine Zeile.

APL (Dyalog) , 53 Bytes

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

Probieren Sie es online!