Графіка Брайля

46

Вирізати булеву матрицю в 4х2 блоків і зробити їх як символи Брайля 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]]

⣎⣀⠅

Прокладка з 0-с, якщо розміри не кратні 4 і 2.

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

⠮⠄

Застосовуються звичайні правила гольфу, гнучкі у форматі введення. Вихідні дані повинні мати структуру матриці або мати вигляд матриці, наприклад, список рядків; один рядок з новими рядками.

Підказка: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)чи точковий візерунок

b0 b3
b1 b4
b2 b5
b6 b7

Більший тест:

[[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
джерело
Вітаю з другим викликом.
— Адам
5
Кращий опис: у вас є двовимірний масив булевих значень, рядки яких представляють горизонтальні растрові лінії чорно-білого (1 біт на піксель) буфера кадру або графічного полотна. Кодуйте всі прямокутні блоки 4x2 цього полотна в символи Брайля Unicode. Для обробки дробових блоків на краях накладайте ширину полотна на кратну 2, а висоту - на кратну чотири, нулями (або іншим чином забезпечуйте еквівалентний вихід, обробляючи дані так, як ніби вони були набиті).
— Каз
3
@Kaz Я не знаю, я особисто дуже ціную, наскільки лаконічна ця публікація. ІМО, не надто багато ясності буде додано, написавши більше (окрім кількох невеликих роз'яснень, як-от зауваження, що висота повинна бути кратною 4, а шириною 2); твою пропозицію мені важче прочитати, ніж нинішня публікація.
— Quelklef

Відповіді:

10

Желе ,  31  30 байт

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

Спробуйте в Інтернеті!

Як?

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
— Джонатан Аллан
джерело
Чи Ḅпідтримує "цифри" більше 1? Замість того, щоб до результату додати 10240 (0x2800 - два байти), ви можете додати 40 (0x28 - один байт) до вектора двійкових цифр. Я мало знаю про Джеллі, тому не впевнений, чи справді це би спрацювало.
— ngn
Ḅдійсно перетворив би провідну цифру 40, як ви пропонуєте, але нам потрібно було б додати її до кожного такого списку (на глибині 2), що, я думаю, вимагало б більше байтів коду ( ;@€€40Ḅ).
— Джонатан Аллан
6

JavaScript ES7 210 207 201 200 198 194 185 183 байт

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 байти збережено завдяки ngn

3 байти збережено завдяки Луці

Як це працює

Я збираюся розділити код на частини і розповісти про них окремо:

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

Тут декларується кожна змінна. xі yє позицією "курсору" (верхній лівий край поточного символу Брайля). Координата x збільшується на 2 за кожну ітерацію, і вона зупиняється, коли немає рядка з індексом y(a [x] повертається, undefinedякщо його немає, який перетворюється на false).

У другому ряду є кілька хитрощів. (a[y] || [])[x]гарантує, що пошук значення в (x, y)позиції не видає помилки. Це &&звичайний і оператор, і він перевіряє лише праву частину виразу, якщо ліва правда. Це можна перекласти на

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

Наступна частина:

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.fromCharCodeпросто перетворює передане число в символ unicode з тим же кодом символів. Вираз у дужках обчислює індекс символу Брайля:

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

Проходить через позицію в

1 4
2 5
3 6

порядку, помножує значення в цих позиціях на 2 i , де i - індекс, і додає їх разом. The

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

частина оголошує лямбда-функцію g, яка називається , яка надає xі yкоординату повертає або значення в (x, y)позиції, або 0, якщо позиція лежить за межами масиву.

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

Ця частина додає дві останні позиції з правильними вагами за допомогою функції, визначеної трохи раніше.

І останнє, але не менш важливе

a=>eval('...')

частина має 2 функції. Він визначає анонімну лямбда і гарантує, що цикл for не викликає жодних проблем (одна лямбда-лінія, така як ця, не може містити єдину для циклу, оцінка обходить це).

— Балінт
джерело
кілька простих пропозицій: ||0-> |0; ~~(k/3)-> (k>2); *128-> <<7(замінюючи +-s на |-s)
— ngn
Чому б не надати версію ES7 як основне рішення?
— Кудлатий
@Shaggy Не всі можуть ще запустити ES7, тому це резервне копіювання
— Bálint
Це не має значення "навколо цих частин;) Поки є один, єдиний інтерпретатор (браузер), який може правильно запустити ваш код, тут він вважається дійсним.
— Кудлатий
@ngn Спасибі за перші два, але бітове зміщення має нижчий пріоритет, ніж в основному будь-що, так що це не спрацює
— Bálint
6

Математика, 126 110 97 90

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

Це рішення має перевагу ListCorrelateв згортку з (зверненим) ядром над матрицею , яка, по суті , ковзне множення матриць (або скалярним твір). Дивіться наочне пояснення тут . Прокладка робиться за допомогою 0четвертого аргументу. У наступному прикладі ми очікуємо, що результат буде відповідати наведеному вище натяку:

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

Зауважте, що ListConvolveце не коротше, оскільки це був би третій аргумент -1.

Оскільки це стосується ядра у кожному положенні матриці, нам просто потрібно витягти елементи у кожному четвертому рядку та другому стовпці. Ми використовуємо Shorthands для Spanі Part: [[;;;;4,;;;;2]].

Корисно, FromCharacterCodeможна взяти матрицю символьних кодів і повернути список рядків.

Це рішення повертає список рядків, що є одним із дозволених форматів виводу. Просто додайте Column@до висновку, що "виглядає як матриця".

Ви можете пограти з цим у безкоштовному онлайн-зошиті Mathematica. Перейдіть сюди , натисніть Створити нову зошит, зачекайте мить, вставте цей код і натисніть 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}

Тоді ви повинні побачити це:

— hftf
джерело
5

Діялог APL, 133 122 114 112 101 100 98 95 94 93 90 88 86 байт

Припускає ⎕IO←0

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

- 8 9 12 байт завдяки @ Adám у чаті

-2 байти завдяки @ngn

Спробуйте в Інтернеті!

Як (вхід є ⍵)?

  • A←4 2, збережіть вектор 4 2у зміннійA
  • (⍴⍵)÷, розміри ⍵поділені наA
  • ⌈, стеля
  • C←, зберігається в C
  • A×, помножений на A
  • ⍵↑⍨, підходять ⍵до цих розмірів
  • S←, зберігається в S
  • ⍳⍴, індекси S
  • {0 0≡A|⍵}¨, 1де знаходиться лівий верхній бік клітинки, і 0скрізь
  • (,b)/,⍳⍴b←, truthy індекси
  • {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, перетворіть кожен елемент на шрифт Брайля
  • C⍴, переформатуйте розміри на C
— Zacharý
джерело
розгляньте +/(2*0 3 1,A,4+⍳3)×something→2⊥something[⍎¨⍕76524130]
— ngn
Хто б це все ще працював зараз, коли я змінив його ⎕IO←0?
— Zacharý
Насправді, це працювало б лише у ⎕IO←0:)
— ngn
Я спробував це, чи роблю щось не так? tio.run/…
— Zacharý
Вибачте, я забув про цю дурну штуку ( ⎕IO) в APL. Бо ⎕IO←1, звичайно, вам доведеться додати 1 до кожної цифри 76524130.
— ngn
4

JavaScript, 136 байт

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

Завдяки ngn , використовуючи бітові зрушення, економте 4 байти.

— тш
джерело
ви можете використовувати бітові зрушення на кшталт i/4|0->i>>2
— ngn
c*2**теж трохи зрушення :)
— ngn
4

Python 2 + drawille , 141 125 120 116 байт

Збережено 16 байт завдяки ngn та L3viathan

Збережено 5 байт завдяки L3viathan

Збережено 4 байти завдяки 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()

Спробуйте в Інтернеті!

У tio не встановлено draille, тому воно не працює

— Noskcaj
джерело
Пітон та його акумулятори! :) Не здивує мене. Ви можете зменшити це до рівня 120 байт, якщо ви використовуєте enumerate()та розуміння списку.
— ngn
Збережіть пару байтів, зробивши функцію 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()
— однолінійною
— L3viathan
вам не потрібна and cхитрість - розуміння може стати твердженням самостійно, після чого;print c.frame()
— пн.
3

APL (Діалог) , 57 54 байти *

-3 завдяки ОП. Підказки до булевої матриці. Друкує матрицю символів.

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

Спробуйте в Інтернеті!

⎕,0 додайте нуль праворуч (ігнорується, якщо парне число стовпців)

⊢ урожай, що (відокремити 3і ⎕)

⍪∘0⍣3 додайте нулі внизу тричі (тому що ⌺випадає часткове вікно)

0⍪⍣3 тричі укладайте нулі (бо ⌺починається у верхньому лівому куті)

⊢ урожай, який (розділяє круглі дужки і 0)

{… У }⌺(2 2⍴4 2) кожному 4-рядковому вікні з двома стовпцями, з 4-рядковим вертикальним та дворядним горизонтальним кроком:

 ⊢⌿⍵ останній ряд (літ. вертикальне зменшення праворуч); [b6,b7]

 (… ), Доплата:

  3↑ візьміть три ряди; [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ переносити; [[b0,b1,b2],[b3,b4,b5]]

  , гребець; [b0,b1,b2,b3,b4,b5]

 тепер у нас є [b0,b1,b2,b3,b4,b5,b6,b7]

 ⌽ зворотний; [b7,b6,b5,b4,b3,b2,b1,b0]

 40, подати 40 (для 40 × 2 9 = 10240);[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ оцінити як базу-2 (двійкові)

⎕UCS перетворити в символ

1↓ опустити перший рядок (усе-нуль через ⌺прокладку 's)

* У Classic, рахуючи ⌺як ⎕U233A.

— Адам
джерело
Існує простий спосіб зберегти кілька байт, дивіться мій коментар під рішенням Jelly.
— ngn
Має бути помилка - посилання TIO не відповідає коду, який ви тут розмістили.
— ngn
це нульовий код під кінець: 0⍪⍣3⍪∘0⍣3⊢⎕,0vs0⍪∘0⍣3⊢⎕,0
— ngn
@ngn Fixed, але у мене є відчуття , що ⍪∘0⍣3і ,0тільки необхідні , з - за помилки в ⌺, і перший з них не потрібно для тестів.
— Adám
Мої тестові випадки не є вичерпними - рішення, безумовно, має працювати для будь-яких дійсних даних. Можна скоротити 0⍪⍣3⍪∘0⍣3⊢⍵,0до 0(⊖⍪)⍣6⊢⍵,0.
— ngn
1

Пітон 3 , 169 байт

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

Спробуйте в Інтернеті!

— Лінн
джерело
Ви можете переписати if y%4<1:a+=-~len(l)//2*[10240],як a+=(y%4<1)*[-~len(l)//2*[10240]]і підходити x=0;y+=1в одному рядку. Я думаю, що це економить байт.
— ngn
@ngn врятував ще кілька байтів, спасибі!
— Лінн
1

Perl 5 , 164 байти

163 байти коду + 1 прапор -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}$\.=$/}

Спробуйте в Інтернеті!

Приймає кожну рядок комою, розділеною на один рядок.

— Xcali
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.