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

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

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

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


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:


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
  • , 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

rozważyć +/(2*0 3 1,A,4+⍳3)×something2⊥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.


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


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ą


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{240,⌽(,⍉3↑⍵),⊢⌿⍵}⌺(2 24 2)⊢0⍪⍣3⍪∘03⊢⎕,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.


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!


Ł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!


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!


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.


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.