Und nein, dies ist keine Kopie von ASCII-Text in Blindenschrift übersetzen .

In Unicode gibt es 2 ⁸ = 256 Braillemuster . (Mit "Blindenschrift" meine ich 8-Zellen)

W, warte. Wie viele ASCII-Zeichen gab es?

2 ⁷ = 128 & le;

Nun, lassen Sie uns ASCII in Blindenschrift umwandeln, denn es gibt absolut keinen Grund, dies nicht zu tun!

Der Weg von ASCII nach Braille

Wir können sehen, dass jede Zelle ein Bit darstellt, welches jede Zelle "gelocht" ist oder nicht.

Jetzt können wir jede Zelle zuweisen, um die Bits des ASCII-Zeichens als binär darzustellen.

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

^{* ( - )ist leer}

Jetzt können wir ASCII nach Braille konvertieren. Zum Beispiel ist A(65 = 01000001) gleich ⠡.

Beispiele

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}

Probieren Sie es online!

Erläuterung

Die Blindenschrift-Codepunkte sind ordentlich angeordnet, so dass die einzelnen Punkte in binärer Form hochgezählt werden. Die Reihenfolge der Bits in den Codepunkten ist jedoch unterschiedlich. Wir wollen die folgende Reihenfolge:

04
15
26
37

Während die Zeichen in Unicode in dieser Reihenfolge angeordnet sind:

03
14
25
67

(Was irgendwie Sinn macht, weil in der Vergangenheit in Braille nur die ersten sechs Punkte verwendet wurden.) Beachten Sie, dass wir den 7Punkt nicht benötigen , da die Eingabe garantiert im ASCII-Bereich liegt. [6 5 4 3 2 1 0]Wenn wir also eine Liste von Bits eines Eingabezeichens haben, wollen wir sie neu anordnen [3 6 5 4 2 1 0], um das Bit, das den linken unteren Punkt darstellt, an die höchstwertige Position zu ziehen.

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 Byte

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

Probieren Sie es online!

CJam , 27 Bytes

1 Byte von Neil gestohlen.

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

Probieren Sie es online!

Erläuterung

Dies verwendet die gleiche Grundidee wie meine andere CJam-Antwort , verwendet jedoch bitweise Arithmetik anstelle von Basiskonvertierung und Listenmanipulation, um die Bits neu zu ordnen.

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)).'"');

Online Version

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]

Davon sind +60 Bytes in langen Funktionsnamen gebunden.

Jelly , 21 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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.

Netzhaut , 59 Bytes

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

Probieren Sie es online! Hex-Dump:

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

Probieren Sie es online!

Inspiration von @ovs und @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

Probieren Sie es online!

Ich vermute, ich kann mehr Golf spielen, ich muss nur herausfinden, wie ...

Der Chip liest jedes Byte der Eingabe als eine Sammlung von Bits ein, auf die sich die ersten acht Buchstaben des Alphabets beziehen (Großbuchstaben werden eingegeben, Kleinbuchstaben werden ausgegeben):

HGFEDCBA

Wir müssen diese Bits der Eingabe einfach den folgenden drei Bytes der Ausgabe zuordnen:

11100010 101000hd 10gfecba

Die obere Hälfte des Codes übernimmt die gesamte Sequenzierung und generiert die ersten beiden Bytes, die untere Hälfte generiert das dritte Byte.

Da die Spezifikation nur die Verarbeitung von 7 Bit für ASCII erfordert, wird dies nicht untersucht H. Ändern Sie die Zeile B/bin, um das achte Bit einzuschließen B/b/H.