Braille-Grafiken

46

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

⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀
code-golf ascii-art unicode binary-matrix ngn
quelle
Herzlichen Glückwunsch zur zweiten Herausforderung.
Adám
5
Bessere Beschreibung: Sie haben ein 2D-Array mit Booleschen Werten, deren Zeilen die horizontalen Rasterlinien eines Schwarzweiß-Frame-Puffers (1 Bit pro Pixel) oder eines Grafikbereichs darstellen. Codieren Sie alle 4x2 rechteckigen Blöcke dieser Zeichenfläche in Unicode-Braillezeichen. Füllen Sie die Breite der Zeichenfläche mit Nullen auf ein Vielfaches von 2 und die Höhe mit einem Vielfachen von vier auf, um mit Bruchblöcken an den Kanten umzugehen (oder stellen Sie auf andere Weise die entsprechende Ausgabe sicher und behandeln Sie die Daten so, als wären sie gepolstert).
Kaz
3
@ Kaz Ich weiß nicht, ich persönlich weiß wirklich zu schätzen, wie prägnant dieser Beitrag ist. IMO, nicht viel Klarheit würde durch das Schreiben mehr hinzugefügt werden (abgesehen von ein paar kleinen Klarstellungen wie der Feststellung, dass die Höhe ein Vielfaches von 4 und die Breite von 2 sein sollte); Ihr Vorschlag ist für mich schwerer zu lesen als der aktuelle Beitrag.
Quelklef

Antworten:

10

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
Jonathan Allan
quelle
Ist ḄUnterstützung „Ziffern“ größer als 1? Anstatt 10240 (0x2800 - zwei Bytes) zum Ergebnis hinzuzufügen, können Sie dem Vektor der Binärziffern 40 (0x28 - ein Byte) voranstellen. Ich weiß nicht viel über Jelly, also bin ich mir nicht sicher, ob das wirklich funktionieren würde.
27.
Ḅwürde in der Tat eine führende Ziffer von 40 konvertieren, wie Sie vorschlagen, aber wir müssten sie jeder solchen Liste voranstellen (mit einer Tiefe von 2), was meiner Meinung nach mehr Byte Code ( ;@€€40Ḅ) erfordern würde .
Jonathan Allan
6

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 i , 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).

Bálint
quelle
ein paar einfache vorschläge: ||0-> |0; ~~(k/3)-> (k>2); *128-> <<7(Ersetzen von +-s durch |-s)
ngn
Warum nicht die ES7-Version als primäre Lösung einreichen?
Shaggy
@ Shaggy Noch kann nicht jeder ES7 ausführen, es ist also ein Backup
Bálint
Das ist für diese Teile irrelevant;) Solange es einen einzelnen Interpreter (Browser) gibt, der Ihren Code ordnungsgemäß ausführen kann, wird dies hier als gültig angesehen.
Shaggy
@ngn Danke für die ersten beiden, aber Bitverschiebung hat eine niedrigere Priorität als im Grunde alles, so dass nicht funktioniert
Bálint
6

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:

hftf
quelle
5

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
Zacharý
quelle
Betrachten Sie +/(2*0 3 1,A,4+⍳3)×something→2⊥something[⍎¨⍕76524130]
ngn
Würde das jetzt noch funktionieren, wo ich es geändert habe ⎕IO←0?
Zacharý
Eigentlich würde es nur funktionieren in ⎕IO←0:)
ngn
Ich habe das versucht, mache ich etwas falsch? tio.run/…
Zacharý
Entschuldigung, ich habe dieses blöde Ding ( ⎕IO) in APL vergessen . Für ⎕IO←1, natürlich würden Sie 1 bis jede Ziffer von 76524130. hinzufügen müssen
ngn
4

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.

tsh
quelle
Sie können Bitverschiebungen wie i/4|0->i>>2
ngn
c*2**ist ein bisschen verschieben, auch :)
ngn
4

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

Noskcaj
quelle
Python und seine Batterien! :) Wundert mich nicht. Sie können diese auf unter 120 Byte verkleinern, wenn Sie enumerate()ein Listenverständnis verwenden.
28.
Sparen Sie ein paar Bytes, indem Sie die Funktion zu einem def b(d,c=l.Canvas()):print([c.set(j,i)for i,x in enumerate(d)for j,y in enumerate(x)if y]and c).frame()
Einzeiler machen
Bekam
du brauchst den and ctrick nicht - das verständnis könnte eine ;print c.frame()
aussage
3

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 9 = 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.

Adam
quelle
Es gibt einen einfachen Weg, um ein paar Bytes zu sparen, siehe meinen Kommentar unter der Jelly-Lösung.
ngn
Es muss ein Fehler vorliegen - der TIO-Link stimmt nicht mit dem Code überein, den Sie hier gepostet haben.
10.
Es ist der Null-Padding-Code 0⍪⍣3⍪∘0⍣3⊢⎕,0gegen Ende: vs0⍪∘0⍣3⊢⎕,0
ngn
@ngn Behoben, aber ich habe das Gefühl, dass ⍪∘0⍣3und ,0nur aufgrund eines Fehlers benötigt werden ⌺und der erste für Ihre Testfälle nicht benötigt wird.
Adám,
Meine Testfälle erheben keinen Anspruch auf Vollständigkeit - die Lösung sollte natürlich für jede gültige Eingabe funktionieren. Sie können verkürzen 0⍪⍣3⍪∘0⍣3⊢⍵,0zu 0(⊖⍪)⍣6⊢⍵,0.
ngn
2

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!

TFeld
quelle
Schön golfen! Sie können drei Bytes mit speichern, [*zip(*m[:4])]anstatt aufzurufen list.
Lynn
2

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!

Angs
quelle
1

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!

Lynn
quelle
Sie können if y%4<1:a+=-~len(l)//2*[10240],als umschreiben a+=(y%4<1)*[-~len(l)//2*[10240]]und x=0;y+=1in dieselbe Zeile einfügen . Ich denke, es spart ein Byte.
28.
@ngn hat von da an ein paar Bytes mehr gespart, danke!
Lynn
1

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.

Xcali
quelle
1

APL (Dyalog) , 53 Bytes

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

Probieren Sie es online!

ngn
quelle