Bài tập

Đưa ra một chuỗi UTF-8 (bằng mọi cách) câu trả lời (bằng mọi cách) một danh sách tương đương trong đó mọi phần tử là số byte được sử dụng để mã hóa ký tự đầu vào tương ứng.

Ví dụ

! → 1

Ciao → 1 1 1 1

tʃaʊ → 1 2 1 2

Adám → 1 1 2 1

ĉaŭ→ 2 1 2(ký tự đơn)

ĉaŭ→ 1 2 1 1 2(sử dụng kết hợp lớp phủ)

チャオ → 3 3 3

(đầu vào trống) → (đầu ra trống)

!±≡𩸽 → 1 2 3 4

(Một byte rỗng) → 1

Null byte

Nếu cách duy nhất để tiếp tục đọc đầu vào ngoài byte rỗng là bằng cách biết tổng số byte, bạn có thể lấy số byte bằng bất kỳ phương tiện nào (ngay cả đầu vào của người dùng).

Nếu ngôn ngữ của bạn hoàn toàn không thể xử lý byte rỗng, bạn có thể cho rằng đầu vào không chứa null.

Bình thường, 9 7 byte

Cảm ơn @Maltysen vì đã tiết kiệm 2 byte!

mlc.Bd8

Bộ kiểm tra

Chuyển đổi mọi ký tự của đầu vào thành biểu diễn nhị phân của nó và sau đó chia phần này thành các đoạn có độ dài 8. Số lượng các đoạn đó sau đó là lượng byte cần thiết để mã hóa ký tự đó.

Python 3, 42 36 byte

lambda x:[len(i.encode())for i in x]

C, 68 65 byte

b;main(c){for(;~c;b=c/64^2?b?putchar(b+48)/48:1:b+1)c=getchar();}

Cảm ơn @FryAmTheEggman vì đã chơi golf 3 byte!

Kiểm tra nó trên Ideone .

APL, 15 ký tự

≢¨'UTF-8'∘⎕ucs¨

Trong tiếng Anh: chuyển đổi từng ký tự thành UTF-8 (có nghĩa là: vectơ biểu diễn byte) và lấy số liệu của nó.

GolfScript, 16 byte

{64/2=}%1,/{,)}*

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

Lý lịch

GolfScript không biết Unicode là gì; tất cả các chuỗi (đầu vào, đầu ra, bên trong) được tạo thành từ các byte. Mặc dù điều đó có thể khá khó chịu, nhưng nó hoàn hảo cho thử thách này.

UTF-8 mã hóa các ký tự ASCII và không phải ASCII khác nhau:

• Tất cả các điểm mã dưới 128 được mã hóa thành 0xxxxxxx.

• Tất cả các điểm mã khác được mã hóa thành 11xxxxxx 10xxxxxx ... 10xxxxxx.

Điều này có nghĩa là mã hóa của mỗi ký tự Unicode chứa một 0xxxxxxxbyte đơn hoặc một 11xxxxxxbyte đơn và 1 đến 5 10xxxxxxbyte.

Bằng cách chia tất cả các byte của đầu vào cho 64 , chúng ta biến 0xxxxxxxthành 0 hoặc 1 , 11xxxxxxthành 3 và 10xxxxxxthành 2 .

Nếu chúng ta so sánh thương số với 2 - đẩy 1 cho 2 ; và 0 cho 0 , 1 và 3 - mỗi ký tự sẽ được chuyển thành 0 , theo sau là 1 đến 5 1 's.

Tất cả những gì còn lại là chia chuỗi kết quả tại các lần xuất hiện bằng 0 , đếm số 1 giữa các số 0 đó và thêm một chuỗi vào số tiền.

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

{     }%          Map the following over all bytes in the input.
 64/                Divide the byte by 64.
    2=              Compare the quotient with 2, pushing 1 or 0.
        1,        Push range(1), i.e., [0].
          /       Split the array of Booleans around zeroes.
           {  }*  Fold; for each run of ones but the first:
            ,       Push its length.
             )      Increment.

PowerShell v4, 58 byte

[char[]]$args[0]|%{[Text.Encoding]::UTF8.GetByteCount($_)}

Lưu ý

OK, điều này sẽ hoạt động và thực hiện trong hầu hết các trường hợp thử nghiệm ngoại trừ trường hợp 𩸽nào đó được tính như 3,3trên máy của tôi. Nhân vật đó thậm chí còn hiển thị là 7 byte trên máy tính của tôi. Tôi nghi ngờ đây là do một số loại lỗi trong phiên bản Windows hoặc .NET mà tôi đang chạy cục bộ, vì @Mego không có vấn đề đó . ( Chỉnh sửa: @cat chỉ ra điều này là do BOM . Cảm ơn bạn đã giải quyết bí ẩn đó, @cat! )

Tuy nhiên, điều đó vẫn không giải thích cho tất cả các vấn đề. Tôi nghĩ rằng tôi biết một số vấn đề đến từ đâu, mặc dù. Bên trong .NET, tất cả các chuỗi được tạo thành từ các đơn vị mã UTF-16 (là loại System.Char). Với kiểu truyền hình rất lỏng lẻo mà PowerShell sử dụng, có rất nhiều chuyển đổi và chuyển đổi ngầm định giữa các loại trong nền. Có khả năng đây là một yếu tố góp phần vào hành vi mà chúng ta đang thấy - ví dụ, [system.text.encoding]::utf8.getchars([System.Text.UTF8Encoding]::UTF8.GetBytes('𩸽'))trả về hai dấu vết không thể in được, thay vì một ký tự.

Giải trình

Mã rất đơn giản. Lấy đầu vào $args[0]và chuyển nó thành một mảng char để chúng ta có thể lặp qua từng thành phần của chuỗi |%{...}. Mỗi lần lặp, chúng tôi sử dụng lệnh gọi .NET [System.Text.Encoding]::UTF8.GetByteCount()( System.được ngụ ý) để lấy số byte của ký tự hiện tại $_. Điều đó được đặt trên đường ống cho đầu ra sau này. Vì đó là một tập hợp các [int]trả về, nên việc truyền vào một mảng là ẩn.

Chạy thử

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'tʃaʊ'
1
2
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'Adám'
1
1
2
1

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'ĉaŭ'
2
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'ĉaŭ'
1
2
1
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'チャオ'
3
3
3

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 '!±≡𩸽'
1
2
3
3
3

Đã chỉnh sửa để thêm Điều này không đúng với yêu cầu null-byte đã được thêm vào thử thách sau khi tôi đăng ban đầu, miễn là bạn lấy dữ liệu từ tệp văn bản và chuyển nó như sau:

PS C:\Tools\Scripts\golfing> gc .\z.txt -Encoding UTF8|%{.\bytes-per-character.ps1 $_}
2
1
1
1

JavaScript (ES6), 54 45 43 byte

s=>[...s].map(c=>encodeURI(c).length/3-8&7)

Chỉnh sửa: Đã lưu 2 byte với sự trợ giúp từ @ l4m2.

Ruby, 33 byte

Chỉ đơn giản là cạnh Python, yay! Hãy thử trực tuyến.

->s{s.chars.map{|c|c.bytes.size}}

Perl 6 ,  77 69  63 byte

put +$0 if $_».base(2).fmt("%8d")~~/^(1)**2..*|^(" ")/ while $_=$*IN.read: 1

put +$0 if $_».fmt("%8b")~~/^(1)**2..*|^(" ")/ while $_=$*IN.read: 1

put 1+$0 if $_».fmt("%8b")~~/^1(1)+|^" "/while $_=$*IN.read: 1

put 1+$0 if $_».fmt("%0.8b")~~/^1(1)+|^0/while $_=$*IN.read: 1

Vì Perl 6 sử dụng các chuỗi NFG, tôi phải lấy các byte trực tiếp, điều này vượt qua tính năng này.
(NFG giống như NFC ngoại trừ nó cũng tạo ra các loại tiền mã hóa tổng hợp)

Đầu ra được phân tách bằng dòng mới.

Kiểm tra:

for text in '!' 'Ciao' 'tʃaʊ' 'Adám' 'ĉaŭ' 'ĉaŭ' 'チャオ' '' '!±≡𩸽' '𩸽\0𩸽';
do
  echo -en $text |
  perl6 -e 'put 1+$0 if $_».fmt("%8b")~~/^1(1)+|^" "/while $_=$*IN.read: 1' |

  # combine all of the lines into a single one for display purposes
  env text=$text perl6 -e 'put qq["%*ENV<text>"], "\t\t", lines.gist'
done

"!"     (1)
"tʃaʊ"      (1 2 1 2)
"Adám"      (1 1 2 1)
"ĉaŭ"       (2 1 2)
"ĉaŭ"     (1 2 1 1 2)
"チャオ"       (3 3 3)
""      ()
"!±≡𩸽"     (1 2 3 4)
"𩸽\0𩸽"        (4 1 4)

Giải trình:

# turns the list in ｢$0｣ into a count, and adds one
# ｢put｣ prints that with a trailing newline
put 1+$0 

   # if the following is true
   if

       # format the input byte to base 2 and pad it out to 8 characters
       $_».fmt("%8b")

       ~~ # smart match against

       # check to see if it starts with more than one 1s, or a space
       # ( also sets ｢$0｣ to a list that is 1 shorter
       # than the number of bytes in this codepoint )
       / ^1 (1)+ | ^" " /

           # for every byte in STDIN
           while
               $_ = $*IN.read: 1

Điều này hoạt động vì byte đầu tiên trong một bộ mã nhiều byte có số byte được mã hóa bên trong nó và các byte khác trong bộ mã có tập bit cao nhất, nhưng không phải là cao nhất tiếp theo. Trong khi các điểm mã byte đơn không có tập bit cao nhất.

Python 3, 82 byte

import math
lambda x:[ord(i)<128and 1or int((math.log2(ord(i))-1)//5+1)for i in x]

Câu này dài hơn nhiều so với câu trả lời khác của Python và phần lớn các câu trả lời khác, nhưng sử dụng một cách tiếp cận liên quan đến logarit mà tôi chưa thấy.

Một hàm ẩn danh nhận đầu vào, thông qua đối số, dưới dạng chuỗi và trả về danh sách.

Hãy thử nó trên Ideone

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

Phương pháp này dựa vào cách UTF-8 mã hóa điểm mã của một ký tự. Nếu điểm mã nhỏ hơn 128, ký tự được mã hóa như trong ASCII:

0xxxxxxx

trong đó xđại diện cho các bit của điểm mã. Tuy nhiên, đối với các điểm mã lớn hơn hoặc bằng 128, byte đầu tiên được đệm với cùng số 1s với tổng số byte và các byte tiếp theo bắt đầu 10. Các bit của điểm mã sau đó được nhập vào để đưa ra chuỗi đa bào ngắn nhất có thể và bất kỳ bit nào còn lại sẽ trở thành 0.

No. of bytes  Format
1             0xxxxxxx
2             110xxxxx 10xxxxxx
3             1110xxxx 10xxxxxx 10xxxxxx
4             11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
...           ...

và kể từ đó trở đi.

Bây giờ có thể nhận thấy rằng với mỗi số byte n, giới hạn trên cho số bit điểm mã được đưa ra bởi (-n+7)+6(n-1) = 5n+1. Do đó, điểm mã giới hạn trên ccho mỗi điểm nđược đưa ra, theo số thập phân, theo c= 2^(5n+1). Sắp xếp lại này cho n = (log2(c)-1)/5. Vì vậy, đối với bất kỳ điểm mã nào, số byte có thể được tìm thấy bằng cách đánh giá biểu thức trên và sau đó lấy trần.

Tuy nhiên, điều này không hoạt động đối với các điểm mã trong phạm vi 64 <= c <= 127, vì việc thiếu phần đệm 1do mã hóa giống như ASCII cho các ký tự 1 byte có nghĩa là giới hạn trên sai được dự đoán và log2không được xác định c = 0, xảy ra nếu một byte rỗng có mặt trong đầu vào. Do đó, nếu c <= 127, một giá trị 1được trả về cho n.

Đây chính xác là những gì mã đang làm; đối với mỗi ký tự itrong chuỗi x, điểm mã được tìm thấy bằng cách sử dụng ordhàm và trần của biểu thức được tìm thấy bằng cách sử dụng số nguyên thay vì phân chia float bằng cách 5sau đó thêm 1. Do kiểu float của Python luôn đại diện cho các số nguyên x.0, ngay cả sau khi chia số nguyên, kết quả được truyền cho inthàm để loại bỏ dấu 0. Nếu ord(i) <= 127, ngắn mạch logic có nghĩa 1là thay vào đó được trả lại. Số lượng byte cho mỗi ký tự được lưu trữ dưới dạng một phần tử trong danh sách và danh sách này được trả về.

Java 10, 100 96 95 67 61 byte

a->{for(var c:a)System.out.print(c.getBytes("utf8").length);}

-4 byte loại bỏ khoảng trắng bởi vì điều này được cho phép trong các bình luận
-1 byte thay đổi UTF-8thành utf8
-28 byte đi từ Java 7 đến 8 ( a->{...}thay vì void c(char[]i)throws Exception{...})
-3 byte lấy đầu vào là mảng Chuỗi thay vì mảng ký tự và
-3 byte đi từ Java 8 đến 10 ( varthay vì String)

Giải trình:

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

a->{                      // Method with String-array parameter and no return-type
  for(var c:a)            //  Loop over the input-array
    System.out.print(     //   Print:
      c.getBytes("utf8")  //    The bytes as array in UTF-8 of the current item,
       .length);}         //    and print the amount of bytes in this array

Julia, 34 byte

s->s>""?map(sizeof,split(s,"")):[]

Đây là một hàm ẩn danh chấp nhận một chuỗi và trả về một mảng số nguyên. Để gọi nó, gán nó cho một biến.

Cách tiếp cận khá đơn giản: Nếu đầu vào trống, đầu ra trống. Mặt khác, chúng ta ánh xạ sizeofhàm, tính số byte trong một chuỗi, cho mỗi chuỗi con một ký tự.

Hãy thử trực tuyến! (bao gồm tất cả các trường hợp thử nghiệm)

PHP, 92 57 byte

Về ý nghĩ thứ hai, bạn có thể làm điều này với ít khó khăn hơn nhiều:

<?php for(;$a=strlen(mb_substr($argv[1],$i++,1));)echo$a;

Hãy thử lưu ý trực tuyến rằng nó dài hơn một chút vì nó sử dụng stdin chứ không phải là một đối số chương trình.
Phiên bản này yêu cầu bạn bỏ qua các thông báo gửi đến stderr nhưng không sao .

phiên bản cũ:
Sử dụng một cách tiếp cận khá khác với câu trả lời php khác. Dựa vào việc thiếu hỗ trợ riêng cho các chuỗi nhiều byte trong php.

<?php for($l=strlen($a=$argv[1]);$a=mb_substr($a,1);$l=$v)echo$l-($v=strlen($a));echo$l?:'';

Emacs Lisp, 55 49 byte

(lambda(s)(mapcar'string-bytes(mapcar'string s)))

Đầu tiên phân tích chuỗi thành một danh sách các ký tự với (mapcar 'string s). Các stringchức năng trong Emacs Lisp có một danh sách các nhân vật và xây dựng một chuỗi ra khỏi chúng. Do cách Emacs phân tách các chuỗi với mapcar(nghĩa là thành một danh sách các số nguyên, không phải các ký tự hoặc chuỗi), nên việc chuyển đổi rõ ràng này là cần thiết. Sau đó ánh xạ string-byteshàm vào danh sách các chuỗi đó.

Thí dụ:

(mapcar 'string "abc") ; => ("a" "b" "c")
(mapcar 'string-bytes '("a" "b" "c")) ; => (1 1 1) 

Testcase:

(mapcar
 (lambda(s)(mapcar'string-bytes(mapcar'string s)))
 '("!""Ciao""tʃaʊ""Adám""ĉaŭ""ĉaŭ""チャオ""""!±≡𩸽""\0"))
;; ((1) (1 1 1 1) (1 2 1 2) (1 1 2 1) (2 1 2) (1 2 1 1 2) (3 3 3) nil (1 2 3 4) (1))

Câu trả lời cũ:

(lambda(s)(mapcar(lambda(s)(string-bytes(string s)))s))

Ung dung:

 (lambda (s)
   (mapcar
    ;; we can't use string-bytes directly,
    ;; since Emacs mapcar yields a list of ints instead of characters
    ;; therefore we need a wrapper function here. 
    (lambda (s)
      (string-bytes (string s)))
    s))

Testcase:

(mapcar
 (lambda(s)(mapcar(lambda(s)(string-bytes(string s)))s))
 '("!""Ciao""tʃaʊ""Adám""ĉaŭ""ĉaŭ""チャオ""""!±≡𩸽""\0"))
;; ((1) (1 1 1 1) (1 2 1 2) (1 1 2 1) (2 1 2) (1 2 1 1 2) (3 3 3) nil (1 2 3 4) (1))

JavaScript (Nút), 27 byte

s=>s.map(Buffer.byteLength)

Cái này lấy đầu vào là một mảng các ký tự riêng lẻ và trả về một mảng số byte.

Bufferlà một phương pháp biểu diễn dữ liệu nhị phân thô. Buffer.byteLpm (chuỗi) cho số byte trong chuỗi. UTF-8 là mã hóa mặc định. Lưu ý rằng chỉ có Node.js có bộ đệm, không phải trình duyệt JS. Tương đương trình duyệt thô được gọi là Blob , có 31 byte:

s=>s.map(e=>new Blob([e]).size)

Kiểm tra

Lưu tệp này và chạy nó qua nút hoặc thử trực tuyến .

var f =
  s=>s.map(Buffer.byteLength)

var tests = [
  ["!"],
  ["C","i","a","o"],
  ["t","ʃ","a","ʊ"],
  ["A","d","á","m"],
  ["ĉ","a","ŭ"],
  ["c","̂","a","u","̆"],
  ["チ","ャ","オ"],
  [],
  ["!","±","≡","𩸽"]
];

tests.forEach(test => {
  console.log(test, f(test));
});

Đây sẽ là kết quả:

$ node bytes.js
[ '!' ] [ 1 ]
[ 'C', 'i', 'a', 'o' ] [ 1, 1, 1, 1 ]
[ 't', 'ʃ', 'a', 'ʊ' ] [ 1, 2, 1, 2 ]
[ 'A', 'd', 'á', 'm' ] [ 1, 1, 2, 1 ]
[ 'ĉ', 'a', 'ŭ' ] [ 2, 1, 2 ]
[ 'c', '̂', 'a', 'u', '̆' ] [ 1, 2, 1, 1, 2 ]
[ 'チ', 'ャ', 'オ' ] [ 3, 3, 3 ]
[] []
[ '!', '±', '≡', '�' ] [ 1, 2, 3, 4 ]

Bash, 74 byte

Chơi gôn

xxd -p|fold -2|cut -c1|tr -d '89ab'|echo `tr -t '01234567cbef' '[1*]2234'`

Thuật toán

chuỗi đầu vào hexdump, gấp 2 ký tự trên mỗi dòng, chỉ cắt char đầu tiên

echo -ne '!±≡𩸽' | xxd -p|fold -2|cut -c1

2
c
b
e
8
a
f
a
b
b

(4 bit thứ tự cao của mỗi byte đầu vào dưới dạng hex hex, mỗi bit trên một dòng)

Xóa "byte tiếp tục" 0x80..0xBF

tr -d '89ab'

2
c

e


f

(những gì còn lại, là 4 bit của byte đầu tiên của mỗi char unicode)

ánh xạ các bit đầu tiên vào chiều dài char, thu gọn đầu ra và in

echo `tr -t '01234567cbef' '[1*]2234'`

1 2 3 4

Kiểm tra

 U() { xxd -p|fold -2|cut -c1|tr -d '89ab'|echo `tr -t '01234567cbef' '[1*]2234'`;}

 echo -ne '!' | U 
 1

 echo -ne 'Ciao' | U
 1 1 1 1

 echo -ne 'tʃaʊ' | U
 1 2 1 2

 echo -ne 'Adám' | U
 1 1 2 1

 echo -ne 'ĉaŭ' | U
 2 1 2

 echo -ne 'ĉaŭ' | U
 1 2 1 1 2

 echo -ne 'チャオ' | U
 3 3 3
 echo -ne '!±≡𩸽' | U
 1 2 3 4

 echo -ne "\x0" | U
 1

 echo -ne '' | U

PHP, 126 byte

<?php $s=fgets(STDIN);echo $s!=''?implode(' ',array_map(function($x){return strlen($x);},preg_split('/(?<!^)(?!$)/u',$s))):'';

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

C #, 89 82 byte

I=>{var J="";foreach(char c in I){J+=Encoding.UTF8.GetByteCount(c+"");}return J;};

Một lambda C # đơn giản lặp qua chuỗi và trả về danh sách được phân tách bằng dấu cách.

Chỉnh sửa: lưu 6 byte nhờ một số bình luận rất hay.

Haskell, 85 byte

import Data.ByteString as B
import Data.ByteString.UTF8
(B.length.fromString.pure<$>)

Bình thường, 17 byte

mhxS+11+16,7lCdlC

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

Sử dụng điểm mã của các ký tự với một số mỹ phẩm.

C, 85 byte.

l(unsigned char* c){while(*c){int d=(*c>>4)-11;
d=d<0?1:d+(d==1);putchar(48+d);c+=d;}}

Kiểm tra 4 bit cao của mỗi byte để xác định mã hóa và số byte tiếp theo cần bỏ qua;

Yếu tố, 57 87 82 80 byte

[ [ dup zero? [ drop "1"] [ >bin length 4 /i 10 >base ] if ] { } map-as ""join ]

Giải thích:

USING: kernel math math.parser sequences ;
IN: byte-counts

: string>byte-counts ( str -- counts )
  [                  ! new quotation: takes a char as a fixnum
    dup zero?        ! true if this is a NUL byte
    [ drop "1" ]     ! NUL bytes have length 1
    [ >bin           ! else, convert to binary string
      length         ! length of binary string
      4              ! the constant 4
      /i             ! integer division
      number>string  ! 4 -> "4"
    ] if             ! conditionally execute one of the previous quotations
  ]                  ! end
  { } map-as         ! map and clone-like an { } array
  "" join ;          ! join array of 1strings on empty string

Bài kiểm tra đơn vị:

USING: tools.test byte-counts ;
IN: byte-counts.tests

{ "1" } [ "!" string>byte-counts ] unit-test
{ "1111" } [ "Ciao" string>byte-counts ] unit-test
{ "1212"} [ "tʃaʊ" string>byte-counts ] unit-test
{ "1121" } [ "Adám" string>byte-counts ] unit-test
{ "212" } [ "ĉaŭ" string>byte-counts ] unit-test
{ "12112" } [ "ĉaŭ" string>byte-counts ] unit-test
{ "333" } [ "チャオ" string>byte-counts ] unit-test
{ "" } [ "" string>byte-counts ] unit-test
{ "1234" } [ "!±≡𩸽" string>byte-counts ] unit-test
{ "1" } [ "\0" string>byte-counts ] unit-test

Tất cả đều vượt qua, bây giờ. c:

Swift 2.2, 67 52 50 byte

for c in i.characters{print(String(c).utf8.count)}

Thật xấu xí. Không có cách nào để có được độ dài UTF-8 của một nhân vật trong Swift, vì vậy tôi cần phải lặp qua chuỗi theo ký tự, chuyển đổi Characterthành a Stringvà tìm countký tự đơn đó String(ít nhất, có ít nhất là có tích hợp phương pháp để làm điều đó). Tìm kiếm tối ưu hóa, có thể sử dụng một máy quét.

Bản sửa đổi 1: Đã lưu 15 byte bằng cách sử dụng countthay vì underestimateCount().

Sửa đổi 2: Đã lưu 2 ký tự khác bằng cách sử dụng vòng lặp for-in thay vì cho mỗi lần đóng.

Rust, 53 byte

|s:&str|for c in s.chars(){print!("{}",c.len_utf8())}

Rust có các nguyên thủy utf-8 char, iterators và lambdas, vì vậy điều này rất đơn giản. Mã kiểm tra:

fn main() {
    let s = "Löwe 老虎 Léopard💖💖💖💖";
    let f =|s:&str|for c in s.chars(){print!("{}",c.len_utf8())};
    f(s);
}

Đầu ra

1211133112111114444 

jq, 26 ký tự

(Tùy chọn dòng lệnh 23 ký tự + 3 ký tự)

(./"")[]|utf8bytelength

Hy vọng cạnh tranh. Mặc dù utf8bytelengthđã được thêm 9 ++ tháng trước câu hỏi này, nhưng nó vẫn không được đưa vào phiên bản phát hành.

Chạy mẫu:

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'tʃaʊ'
1
2
1
2

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'ĉaŭ '
1
2
1
1
2
1

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'チャオ'
3
3
3

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< ''

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< '!±≡𩸽'
1
2
3
4

C (gcc) , 53 byte

k=49;f(char*s){*++s/64-2?k=puts(&k)+47:++k;*s&&f(s);}

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

SmileBASIC, 69 byte

DEF C B
WHILE I<LEN(B)Q=INSTR(BIN$(B[I],8),"0")I=I+Q+!Q?Q+!Q
WEND
END

Đầu vào là một mảng byte.

Số lượng byte trong một ký tự UTF-8 bằng với số 1bit dẫn đầu trong byte đầu tiên (trừ khi không có 1s, trong trường hợp đó là ký tự là 1 byte). Để tìm số lượng 1 hàng đầu, chương trình tìm đầu tiên 0trong biểu diễn nhị phân, sau đó thêm 1 nếu đây là 0.

0xxxxxxx - no leading ones, 1 byte
110xxxxx 10xxxxxx - 2 leading ones, 2 bytes
1110xxxx 10xxxxxx 10xxxxxx - 3 leading ones, 3 bytes
etc.

F #, 59 54 66 byte

(s)=seq{for c in s->System.Text.Encoding.UTF8.GetByteCount([|c|])}

Về mặt kỹ thuật, s là một chuỗi char, nhưng hóa ra có một chuyển đổi ngầm cho phép một chuỗi được truyền vào.

Khi kiểm tra điều này trong bảng điều khiển với !±≡𩸽, nó sẽ chia kanji thành hai ký tự, mỗi ký tự dài 3 byte. Tất cả các trường hợp thử nghiệm khác hoạt động tốt.

Chỉnh sửa: Hóa ra nhập không gian tên phổ biến không ẩn. Lên thêm 12 ký tự.

05AB1E , 15 byte

ÇεDžy‹i1ë.²<5÷>

Hãy thử trực tuyến.
Tiêu đềεđược sử dụng để for-every trên tất cả các trường hợp thử nghiệm;
Footerï]J]»để in đẹp các danh sách ký tự đầu ra (ï: số thập phân và ký tự cho số nguyên ;]: close if-other và for-every ;J: Nối các chữ số với nhau ;}: đóng tiêu đề foreach ;»: Nối theo dòng mới).

Giải trình:

Ç                   # Convert each character to its unicode value
 εD                 # Foreach over this list
      i             #  If the current item
     ‹              #  is smaller than
   žy               #  128
       1            #   Use 1
        ë           #  Else
         .²         #   Use log_2
           <        #   minus 1
            5÷      #   integer-divided by 5
              >     #   plus 1

Vì 05AB1E không có bất kỳ nội trang nào để chuyển đổi ký tự thành số byte được sử dụng, tôi sử dụng Çđể chuyển đổi các ký tự thành giá trị unicode của chúng và trong mỗi for thực hiện các thao tác sau trong mã giả:

if(unicodeValue < 128)
  return 1
else
  return log_2(unicodeValue-1)//5+1    # (where // is integer-division)

Lấy cảm hứng từ câu trả lời Python 3 của @TheBikingViking .

Zsh , 41 byte

for c (${(s::)1})set +o multibyte&&<<<$#c

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

Zsh nhận biết UTF-8, vì vậy chúng tôi chia chuỗi trên các ký tự, sau đó vô hiệu hóa đa chuỗi và in độ dài của mỗi ký tự.