Xác định độ dài của chuỗi byte UTF-8 cho byte đầu tiên của nó. Bảng sau đây cho thấy phạm vi bản đồ theo từng độ dài có thể:

  Range    Length
---------  ------
0x00-0x7F    1
0xC2-0xDF    2
0xE0-0xEF    3
0xF0-0xF4    4

_{Lưu ý về các khoảng trống trong bảng: 0x80-0xBF là các byte tiếp tục, 0xC0-0xC1 sẽ bắt đầu một chuỗi quá dài, không hợp lệ, 0xF5-0xFF sẽ dẫn đến một mật mã vượt quá mức tối đa Unicode.}

Viết chương trình hoặc hàm lấy byte đầu tiên của chuỗi byte UTF-8 làm đầu vào và đầu ra hoặc trả về độ dài của chuỗi. I / O là linh hoạt. Ví dụ: đầu vào có thể là một số, ký tự 8 bit hoặc chuỗi một ký tự. Bạn có thể giả sử rằng byte đầu tiên là một phần của chuỗi hợp lệ và rơi vào một trong các phạm vi trên.

Đây là mã golf. Câu trả lời ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

0x00 => 1
0x41 => 1
0x7F => 1
0xC2 => 2
0xDF => 2
0xE0 => 3
0xEF => 3
0xF0 => 4
0xF4 => 4

Forth, 6 byte

x-size

xem https://forth-st Chuẩn.org / st Chuẩn / xchar / X-SIZE

Đầu vào và đầu ra theo mô hình Forth tiêu chuẩn:

Đầu vào

Địa chỉ bộ nhớ + chiều dài (tức là 1) của một "chuỗi" UTF-8 byte đơn.

Đầu ra

Độ dài chuỗi UTF-8 tính bằng byte.

Mã mẫu

Lưu trữ 0xF0 trong một ô nhớ và gọi kích thước x:

variable v
0xF0 v !
v 1 x-size

Kiểm tra kết quả:

.s <1> 4  ok

Z80Golf , 19 14 byte

00000000: 2f6f 3e10 37ed 6a3d 30fb ee07 c03c       /o>.7.j=0....<

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

-5 byte nhờ @Bubbler

Ví dụ với đầu vào 0x41-Hãy thử trực tuyến! hội,, tổ hợp

Ví dụ với đầu vào 0xC2-Hãy thử trực tuyến!

Ví dụ với đầu vào 0xE0-Hãy thử trực tuyến!

Ví dụ với đầu vào 0xF4-Hãy thử trực tuyến!

Hội,, tổ hợp:

;input: register a
;output: register a
byte_count:			;calculate 7^(log2(255^a))||1
	cpl			;xor 255
	ld l,a
	log2:
		ld	a,16
		scf
	log2loop:
		adc	hl,hl
		dec	a
		jr	nc,log2loop
	xor 7
	ret nz
	inc a

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

C (gcc) , 39 byte

t(char x){x=(__builtin_clz(~x)-24)%7u;}

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

Thạch ,  8  7 byte

+⁹BIITḢ

Một liên kết đơn âm chấp nhận byte là một số nguyên.

Hãy thử trực tuyến! Hoặc xem tất cả các đầu vào được đánh giá .

Nếu đầu vào của danh sách 8 bit được chấp nhận thì phương thức chỉ có 6 byte: 1;IITḢtuy nhiên, nó được coi là I / O linh hoạt nói chuyện quá xa.

Làm sao?

+⁹BIITḢ - Link: integer       e.g.: 127 (7f)            223 (df)            239 (ef)            244 (f4)
 ⁹      - literal 256
+       - add                       383                 479                 495                 500
  B     - to a list of bits         [1,0,1,1,1,1,1,1,1] [1,1,1,0,1,1,1,1,1] [1,1,1,1,0,1,1,1,1] [1,1,1,1,1,0,1,0,0]
   I    - increments                [-1,1,0,0,0,0,0,0]  [0,0,-1,1,0,0,0,0]  [0,0,0,-1,1,0,0,0]  [0,0,0,0,-1,1,-1,0]
    I   - increments                [2,-1,0,0,0,0,0]    [0,-1,2,-1,0,0,0]   [0,0,-1,2,-1,0,0]   [0,0,0,-1,2,-2,1]
     T  - truthy indices            [1,2]               [2,3,4]             [3,4,5]             [4,5,6,7]
      Ḣ - head                      1                   2                   3                   4

Haskell, 28 bytes

f x=sum[1|y<-"Áßï",x>y]+1

Try it online!

Python 2, 28 bytes

lambda x:1.4**(x/16-11)//1+1

Try it online!

Jelly, 8 7 bytes

»Ø⁷Ba\S

Try it online!

How it works

»Ø⁷Ba\S  Main link. Argument: n (integer)

 Ø⁷      Yield 128.
»        Take the maximum of n and 128.
   B     Yield the array of binary digits.
    a\   Cumulatively reduce by AND, replacing 1's after the first 0 with 0's.
      S  Take the sum.

JavaScript (Node.js), 24 bytes

x=>7^Math.log2(255^x)||1

Try it online!

Ruby, 27 23 bytes

->x{2+x[7]+(x/16<=>14)}

Try it online!

Charcoal, 12 bytes

Ｉ⌕⍘⌈⟦Ｎ¹²⁸⟧²0

Try it online! Link is to verbose version of code. Explanation:

     Ｎ          Input number
      ¹²⁸       Literal 128
   ⌈⟦    ⟧      Take the maximum
  ⍘       ²     Convert to base 2 as a string
 ⌕         0    Find the position of the first `0`
Ｉ               Cast to string
                Implicitly print

Jelly, 7 bytes

»Ø⁷Bi0’

Port of my 05AB1E answer.

Try it online or verify all test cases.

Explanation:

 Ø⁷        # Push 128
»          # Take the max of 128 and the input
   B       # Convert it to binary
    i0     # Get the 1-indexed first index of a 0
      ’    # Decrease it by 1 to make it 0-indexed (and output it implicitly)

Perl 6, 18 bytes

{7-msb(255-$_)||1}

Try it online!

Port of user202729's JavaScript answer. Alternatives with WhateverCode:

(255-*).msb*6%34%7
-(255-*).msb%6%5+1

x86 Assembly, 11 bytes

00000000 <f>:
   0:   f6 d1                   not    %cl
   2:   0f bd c1                bsr    %ecx,%eax
   5:   34 07                   xor    $0x7,%al
   7:   75 01                   jne    a <l1>
   9:   40                      inc    %eax
0000000a <l1>:
   a:   c3                      ret

Try it online!

Port of user202729's JavaScript answer. Uses fastcall conventions.

Labyrinth, 35 bytes

? 28& 16/ )!@!
:_1 ";_ _3&""2
   @1

Try it online!

Unwrapped version of the code:

?:_128&1!@
      ;
      _16/_3&2!@
            )
            !
            @

05AB1E, 8 7 bytes

žy‚àb0k

Port of @Neil's Charcoal answer.
-1 byte thanks to @Grimy.

Input as integer.

Try it online or verify all test cases.

Explanation:

žy       # Push 128
  ‚      # Pair it with the (implicit) input-integer
   à     # Take the maximum of this pair (128 and input)
    b    # Convert it to a binary-string
     0k  # Get the 0-based first index of a "0" in this binary-string
         # (and output it implicitly as result)

C, 31 bytes

f(x){return(x-160>>20-x/16)+2;}

Try it online!

27 bytes with gcc (-O0)

f(x){x=(x-160>>20-x/16)+2;}

Alternatives, 31 and 33 bytes

f(x){return(10>>15-x/16)+7>>2;}
f(x){return x/128-(-3>>15-x/16);}

I found these expressions when playing around with the Aha! superoptimizer a few years ago.