utf-8-validation

java

python

python3

mysql

mssql

oraclesql

csharp

javascript

typescript

bash

swift

kotlin

dart

golang

ruby

scala

rust

racket

erlang

elixir

pythondata

postgresql

cangjie

Algorithms

Given an integer array <code>data</code> representing the data, return whether it is a valid UTF-8 encoding (i.e. it translates to a sequence of valid UTF-8 encoded characters).

A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:

<ol>
	<li>For a 1-byte character, the first bit is a <code>0</code>, followed by its Unicode code.</li>
	<li>For an n-bytes character, the first <code>n</code> bits are all one&#39;s, the <code>n + 1</code> bit is <code>0</code>, followed by <code>n - 1</code> bytes with the most significant <code>2</code> bits being <code>10</code>.</li>
</ol>

This is how the UTF-8 encoding would work:

<pre>
 Number of Bytes | UTF-8 Octet Sequence
 | (binary)
 --------------------+-----------------------------------------
 1 | 0xxxxxxx
 2 | 110xxxxx 10xxxxxx
 3 | 1110xxxx 10xxxxxx 10xxxxxx
 4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
</pre>

<code>x</code> denotes a bit in the binary form of a byte that may be either <code>0</code> or <code>1</code>.

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.

&nbsp;
Example 1:

<pre>
Input: data = [197,130,1]
Output: true
Explanation: data represents the octet sequence: 11000101 10000010 00000001.
It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
</pre>

Example 2:

<pre>
Input: data = [235,140,4]
Output: false
Explanation: data represented the octet sequence: 11101011 10001100 00000100.
The first 3 bits are all one&#39;s and the 4th bit is 0 means it is a 3-bytes character.
The next byte is a continuation byte which starts with 10 and that&#39;s correct.
But the second continuation byte does not start with 10, so it is invalid.
</pre>

&nbsp;
Constraints:

<ul>
	<li><code>1 &lt;= data.length &lt;= 2 * 104</code></li>
	<li><code>0 &lt;= data[i] &lt;= 255</code></li>
</ul>

validUtf8

UTF-8 Validation

Bit Manipulation

Array

给定一个表示数据的整数数组&nbsp;<code>data</code>&nbsp;，返回它是否为有效的 UTF-8 编码。

UTF-8 中的一个字符可能的长度为 1 到 4 字节，遵循以下的规则：

<ol>
	<li>对于 1 字节&nbsp;的字符，字节的第一位设为 0 ，后面 7 位为这个符号的 unicode 码。</li>
	<li>对于 n 字节&nbsp;的字符 (n &gt; 1)，第一个字节的前 n 位都设为1，第 n+1 位设为 0 ，后面字节的前两位一律设为 10 。剩下的没有提及的二进制位，全部为这个符号的 unicode 码。</li>
</ol>

这是 UTF-8 编码的工作方式：

<pre>
<code> </code>Number of Bytes<code> | UTF-8 octet sequence
 | (binary)
 --------------------+---------------------------------------------
 1 | 0xxxxxxx
 2 | 110xxxxx 10xxxxxx
 3 | 1110xxxx 10xxxxxx 10xxxxxx
 4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
</code></pre>

<code>x</code>&nbsp;表示二进制形式的一位，可以是 <code>0</code>&nbsp;或 <code>1</code>。

注意：输入是整数数组。只有每个整数的 最低 8 个有效位 用来存储数据。这意味着每个整数只表示 1 字节的数据。

&nbsp;

示例 1：

<pre>
输入：data = [197,130,1]
输出：true
解释：数据表示字节序列:11000101 10000010 00000001。
这是有效的 utf-8 编码，为一个 2 字节字符，跟着一个 1 字节字符。
</pre>

示例 2：

<pre>
输入：data = [235,140,4]
输出：false
解释：数据表示 8 位的序列: 11101011 10001100 00000100.
前 3 位都是 1 ，第 4 位为 0 表示它是一个 3 字节字符。
下一个字节是开头为 10 的延续字节，这是正确的。
但第二个延续字节不以 10 开头，所以是不符合规则的。
</pre>

&nbsp;

提示:

<ul>
	<li><code>1 &lt;= data.length &lt;= 2 * 104</code></li>
	<li><code>0 &lt;= data[i] &lt;= 255</code></li>
</ul>