Cortar una matriz booleana de 4x2 bloques y hacerlos como caracteres braille 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]]

⣎⣀⠅

Rellene con 0-s si las dimensiones no son múltiplos de 4 y 2.

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

⠮⠄

Se aplican las reglas habituales de golf, flexible en el formato de entrada. La salida debe tener la estructura de una matriz o verse como una matriz, por ejemplo, una lista de cadenas; cadena única con líneas nuevas.

Sugerencia: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)es el patrón de puntos

b0 b3
b1 b4
b2 b5
b6 b7

Prueba más grande:

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

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

Jalea ,  31  30 bytes

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

Pruébalo en línea!

¿Cómo?

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 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 guardados gracias a ngn

3 bytes guardados gracias a Luke

Cómo funciona

Voy a dividir el código en partes y hablar sobre ellas por separado:

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

Aquí es donde se declara cada variable. xy yes la posición del "cursor" (el borde superior izquierdo del carácter braille actual). La coordenada x aumenta en 2 cada iteración y se detiene cuando no hay una fila con el índice y(a [x] devuelve undefinedsi no existe, que se convierte en falso).

Hay varios trucos en la segunda fila. (a[y] || [])[x]asegura que buscar el valor en la (x, y)posición no arroje un error. El &&es el habitual y el operador, y solo comprueba el lado derecho de la expresión, si el izquierdo era verdadero. Esto se puede traducir a

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

La siguiente parte:

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.fromCharCodesimplemente convierte el número pasado a un carácter unicode con el mismo código de caracteres. La expresión entre paréntesis calcula el índice del carácter Braille:

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

Pasa por la posición en el

1 4
2 5
3 6

orden, multiplica los valores en esas posiciones con 2 ⁱ , donde i es el índice y los suma. los

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

parte declara una función lambda llamada g, que dada una coordenada xy ydevuelve el valor en la (x, y)posición o 0 si la posición se encuentra fuera de los límites de la matriz.

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

Esta parte suma las dos últimas posiciones con los pesos correctos utilizando la función definida un poco antes.

Por último, pero no menos importante, el

a=>eval('...')

La parte tiene 2 funciones. Define una lambda anónima y garantiza que el bucle for no cause ningún problema (una sola línea lambda como esta no puede contener solo un bucle for, una evaluación lo evita).

Mathematica, 126 110 97 90

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

Esta solución aprovecha ListCorrelatepara convolucionar un núcleo (invertido) sobre una matriz , que es esencialmente una multiplicación de matriz deslizante (o producto de puntos). Vea una explicación visual aquí . El relleno se realiza utilizando 0como cuarto argumento. En el siguiente ejemplo, esperamos que el resultado coincida con la sugerencia anterior:

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

Tenga en cuenta que ListConvolveno es más corto, ya que el tercer argumento sería -1.

Como esto aplica el núcleo en cada posición de la matriz, solo necesitamos extraer los elementos en cada cuarta fila y segunda columna. Utilizamos abreviaturas de Spany Part: [[;;;;4,;;;;2]].

Con ayuda, FromCharacterCodepuede tomar una matriz de códigos de caracteres y devolver una lista de cadenas.

Esta solución devuelve una lista de cadenas, que es uno de los formatos de salida permitidos. Simplemente anteponga Column@para que la salida "parezca una matriz".

Puede jugar con esto en un cuaderno gratuito de Mathematica en línea. Vaya aquí , haga clic en Crear un cuaderno nuevo, espere un momento, pegue este código y luego presione 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}

Entonces deberías ver esto:

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

Asume ⎕IO←0

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

- 8 9 12 bytes gracias a @ Adám en el chat

-2 bytes gracias a @ngn

Pruébalo en línea!

¿Cómo (entrada es ⍵)?

• A←4 2, almacena el vector 4 2en variableA
• (⍴⍵)÷, las dimensiones de ⍵dividido porA
• ⌈, techo
• C←, guardado en C
• A×, multiplicado por A
• ⍵↑⍨, se ajusta ⍵a esas dimensiones
• S←, guardado en S
• ⍳⍴, índices de S
• {0 0≡A|⍵}¨, 1donde está la parte superior izquierda de una celda, en 0cualquier otro lugar
• (,b)/,⍳⍴b←, índices de verdad
• {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, convierte cada elemento en braille
• C⍴, remodelar las dimensiones a C

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

Gracias a ngn , el uso de cambios de bit ahorra 4 bytes.

Python 2 + drawille , 141 125 120 116 bytes

Guardado 16 bytes gracias a ngn y L3viathan

Guardado 5 bytes gracias a L3viathan

Guardado 4 bytes gracias a 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()

Pruébalo en línea!

tio no tiene un drawille instalado, por lo que no funciona

APL (Dyalog) , 57 54 bytes *

-3 gracias a OP. Solicita matriz booleana. Imprime la matriz de caracteres.

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

Pruébalo en línea!

⎕,0 agregar un cero a la derecha (ignorado si hay un número par de columnas)

⊢ ceder eso (para separar 3y ⎕)

⍪∘0⍣3 agregue ceros en la parte inferior tres veces (porque ⌺cae ventanas parciales)

0⍪⍣3 apila ceros en la parte superior tres veces (porque ⌺comienza en la esquina superior izquierda)

⊢ producir eso (separa el paréntesis y el 0)

{… }⌺(2 2⍴4 2) En cada ventana de 4 filas y 2 columnas, con paso vertical de 4 filas y horizontal de 2 filas:

 ⊢⌿⍵ última fila (encendido, reducción vertical derecha); [b6,b7]

 (... ), anteponer:

  3↑ toma tres filas; [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ transponer; [[b0,b1,b2],[b3,b4,b5]]

  , enmarañar; [b0,b1,b2,b3,b4,b5]

 ahora tenemos [b0,b1,b2,b3,b4,b5,b6,b7]

 ⌽ marcha atrás; [b7,b6,b5,b4,b3,b2,b1,b0]

 40, anteponer 40 (para 40 × 2 ⁹ = 10240);[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ evaluar como base-2 (binario)

⎕UCS convertir a personaje

1↓ soltar la primera fila (todo cero debido al ⌺relleno de ')

* En Clásico, contando ⌺como ⎕U233A.

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)

Pruébalo en línea!

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)

Pruébalo en línea!

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

Pruébalo en línea!

Perl 5 , 164 bytes

163 bytes de código + 1 bandera -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}$\.=$/}

Pruébalo en línea!

Toma cada fila con una coma separada en una línea.

APL (Dyalog) , 53 bytes

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

Pruébalo en línea!