Wyciąć matrycę logiczną w blokach 4x2 i uczynić je jako znaki Braille'a 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]]

⣎⣀⠅

Wpisz 0-s, jeśli wymiary nie są wielokrotnością 4 i 2.

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

⠮⠄

Obowiązują zwykłe zasady gry w golfa, elastyczne w formacie wejściowym. Dane wyjściowe powinny mieć strukturę macierzy lub wyglądać jak macierze, np. Lista ciągów; pojedynczy ciąg z nowymi liniami.

Wskazówka: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)to wzór punktowy

b0 b3
b1 b4
b2 b5
b6 b7

Większy 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]]

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

Galaretka ,  31  30 bajtów

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

Wypróbuj online!

W jaki sposób?

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 bajtów

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 bajty zapisane dzięki ngn

3 bajty zapisane dzięki Łukaszowi

Jak to działa

Podzielę kod na części i będę mówić o nich osobno:

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

Tutaj deklarowana jest każda zmienna. xi yjest pozycją „kursora” (lewa górna krawędź bieżącego znaku brajlowskiego). Współrzędna x zwiększa się o 2 z każdą iteracją i zatrzymuje się, gdy nie ma wiersza z indeksem y(zwraca [x]undefined jeśli nie istnieje, co zostaje przekształcone na false).

W drugim rzędzie jest wiele lew. (a[y] || [])[x]zapewnia, że ​​wyszukiwanie wartości w (x, y)pozycji nie spowoduje błędu. Jest &&to zwykły i operator, i sprawdza tylko prawą stronę wyrażenia, jeśli lewa była prawdziwa. Można to przetłumaczyć na

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

Następna część:

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.fromCharCodepo prostu konwertuje przekazaną liczbę na znak Unicode o tym samym kodzie znaków. Wyrażenie w nawiasach oblicza indeks znaku brajlowskiego:

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

Przechodzi przez pozycję w

1 4
2 5
3 6

porządek, mnoży wartości w tych pozycjach przez 2 ⁱ , gdzie i jest indeksem i dodaje je razem. The

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

część deklaruje wywołaną funkcję lambda g, która podając współrzędną xi yzwraca wartość na (x, y)pozycji lub 0, jeśli pozycja leży poza granicami tablicy.

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

Ta część sumuje ostatnie dwie pozycje z prawidłowymi wagami, używając funkcji zdefiniowanej nieco wcześniej.

Last but not least,

a=>eval('...')

część ma 2 funkcje. Definiuje anonimową lambdę i zapewnia, że ​​pętla for nie powoduje żadnych problemów (lambda z jedną linią, taka jak ta, nie może zawierać tylko jednej pętli for, ocena tego obchodzi).

Mathematica, 126 110 97 90

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

Rozwiązanie to wykorzystuje ListCorrelatesię convolve jest (odwrotnie) na jądro matrycy , która jest zasadniczo przesuwnych mnożenie macierzy (lub produkt kropka). Zobacz objaśnienie wizualne tutaj . Wypełnianie odbywa się za pomocą 0czwartego argumentu. W poniższym przykładzie oczekujemy, że wynik będzie zgodny z powyższą wskazówką:

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

Zauważ, że ListConvolvenie jest on krótszy, ponieważ byłby to trzeci argument-1 .

Ponieważ dotyczy to jądra w każdej pozycji macierzy, musimy tylko wyodrębnić elementy w co czwartym rzędzie i drugiej kolumnie. Używamy skróty dla Spani Part: [[;;;;4,;;;;2]].

Pomocnie, FromCharacterCodemoże wziąć macierz kodów znaków i zwrócić listę ciągów znaków.

To rozwiązanie zwraca listę ciągów, która jest jednym z dozwolonych formatów wyjściowych. Po prostu przygotuj się, Column@aby wynik „wyglądał jak matryca”.

Możesz się tym pobawić w darmowym zeszycie Mathematica online. Idź tutaj , kliknij Utwórz nowy notatnik, poczekaj chwilę, wklej ten kod, a następnie naciśnij 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}

Powinieneś zobaczyć to:

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

Zakłada ⎕IO←0

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

- 8 9 12 bajtów dzięki @ Adám na czacie

-2 bajty dzięki @ngn

Wypróbuj online!

Jak (dane wejściowe ⍵)?

• A←4 2, zapisz wektor 4 2w zmiennejA
• (⍴⍵)÷, wymiary ⍵podzielone przezA
• ⌈, sufit
• C←, przechowywane w C
• A×, pomnożone przez A
• ⍵↑⍨, pasuje ⍵do tych wymiarów
• S←, przechowywane w S
• ⍳⍴, indeksy S
• {0 0≡A|⍵}¨, 1gdzie jest górna lewa komórka, 0wszędzie indziej
• (,b)/,⍳⍴b←, prawdomówne indeksy
• {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, zmień każdy element w brajla
• C⍴, zmień wymiary na C

JavaScript, 136 bajtów

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

Dzięki ngn użycie przesunięć bitowych pozwala zaoszczędzić 4 bajty.

Szuflada Python 2 + , 141 125 120 116 bajtów

Zaoszczędzono 16 bajtów dzięki ngn i L3viathan

Zaoszczędzono 5 bajtów dzięki L3viathan

Zaoszczędzono 4 bajty dzięki 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()

Wypróbuj online!

tio nie ma zainstalowanej szuflady, więc nie działa

APL (Dyalog) , 57 54 bajtów *

-3 dzięki OP. Monity o macierz boolowską. Drukuje matrycę znaków.

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

Wypróbuj online!

⎕,0 dodaj zero po prawej stronie (ignorowane, jeśli parzysta liczba kolumn)

⊢ dają to (do rozdzielenia 3i ⎕)

⍪∘0⍣3 trzy razy dodaj zera na dole (ponieważ ⌺upuszcza częściowe okna)

0⍪⍣3 stos zer na górze trzy razy (ponieważ ⌺zaczyna się w lewym górnym rogu)

⊢ wydajność, która (oddziela nawias i 0)

{… W }⌺(2 2⍴4 2) każdym 4-rzędowym 2-kolumnowym oknie z 4-rzędowym krokiem w pionie i 2 rzędami w poziomie:

 ⊢⌿⍵ ostatni rząd (podświetlony pionowy spadek po prawej); [b6,b7]

 (… ), Prepend:

  3↑ weź trzy rzędy; [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ transponować; [[b0,b1,b2],[b3,b4,b5]]

  , strzępy; [b0,b1,b2,b3,b4,b5]

 teraz mamy [b0,b1,b2,b3,b4,b5,b6,b7]

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

 40, prepend 40 (dla 40 × ²⁹ = 10240);[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ oceniać jako base-2 (binarnie)

⎕UCS przekształcić w postać

1↓ upuść pierwszy rząd (wszystkie zero z powodu ⌺wypełnienia)

* W wersji Classic, licząc ⌺jako ⎕U233A.

Python 3 , 168 165 161 bajtów

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)

Wypróbuj online!

Haskell , 145 bajtów

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

Wypróbuj online!

Python 3 , 169 bajtów

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

Wypróbuj online!

Perl 5 , 164 bajtów

163 bajty kodu + 1 flaga -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}$\.=$/}

Wypróbuj online!

Pobiera przecinek każdego wiersza oddzielony w jednym wierszu.

APL (Dyalog) , 53 bajty

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

Wypróbuj online!