Và không, Đây không phải là bản sao của văn bản Dịch ASCII sang chữ nổi .

Có 2 ⁸ = 256 mẫu chữ nổi trong Unicode. (Theo 'Chữ nổi', ý tôi là những ô 8 ô)

W, đợi đã. Có bao nhiêu ký tự ASCII?

2 ⁷ = 128?

Vậy thì, hãy biến ASCII thành chữ nổi, vì hoàn toàn không có lý do gì để không!

Con đường từ ASCII, đến chữ nổi

Chúng ta có thể thấy mỗi ô đại diện cho một bit, mà mỗi ô được 'đục lỗ' hoặc không.

Bây giờ chúng ta có thể phân bổ từng ô để biểu diễn các bit của ký tự ASCII dưới dạng nhị phân.

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

^{* ( - )trống}

Bây giờ chúng ta có thể chuyển đổi ASCII sang chữ nổi. Ví dụ: A(65 = 01000001) bằng ⠡.

Ví dụ

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 byte

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

Hãy thử trực tuyến!

Giải trình

Các điểm mã chữ nổi được sắp xếp gọn gàng để các dấu chấm riêng lẻ được đếm thành nhị phân. Tuy nhiên, thứ tự của các bit trong các điểm mã là khác nhau. Chúng tôi muốn theo thứ tự sau:

04
15
26
37

Trong khi các ký tự được trình bày bằng Unicode theo thứ tự này:

03
14
25
67

(Điều này có ý nghĩa gì, bởi vì trong lịch sử, chữ nổi chỉ sử dụng sáu dấu chấm đầu tiên.) Lưu ý rằng chúng ta không cần 7dấu chấm, vì đầu vào được đảm bảo nằm trong phạm vi ASCII. Vì vậy, đưa ra một danh sách các bit [6 5 4 3 2 1 0]của một ký tự đầu vào, chúng tôi muốn sắp xếp lại chúng vào [3 6 5 4 2 1 0], để kéo bit đại diện cho dấu chấm dưới cùng bên trái đến vị trí quan trọng nhất.

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 byte

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

Hãy thử trực tuyến!

CJam , 27 byte

1 byte bị đánh cắp từ Neil.

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

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng cùng một ý tưởng cơ bản như câu trả lời khác của tôi về CJam nhưng sử dụng số học bitwise thay vì chuyển đổi cơ sở và thao tác danh sách để sắp xếp lại các bit.

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 byte

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

Phiên bản trực tuyến

Toán học 100 byte

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

Ung dung:

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

+60 byte này được gắn trong các tên hàm dài.

Thạch , 21 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Võng mạc , 59 byte

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

Hãy thử trực tuyến! Đổ lục giác:

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 byte

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

Hãy thử trực tuyến!

Cảm hứng từ @ovs và @Neil

Chip ,62 59 byte

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

Hãy thử trực tuyến!

Tôi nghi ngờ tôi có thể chơi gôn nhiều hơn, chỉ cần tìm ra cách ...

Chip đọc trong mỗi byte đầu vào dưới dạng tập hợp các bit, được gọi bằng tám chữ cái đầu tiên của bảng chữ cái (chữ hoa là đầu vào, thấp hơn là đầu ra):

HGFEDCBA

Chúng ta chỉ cần ánh xạ các bit của đầu vào thành ba byte đầu ra sau:

11100010 101000hd 10gfecba

Nửa trên của mã đang thực hiện tất cả các trình tự và tạo hai byte đầu tiên, nửa dưới tạo ra byte thứ ba.

Vì đặc tả chỉ yêu cầu xử lý 7 bit cho ASCII, chúng tôi không kiểm tra H. Để bao gồm bit thứ tám, thay đổi dòng B/bthành B/b/H.