Et non, ce n'est pas une dupe de Traduire du texte ASCII en braille .

Il y a 2 ⁸ = 256 motifs braille en Unicode. (Par «braille», je veux dire ceux à 8 cellules)

Attends. Combien de caractères ASCII y avait-il?

2 ⁷ = 128?

Eh bien, transformons l'ASCII en braille, car il n'y a absolument aucune raison de ne pas le faire!

Le chemin de l'ASCII au Braille

Nous pouvons voir que chaque cellule représente un peu, chaque cellule étant «perforée» ou non.

Maintenant, nous pouvons allouer chaque cellule pour représenter les bits du caractère ASCII sous forme binaire.

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

^{* ( - )est vide}

Nous pouvons maintenant convertir ASCII en braille. Par exemple, A(65 = 01000001) est égal à ⠡.

Exemples

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 octets

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

Essayez-le en ligne!

Explication

Les points de code braille sont soigneusement ordonnés afin que les points individuels soient comptés en binaire. Cependant, l'ordre des bits dans les points de code est différent. Nous voulons l'ordre suivant:

04
15
26
37

Alors que les personnages sont disposés en Unicode dans cet ordre:

03
14
25
67

(Ce qui est un peu logique, car historiquement, le braille n'utilisait que les six premiers points.) Notez que nous n'avons pas besoin du 7point, car l'entrée est garantie d'être dans la plage ASCII. Donc, étant donné une liste de bits [6 5 4 3 2 1 0]d'un caractère d'entrée, nous voulons les réorganiser [3 6 5 4 2 1 0], pour tirer le bit représentant le point inférieur gauche à la position la plus significative.

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 octets

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 octets

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

Essayez-le en ligne!

CJam , 27 octets

1 octet volé à Neil.

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

Essayez-le en ligne!

Explication

Cela utilise la même idée de base que mon autre réponse CJam mais utilise l'arithmétique au niveau du bit au lieu de la conversion de base et de la manipulation de liste pour réorganiser les 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 octets

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

Version en ligne

Mathematica 100 octets

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

Non golfé:

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

+60 octets de cela liés à des noms de fonction longs.

Gelée , 21 octets

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

Essayez-le en ligne!

Comment ça marche

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.

Rétine , 59 octets

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

Essayez-le en ligne! Vidage hexadécimal:

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 octets

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

Essayez-le en ligne!

Inspiration de @ovs et @Neil

Chip ,62 59 octets

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

Essayez-le en ligne!

Je pense que je peux jouer au golf plus, je dois juste comprendre comment ...

La puce lit dans chaque octet d'entrée une collection de bits, référencée par les huit premières lettres de l'alphabet (les majuscules sont entrées, les plus basses sont sorties):

HGFEDCBA

Nous devons simplement mapper ces bits de l'entrée aux trois octets de sortie suivants:

11100010 101000hd 10gfecba

La moitié supérieure du code effectue tout le séquençage et génère les deux premiers octets, la moitié inférieure génère le troisième octet.

Étant donné que la spécification nécessite uniquement la gestion de 7 bits pour ASCII, nous n'examinons pas H. Pour inclure le huitième bit, changez la ligne B/ben B/b/H.