UTF-8 là một cách tương đối đơn giản để mã hóa các điểm mã Unicode theo định dạng có độ rộng thay đổi sao cho nó không dễ nhầm lẫn mã không nhận biết Unicode.

Tổng quan về UTF-8

• Byte trong phạm vi 1-0x7F, bao gồm, thường có giá trị
• Byte với mẫu bit 10XX XXXXđược coi là byte tiếp tục, với sáu bit có ý nghĩa nhỏ nhất được sử dụng để mã hóa một phần của một điểm mã. Chúng không được xuất hiện trừ khi chúng được mong đợi bởi một byte trước đó.
• Byte với mẫu 110X XXXXmong đợi một byte tiếp tục sau đó
• Byte với mẫu 1110 XXXXmong đợi hai byte tiếp tục sau đó
• Byte với mẫu 1111 0XXXmong đợi ba byte tiếp tục sau đó
• Tất cả các byte khác không hợp lệ và sẽ không xuất hiện ở bất kỳ đâu trong luồng UTF-8. Về lý thuyết, các cụm 5, 6 và 7 byte có thể, nhưng sẽ không được phép cho các mục đích của thử thách này.

Mã hóa quá dài

UTF-8 cũng yêu cầu một mật mã phải được biểu diễn với số byte tối thiểu. Bất kỳ chuỗi byte nào có thể được biểu diễn với ít byte hơn đều không hợp lệ. UTF-8 đã sửa đổi thêm một ngoại lệ cho ký tự null (U + 0000), được thể hiện dưới dạng C0 80(biểu diễn hex)) và thay vào đó không cho phép các byte rỗng xuất hiện ở bất kỳ đâu trong luồng. (Điều này làm cho nó tương thích với các chuỗi kết thúc null)

Thử thách

Bạn phải tạo một chương trình, khi được cung cấp một chuỗi byte, sẽ xác định xem chuỗi đó có đại diện cho UTF-8 đã sửa đổi hợp lệ hay không và sẽ trả về giá trị trung thực nếu hợp lệ và giá trị sai lệch. Lưu ý rằng bạn phải kiểm tra mã hóa quá dài và byte rỗng (vì đây là UTF-8 đã sửa đổi). Bạn không cần giải mã các giá trị UTF-8.

Ví dụ

41 42 43  ==> yes (all bytes are in the 0-0x7F range)
00 01 02  ==> no (there is a null byte in the stream)
80 7F 41  ==> no (there is a continuation byte without a starter byte)
D9 84 10  ==> yes (the correct number of continuation bytes follow a starter byte)
F0 81 82 41  ==> no (there are not enough continuation bytes after F0)
EF 8A A7 91  ==> no (too many continuation bytes)
E1 E1 01  ==> no (starter byte where a continuation byte is expected)
E0 80 87  ==> no (overlong encoding)
41 C0 80  ==> yes (null byte encoded with the only legal overlong encoding)
F8 42 43  ==> no (invalid byte 'F8')

Quy tắc

• Quy tắc chuẩn và sơ hở áp dụng
• Đầu vào và đầu ra có thể ở bất kỳ định dạng thuận tiện nào miễn là tất cả các giá trị trong phạm vi byte không dấu (0-255) có thể được đọc.
  • Bạn có thể cần phải sử dụng một mảng hoặc tệp chứ không phải là một chuỗi kết thúc null. Bạn cần có khả năng đọc byte rỗng.
• Mã ngắn nhất sẽ thắng!
• Lưu ý rằng việc sử dụng nội dung để giải mã UTF-8 không được đảm bảo tuân thủ các yêu cầu được đưa ra ở đây. Bạn có thể cần phải làm việc xung quanh nó và tạo ra các trường hợp đặc biệt.

EDIT: phần thưởng được thêm vào khi không sử dụng nội dung giải mã UTF-8

EDIT2: đã xóa phần thưởng vì chỉ có câu trả lời Rust đủ điều kiện và thật khó để xác định.

Thuốc tiên , 69 byte

import String
&valid? replace replace(&1,<<0>>,"\xFF"),"\xC0\x80","0"

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

Làm cho việc sử dụng chức năng xác nhận chuỗi tích hợp. Đưa đầu vào dưới dạng nhị phân Elixir.

APL (Dyalog Unicode) , 41 39 byte ^SBCS

Chức năng tiền tố ẩn danh. Lấy một chuỗi Unicode làm đối số trong đó các điểm mã của các ký tự đại diện cho các byte đầu vào.

{0::0⋄×⌊/'UTF-8'⎕UCS⍣2⎕UCS⍵}'À\x80'⎕R⎕A

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

'À\x80'⎕R⎕A R eplace C0 80s với chữ hoa A lph.us

{... } áp dụng các chức năng ẩn danh sau đây, nơi mà các đối số là ⍵:

 0:: nếu có lỗi xảy ra:

  0 trả về số không

 ⋄ thử:

  ⎕UCS⍵ chuyển đổi chuỗi thành điểm mã

  'UTF-8'⎕UCS⍣2 diễn giải dưới dạng byte UTF-8 và chuyển đổi văn bản kết quả thành byte

  ⌊/ byte thấp nhất (không nếu có byte rỗng, dương nếu không, "vô cực" nếu chuỗi rỗng)

  × dấu (không nếu có byte null, một nếu không)

Python 2 , 104 102 byte

''.join(chr(int(c,16))for c in input().replace('00','-').replace('C0 80','0').split()).decode('utf-8')

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

Đầu ra thông qua mã thoát

Rust - 191 byte 313 byte

Mỗi bình luận dưới đây ban đầu không hoạt động đúng. Phiên bản mới và cải tiến. Không có thư viện nào được sử dụng, vì Mighty Rust không cần bạn và thư viện của bạn. Mã này sử dụng khớp mẫu với máy trạng thái. Bằng cách xấu hổ xé toạc thông số UTF8 , sau khi tìm thấy nó thông qua tham chiếu và thảo luận của Jon Skeet , chúng ta có thể sao chép thông số gần như ký tự cho nhân vật vào khối khớp mẫu phù hợp. Cuối cùng, chúng tôi thêm vào yêu cầu Mutf8 đặc biệt của Beefster cho C0 80 để được coi là hợp lệ. Ung dung:

/* http://www.unicode.org/versions/corrigendum1.html
 Code Points        1st Byte    2nd Byte    3rd Byte    4th Byte
U+0000..U+007F      00..7F           
U+0080..U+07FF      C2..DF      80..BF           
U+0800..U+0FFF      E0          A0..BF      80..BF       
U+1000..U+FFFF      E1..EF      80..BF      80..BF       
U+10000..U+3FFFF    F0          90..BF      80..BF      80..BF
U+40000..U+FFFFF    F1..F3      80..BF      80..BF      80..BF
U+100000..U+10FFFF  F4          80..8F      80..BF      80..BF
*/

let m=|v:&Vec<u8>|v.iter().fold(0, |s, b| match (s, b) {
        (0, 0x01..=0x7F) => 0,
        (0, 0xc2..=0xdf) => 1,
        (0, 0xe0) => 2,
        (0, 0xe1..=0xef) => 4,
        (0, 0xf0) => 5,
        (0, 0xf1..=0xf3) => 6,
        (0, 0xf4) => 7,
        (1, 0x80..=0xbf) => 0,
        (2, 0xa0..=0xbf) => 1,
        (4, 0x80..=0xbf) => 1,
        (5, 0x90..=0xbf) => 4,
        (6, 0x80..=0xbf) => 4,
        (7, 0x80..=0x8f) => 4,
        (0, 0xc0) => 8, // beefster mutf8 null
        (8, 0x80) => 0, // beefster mutf8 null
        _ => -1,
    })==0;

thử nó trên sân chơi rỉ sét