E não, isso não é uma brincadeira de traduzir texto ASCII para braille .

Existem 2 ⁸ = 256 padrões Braille em Unicode. (Por 'Braille' quero dizer células de 8 células)

W, espera. Quantos caracteres ASCII havia?

2 ⁷ = 128?

Bem, então, vamos transformar ASCII em Braille, porque não há absolutamente nenhuma razão para não!

O caminho de ASCII, para Braille

Podemos ver que cada célula representa um pouco, e cada célula é 'perfurada' ou não.

Agora podemos alocar cada célula para representar os bits do caractere ASCII como binários.

(1  )(16 )
(2  )(32 )
(4  )(64 )
(8  )( - )

^{* ( - )está em branco}

Agora podemos converter ASCII para Braille. Por exemplo, A(65 = 01000001) é igual a ⠡.

Exemplos

Input -> Output
Braille! -> ⠢⠺⠱⡱⡴⡴⠵⠑
(Upscaled)
.. .o o. o. .. .. o. o.
o. oo .o .o .o .o .o .o
.o .o .o .o oo oo oo ..
.. .. .. o. o. o. .. ..

CJam , 27 26 bytes

80qf{i2b7Te[4/~\)\@+++2bc}

Experimente online!

Explicação

Os pontos do código Braille são ordenados ordenadamente para que os pontos individuais sejam contados em binário. No entanto, a ordem dos bits nos pontos de código é diferente. Queremos a seguinte ordem:

04
15
26
37

Enquanto os caracteres estão dispostos em Unicode nesta ordem:

03
14
25
67

(O que meio que faz sentido, porque historicamente, o Braille usou apenas os seis primeiros pontos.) Observe que não precisamos do 7ponto, pois a entrada é garantida como estando na faixa ASCII. Portanto, dada uma lista de bits [6 5 4 3 2 1 0]de um caractere de entrada, queremos reordená-los para [3 6 5 4 2 1 0]que o bit que representa o ponto inferior esquerdo seja colocado na posição mais significativa.

80     e# Push 80... we'll need this later.
q      e# Read all input.
f{     e# Map this block onto each character, putting a copy of the 80
       e# below each character.
  i    e#   Convert the character to its code point.
  2b   e#   Get its binary representation.
  7Te[ e#   Pad it to 7 bits with zeros. We've now got some bit list
       e#   [6 5 4 3 2 1 0].
  4/   e#   Split into chunks of 4: [[6 5 4 3] [2 1 0]]
  ~    e#   Dump them onto the stack: [6 5 4 3] [2 1 0]
  \    e#   Swap them: [2 1 0] [6 5 4 3]
  )    e#   Pull off the last element: [2 1 0] [6 5 4] 3
  \    e#   Swap: [2 1 0] 3 [6 5 4]
  @    e#   Rotate: 3 [6 5 4] [2 1 0]
  ++   e#   Concatenate twice: [3 6 5 4 2 1 0]
       e#   That's the reordering done.
  +    e#   Prepend the 80. That puts it in the 2^7 position of the
       e#   binary digit list, which gives it a value of 10240, which
       e#   is where the Braille characters start.
  2b   e#   Convert the bits back to an integer.
  c    e#   Convert the code point to the corresponding integer.
}%

JavaScript (ES6), 83 bytes

f=
s=>s.replace(/./g,c=>String.fromCharCode((c=c.charCodeAt())&7|c*8&64|c/2&56|10240))

<input oninput=o.textContent=f(this.value)><pre id=o>

Python 3 , 98 71 66 bytes

lambda s:''.join(chr(i*8&64|i//2&56|i&7|10240)for i in map(ord,s))

Experimente online!

CJam , 27 bytes

1 byte roubado de Neil.

q{i__8&8*@7&@2/56&++'⠀+}%

Experimente online!

Explicação

Isso usa a mesma idéia básica da minha outra resposta CJam, mas usa aritmética bit a bit em vez de conversão de base e manipulação de lista para reordenar os bits.

q        e# Read all input.
{        e# Map this block over each character...
  i__    e#   Convert the character to its code point and make two copies.
  8&     e#   AND 8. Gives the 4th bit, which we need to move to the 7th place.
  8*     e#   Multiply by 8 to move it up three places.
  @7&    e#   Pull up another copy and take it AND 7. This extracts the three
         e#   least significant bits which shouldn't be moved at all.
  @2/    e#   Pull up the last copy and divide by 2 to shift all bits down
         e#   by one place.
  56&    e#   AND 56. Extracts the three most-significant bits.
  ++     e#   Add all three components back together.
  '⠀+    e#   Add to the empty Braille character which is the offset for all
         e#   the code points and which converts the value to a character.
}%

PHP, 109 bytes

foreach(str_split($argn)as$c)echo json_decode('"\u'.dechex(10240+(($d=ord($c))&7)+($d/2&56)+(($d&8)*8)).'"');

Versão Online

Mathematica 100 Bytes

FromCharacterCode[10240+#~Drop~{4}~Prepend~#[[4]]~FromDigits~2&/@ToCharacterCode@#~IntegerDigits~2]&

Ungolfed:

ToCharacterCode["Braille!0"]
PadLeft@IntegerDigits[%,2]
Prepend[Drop[#,{4}],#[[4]]]&/@%
FromDigits[#,2]&/@%
FromCharacterCode[%+10240]

+60 bytes deste empatado em nomes de funções longos.

Gelatina , 21 bytes

O&€“¬®p‘æ.1,8,.+“'ṁ’Ọ

Experimente online!

Como funciona

O&€“¬®p‘æ.1,8,.+“'ṁ’Ọ  Main link. Argument: s (string)

O                      Ordinal; map all characters to their Unicode code points.
   “¬®p‘               Yield the code points of the enclosed characters in Jelly's
                       code page, i.e., [1, 8, 112].
 &€                    Take the bitwise AND of each code point to the left and the
                       three code points to the right.
          1,8,.        Yield [1, 8, 0.5].
        æ.             Take the dot product of the array to the right and each flat
                       array in the array to the left.
                “'ṁ’   Yield 10240 = 250 × 39 + 239, where 39 and 239 are the
                       indices of ' and ṁ in Jelly's code page.
               +       Add 10240 to all integers to the left.
                    Ọ  Unordinal; convert all code points to their respective 
                       Unicode charcters.

Retina , 59 bytes

T`�-- -'0-7@-GP-W\`-gp-w--(-/8-?H-OX-_h-ox-`⠀-⡿

Experimente online! Despejo hexagonal:

0000  54 60 00 2a 07 10 2a 17  20 2a 17 30 2a 17 40 2a  T`�-- -'0-7@-
0010  47 50 2a 57 5c 60 2a 67  70 2a 77 08 2a 0f 18 2a  GP-W\`-gp-w--
0020  1f 28 2a 2f 38 2a 3f 48  2a 4f 58 2a 5f 68 2a 6f  (-/8-?H-OX-_h-o
0030  78 2a 7f 60 e2 a0 80 2a  e2 a1 bf                 x-`⠀-⡿

C #, 63 bytes

s=>string.Concat(s.Select(c=>(char)(c*8&64|c/2&56|c&7|10240)));

Experimente online!

Inspiração de @ovs e @Neil

Chip ,62 59 bytes

h*
 Z~.
z.g+b
>xv<
||sf
Zx^<
Z< |
A/a/D
B/b
C/c
E/d
F/e
G/f

Experimente online!

Eu suspeito que posso jogar mais, só preciso descobrir como ...

O chip lê cada byte de entrada como uma coleção de bits, referida pelas oito primeiras letras do alfabeto (maiúsculas são inseridas, menor é saída):

HGFEDCBA

Simplesmente precisamos mapear esses bits da entrada para os três bytes a seguir de saída:

11100010 101000hd 10gfecba

A metade superior do código está fazendo todo o seqüenciamento e gera os dois primeiros bytes, a metade inferior gera o terceiro byte.

Como a especificação requer apenas 7 bits para ASCII, não examinamos H. Para incluir o oitavo bit, altere a linha B/bpara B/b/H.