Question
Formatted question description: https://leetcode.ca/all/393.html
A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:
For 1byte character, the first bit is a 0, followed by its unicode code.
For nbytes character, the first nbits are all one's, the n+1 bit is 0, followed by n1 bytes with most significant 2 bits being 10.
This is how the UTF8 encoding would work:
Char. number range  UTF8 octet sequence
(hexadecimal)  (binary)
+
0000 00000000 007F  0xxxxxxx
0000 00800000 07FF  110xxxxx 10xxxxxx
0000 08000000 FFFF  1110xxxx 10xxxxxx 10xxxxxx
0001 00000010 FFFF  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
Given an array of integers representing the data, return whether it is a valid utf8 encoding.
Note:
The input is an array of integers. Only the least significant 8 bits of each integer is used to store the data. This means each integer represents only 1 byte of data.
Example 1:
data = [197, 130, 1], which represents the octet sequence: 11000101 10000010 00000001.
Return true.
It is a valid utf8 encoding for a 2bytes character followed by a 1byte character.
Example 2:
data = [235, 140, 4], which represented the octet sequence: 11101011 10001100 00000100.+
Return false.
The first 3 bits are all one's and the 4th bit is 0 means it is a 3bytes character.
The next byte is a continuation byte which starts with 10 and that's correct.
But the second continuation byte does not start with 10, so it is invalid.
Algorithm
For any byte B in UTF8 encoding, if the first bit of B is 0, then B independently represents a character (ASCII code);
If the first bit of B is 1, and the second bit is 0, then B is a byte (nonASCII character) in a multibyte character;
If the first two bits of B are 1, and the third bit is 0, then B is the first byte in the character represented by two bytes;
If the first three bits of B are 1, and the fourth bit is 0, then B is the first byte of the character represented by three bytes;
If the first four bits of B are 1, and the fifth bit is 0, then B is the first byte of the character represented by four bytes;
Therefore, for any byte in UTF8 encoding,
 According to the first digit, it can be judged whether it is an ASCII character;
 According to the first two bits, it can be judged whether the byte is the first byte of a character encoding;
 According to the first four bits (if the first two bits are both 1), it can be determined that the byte is the first byte of the character code, and it can be judged that the corresponding character is represented by several bytes;
 According to the first five bits (if the first four bits are 1), it can be judged whether there is an error in the encoding or whether there is an error in the data transmission process.
Code

class Solution { public: bool validUtf8(vector< int >& data) { int n = data.size(); for (int i = 0; i < n; ++i) { if (data[i] < 0b10000000) { continue; } else { int cnt = 0, val = data[i]; for (int j = 7; j >= 1; j) { if (val >= pow(2, j)) ++cnt; else break; val = pow(2, j); } if (cnt == 1  cnt > 4  cnt > n  i) return false; for (int j = i + 1; j < i + cnt; ++j) { if (data[j] > 0b10111111  data[j] < 0b10000000) return false; } i += cnt  1; } } return true; } };

class Solution(object): def validUtf8(self, data): """ :type data: List[int] :rtype: bool """ features = {0x00: 0, 0xc0: 1, 0xe0: 2, 0xf0: 3} masks = [0xf8, 0xf0, 0xe0, 0x80] new = True followed = 0 i = 0 while i < len(data): if new: followed = 1 for mask in masks: if (data[i] & mask) in features: followed = features[data[i] & mask] break if followed == 1: return False elif followed != 0: new = False else: new = True else: if (data[i] & 0xc0) != 0x80: return False followed = 1 if followed == 0: new = True i += 1 return followed == 0