I nie, to nie jest duplikat tłumaczenia tekstu ASCII na Braille'a .

W standardzie Unicode jest 2 ⁸ = 256 wzorów brajlowskich . (Przez „Braille'a” mam na myśli 8-komórkowe)

W, czekaj. Ile było znaków ASCII?

2 ⁷ = 128?

A zatem zamieńmy ASCII w brajla, ponieważ absolutnie nie ma powodu, aby tego nie robić!

Droga z ASCII do brajla

Widzimy, że każda komórka reprezentuje bit, który jest „dziurkowany” lub nie.

Teraz możemy przydzielić każdą komórkę do reprezentowania bitów znaku ASCII jako binarnego.

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

^{* ( - )jest puste}

Teraz możemy przekonwertować ASCII na brajla. Na przykład A(65 = 01000001) jest równe ⠡.

Przykłady

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Punkty kodu brajlowskiego są uporządkowane, dzięki czemu poszczególne kropki liczą się w systemie binarnym. Jednak kolejność bitów w punktach kodowych jest inna. Chcemy następującej kolejności:

04
15
26
37

Podczas gdy znaki są ułożone w Unicode w tej kolejności:

03
14
25
67

(Co to ma sens, ponieważ historycznie Braille używał tylko pierwszych sześciu kropek.) Zauważ, że nie potrzebujemy 7kropki, ponieważ wejście ma gwarantowany zakres ASCII. Biorąc pod uwagę listę bitów [6 5 4 3 2 1 0]znaku wejściowego, chcemy zmienić ich kolejność [3 6 5 4 2 1 0], aby przeciągnąć bit reprezentujący lewą dolną kropkę do najbardziej znaczącej pozycji.

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 bajty

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 bajtów

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

Wypróbuj online!

CJam , 27 bajtów

1 bajt skradziony Neilowi.

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

Wypróbuj online!

Wyjaśnienie

Korzysta z tego samego podstawowego pomysłu, co w mojej innej odpowiedzi CJam, ale używa bitowej arytmetyki zamiast konwersji bazowej i manipulacji listą w celu zmiany kolejności bitów.

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 bajtów

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

Wersja online

Mathematica 100 bajtów

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

Nie golfowany:

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

+60 bajtów tego związanych w długich nazwach funkcji.

Galaretka , 21 bajtów

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

Wypróbuj online!

Jak to działa

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.

Siatkówka , 59 bajtów

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

Wypróbuj online! Zrzut szesnastkowy:

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 bajty

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

Wypróbuj online!

Inspiracje od @ovs i @Neil

Chip ,62 59 bajtów

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

Wypróbuj online!

Podejrzewam, że mogę bardziej zagrać w golfa, muszę tylko dowiedzieć się, jak ...

Chip odczytuje w każdym bajcie wejścia jako zbiór bitów, o których mowa w pierwszych ośmiu literach alfabetu (wielkie litery to wejście, dolne to wyjście):

HGFEDCBA

Musimy po prostu odwzorować te bity danych wejściowych na następujące trzy bajty danych wyjściowych:

11100010 101000hd 10gfecba

Górna połowa kodu wykonuje całe sekwencjonowanie i generuje pierwsze dwa bajty, dolna połowa generuje trzeci bajt.

Ponieważ specyfikacja wymaga obsługi tylko 7 bitów dla ASCII, nie badamy H. Aby dołączyć ósmy bit, zmień wiersz B/bna B/b/H.