Grafika brajlowska

46

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

⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀
code-golf  ascii-art  unicode  binary-matrix 
— ngn
źródło
Gratulujemy drugiego wyzwania.
— Adám
5
Lepszy opis: masz tablicę 2D wartości boolowskich, których rzędy reprezentują poziome linie rastrowe czarno-białego (1 bit na piksel) bufora ramki lub obszaru graficznego. Zakoduj wszystkie prostokątne bloki 4x2 tego płótna na znaki brajlowskie Unicode. Aby obsłużyć ułamkowe bloki na krawędziach, dopełnij szerokość płótna do wielokrotności 2, a wysokość do wielokrotności czterech, zerami (lub w inny sposób zapewnij równoważne wyjście, traktując dane tak, jakby były tak wypełnione).
— Kaz
3
@Kaz Nie wiem, osobiście bardzo doceniam zwięzłość tego postu. IMO nie dodałoby więcej jasności, pisząc (oprócz kilku drobnych wyjaśnień, takich jak zauważenie, że wysokość powinna być wielokrotnością 4, a szerokość 2); twoja sugestia jest dla mnie trudniejsza do odczytania niż obecny post.
— Quelklef,

Odpowiedzi:

10

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
— Jonathan Allan
źródło
Czy Ḅobsługuje „cyfry” większe niż 1? Zamiast dodawać 10240 (0x2800 - dwa bajty) do wyniku, można dodać 40 (0x28 - jeden bajt) do wektora cyfr binarnych. Nie wiem dużo o Jelly, więc nie jestem pewien, czy to naprawdę zadziała.
— ngn
Ḅrzeczywiście przekonwertowałby wiodącą cyfrę 40, jak sugerujesz, ale musielibyśmy dodać ją do każdej takiej listy (na głębokości 2), która, jak sądzę, wymagałaby więcej bajtów kodu ( ;@€€40Ḅ).
— Jonathan Allan
6

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

— Bálint
źródło
kilka prostych sugestii: ||0-> |0; ~~(k/3)-> (k>2); *128-> <<7(zamieniając +-s na |-s)
— ngn
Dlaczego nie przesłać wersji ES7 jako podstawowego rozwiązania?
— Shaggy
@Shaggy Nie każdy może jeszcze uruchomić ES7, więc jest to kopia zapasowa
— Bálint
To nie ma znaczenia dla tych części;) Tak długo, jak istnieje jeden, pojedynczy interpreter (przeglądarka), który może poprawnie uruchamiać Twój kod, tutaj jest to uważane za prawidłowe.
— Shaggy
@ngn Dzięki za pierwsze dwa, ale zmiana bitów ma niższy priorytet niż w zasadzie wszystko, więc to nie zadziała
— Bálint
6

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:

— hftf
źródło
5

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
— Zacharý
źródło
rozważyć +/(2*0 3 1,A,4+⍳3)×something→2⊥something[⍎¨⍕76524130]
— ngn
CZY mógłbyś nadal działać teraz, kiedy to zmieniłem ⎕IO←0?
— Zacharý
Właściwie to działałoby tylko w ⎕IO←0:)
— ngn
Próbowałem tego, czy robię coś złego? tio.run/…
— Zacharý
Przepraszam, zapomniałem o tej głupiej rzeczy ( ⎕IO) w APL. Bo ⎕IO←1oczywiście musisz dodać 1 do każdej cyfry 76524130.
— ngn
4

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.

— tsh
źródło
możesz użyć przesunięć bitowych, takich jak i/4|0->i>>2
— ngn
c*2**też jest trochę przesunięty :)
— ngn
4

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

— Noskcaj
źródło
Python i jego baterie! :) Nie dziwi mnie. Możesz go zmniejszyć do mniej niż 120 bajtów, jeśli używasz enumerate()i rozumiesz listę.
— ngn
Zaoszczędź kilka bajtów, czyniąc tę ​​funkcję 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()
— jednowierszową
— L3viathan
nie potrzebujesz and cpodstępu - zrozumienie może być samodzielnym stwierdzeniem, po którym następuje;print c.frame()
— ngn
3

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 × 29 = 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.

— Adám
źródło
Jest prosty sposób na zaoszczędzenie kilku bajtów, zobacz mój komentarz pod rozwiązaniem Jelly.
— ngn
Musi być błąd - link TIO nie zgadza się z kodem, który tu umieściłeś.
— ngn
jest to kod dopełniania zera pod koniec: 0⍪⍣3⍪∘0⍣3⊢⎕,0vs0⍪∘0⍣3⊢⎕,0
— ngn
@ngn Stałe, ale mam wrażenie, że ⍪∘0⍣3i ,0są potrzebne tylko z powodu błędu w ⌺, a pierwszy z nich nie jest potrzebna dla przypadków testowych.
— Adám
Moje przypadki testowe nie są wyczerpujące - rozwiązanie powinno oczywiście działać dla każdego ważnego wkładu. Możesz skrócić 0⍪⍣3⍪∘0⍣3⊢⍵,0do 0(⊖⍪)⍣6⊢⍵,0.
— ngn
2

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!

— TFeld
źródło
Ładnie grał w golfa! Możesz zapisać trzy bajty [*zip(*m[:4])]zamiast zamiast dzwonić list.
— Lynn
2

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!

— Angs
źródło
1

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!

— Lynn
źródło
Można przerobić if y%4<1:a+=-~len(l)//2*[10240],jak a+=(y%4<1)*[-~len(l)//2*[10240]]i dopasować x=0;y+=1na tej samej linii. Myślę, że to oszczędza bajt.
— ngn
@ngn zapisał jeszcze kilka bajtów, dziękuję!
— Lynn
1

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.

— Xcali
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.