update

2025-01-10 18:48:13 +08:00 · 2023-02-27 23:41:45 +08:00 · 2023-02-27 23:41:45 +08:00 · 48eaf39261
commit 48eaf39261
parent 947eefea5d
83 changed files with 21090 additions and 12870 deletions
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 # 力扣题库（完整版）
-> 最后更新日期： **2023.02.11**
+> 最后更新日期： **2023.02.27**
 >
 > 使用脚本前请务必仔细完整阅读本 `README.md` 文件
--- a/leetcode-cn/origin-data.json
+++ b/leetcode-cn/origin-data.json
--- a/leetcode-cn/originData/count-the-number-of-fair-pairs.json
+++ b/leetcode-cn/originData/count-the-number-of-fair-pairs.json
--- a/leetcode-cn/originData/count-the-number-of-square-free-subsets.json
+++ b/leetcode-cn/originData/count-the-number-of-square-free-subsets.json
--- a/leetcode-cn/originData/find-the-array-concatenation-value.json
+++ b/leetcode-cn/originData/find-the-array-concatenation-value.json
--- a/leetcode-cn/originData/find-the-divisibility-array-of-a-string.json
+++ b/leetcode-cn/originData/find-the-divisibility-array-of-a-string.json
--- a/leetcode-cn/originData/find-the-maximum-number-of-marked-indices.json
+++ b/leetcode-cn/originData/find-the-maximum-number-of-marked-indices.json
--- a/leetcode-cn/originData/find-the-string-with-lcp.json
+++ b/leetcode-cn/originData/find-the-string-with-lcp.json
--- a/leetcode-cn/originData/handling-sum-queries-after-update.json
+++ b/leetcode-cn/originData/handling-sum-queries-after-update.json
--- a/leetcode-cn/originData/left-and-right-sum-differences.json
+++ b/leetcode-cn/originData/left-and-right-sum-differences.json
--- a/leetcode-cn/originData/maximum-difference-by-remapping-a-digit.json
+++ b/leetcode-cn/originData/maximum-difference-by-remapping-a-digit.json
--- a/leetcode-cn/originData/merge-two-2d-arrays-by-summing-values.json
+++ b/leetcode-cn/originData/merge-two-2d-arrays-by-summing-values.json
--- a/leetcode-cn/originData/minimum-impossible-or.json
+++ b/leetcode-cn/originData/minimum-impossible-or.json
--- a/leetcode-cn/originData/minimum-operations-to-reduce-an-integer-to-0.json
+++ b/leetcode-cn/originData/minimum-operations-to-reduce-an-integer-to-0.json
--- a/leetcode-cn/originData/minimum-score-by-changing-two-elements.json
+++ b/leetcode-cn/originData/minimum-score-by-changing-two-elements.json
--- a/leetcode-cn/originData/minimum-time-to-visit-a-cell-in-a-grid.json
+++ b/leetcode-cn/originData/minimum-time-to-visit-a-cell-in-a-grid.json
--- a/leetcode-cn/originData/subsequence-with-the-minimum-score.json
+++ b/leetcode-cn/originData/subsequence-with-the-minimum-score.json
--- a/leetcode-cn/originData/substring-xor-queries.json
+++ b/leetcode-cn/originData/substring-xor-queries.json
--- a/[minimum-score-by-changing-two-elements].html
+++ b/[minimum-score-by-changing-two-elements].html
@ -0,0 +1,44 @@
 <p>给你一个下标从 <strong>0</strong>&nbsp;开始的整数数组&nbsp;<code>nums</code>&nbsp;。</p>
 <ul>
 	<li><code>nums</code> 的 <strong>最小</strong>&nbsp;得分是满足 <code>0 &lt;= i &lt; j &lt; nums.length</code>&nbsp;的&nbsp;<code>|nums[i]&nbsp;- nums[j]|</code>&nbsp;的最小值。</li>
 	<li><code>nums</code>的 <strong>最大 </strong>得分是满足 <code>0 &lt;= i &lt; j &lt; nums.length</code>&nbsp;的&nbsp;<code>|nums[i]&nbsp;- nums[j]|</code>&nbsp;的最大值。</li>
 	<li><code>nums</code>&nbsp;的分数是 <strong>最大</strong>&nbsp;得分与 <strong>最小</strong>&nbsp;得分的和。</li>
 </ul>
 <p>我们的目标是最小化&nbsp;<code>nums</code>&nbsp;的分数。你 <strong>最多</strong> 可以修改&nbsp;<code>nums</code>&nbsp;中&nbsp;<strong>2</strong>&nbsp;个元素的值。</p>
 <p>请你返回修改&nbsp;<code>nums</code>&nbsp;中&nbsp;<strong>至多两个</strong>&nbsp;元素的值后，可以得到的 <strong>最小分数</strong>&nbsp;。</p>
 <p><code>|x|</code>&nbsp;表示 <code>x</code>&nbsp;的绝对值。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>nums = [1,4,3]
 <b>输出：</b>0
 <b>解释：</b>将 nums[1] 和 nums[2] 的值改为 1 ，nums 变为 [1,1,1] 。<code>|nums[i] - nums[j]|</code> 的值永远为 0 ，所以我们返回 0 + 0 = 0 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>nums = [1,4,7,8,5]
 <b>输出：</b>3
 <b>解释：
 </b>将 nums[0] 和 nums[1] 的值变为 6 ，nums 变为 [6,6,7,8,5] 。
 最小得分是 i = 0 且 j = 1 时得到的 |<code>nums[i] - nums[j]</code>| = |6 - 6| = 0 。
 最大得分是 i = 3 且 j = 4 时得到的 |<code>nums[i] - nums[j]</code>| = |8 - 5| = 3 。
 最大得分与最小得分之和为 3 。这是最优答案。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>3 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[merge-two-2d-arrays-by-summing-values].html
+++ b/[merge-two-2d-arrays-by-summing-values].html
@ -0,0 +1,49 @@
 <p>给你两个 <strong>二维</strong> 整数数组 <code>nums1</code> 和 <code>nums2.</code></p>
 <ul>
 	<li><code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code> 表示编号为 <code>id<sub>i</sub></code> 的数字对应的值等于 <code>val<sub>i</sub></code> 。</li>
 	<li><code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;表示编号为 <code>id<sub>i</sub></code> 的数字对应的值等于 <code>val<sub>i</sub></code> 。</li>
 </ul>
 <p>每个数组都包含 <strong>互不相同</strong> 的 id ，并按 id 以 <strong>递增</strong> 顺序排列。</p>
 <p>请你将两个数组合并为一个按 id 以递增顺序排列的数组，并符合下述条件：</p>
 <ul>
 	<li>只有在两个数组中至少出现过一次的 id 才能包含在结果数组内。</li>
 	<li>每个 id 在结果数组中 <strong>只能出现一次</strong> ，并且其对应的值等于两个数组中该 id 所对应的值求和。如果某个数组中不存在该 id ，则认为其对应的值等于 <code>0</code> 。</li>
 </ul>
 <p>返回结果数组。返回的数组需要按 id 以递增顺序排列。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre><strong>输入：</strong>nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
 <strong>输出：</strong>[[1,6],[2,3],[3,2],[4,6]]
 <strong>解释：</strong>结果数组中包含以下元素：
 - id = 1 ，对应的值等于 2 + 4 = 6 。
 - id = 2 ，对应的值等于 3 。
 - id = 3 ，对应的值等于 2 。
 - id = 4 ，对应的值等于5 + 1 = 6 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre><strong>输入：</strong>nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
 <strong>输出：</strong>[[1,3],[2,4],[3,6],[4,3],[5,5]]
 <strong>解释：</strong>不存在共同 id ，在结果数组中只需要包含每个 id 和其对应的值。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 200</code></li>
 	<li><code>nums1[i].length == nums2[j].length == 2</code></li>
 	<li><code>1 &lt;= id<sub>i</sub>, val<sub>i</sub> &lt;= 1000</code></li>
 	<li>数组中的 id 互不相同</li>
 	<li>数据均按 id 以严格递增顺序排列</li>
 </ul>
--- a/(Chinese)/在网格图中访问一个格子的最少时间
+++ b/(Chinese)/在网格图中访问一个格子的最少时间
@ -0,0 +1,49 @@
 <p>给你一个&nbsp;<code>m x n</code>&nbsp;的矩阵&nbsp;<code>grid</code>&nbsp;，每个元素都为 <strong>非负</strong>&nbsp;整数，其中&nbsp;<code>grid[row][col]</code>&nbsp;表示可以访问格子&nbsp;<code>(row, col)</code>&nbsp;的&nbsp;<strong>最早</strong>&nbsp;时间。也就是说当你访问格子&nbsp;<code>(row, col)</code>&nbsp;时，最少已经经过的时间为&nbsp;<code>grid[row][col]</code>&nbsp;。</p>
 <p>你从 <strong>最左上角</strong>&nbsp;出发，出发时刻为 <code>0</code>&nbsp;，你必须一直移动到上下左右相邻四个格子中的 <strong>任意</strong>&nbsp;一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。</p>
 <p>请你返回 <strong>最早</strong>&nbsp;到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 <code>-1</code>&nbsp;。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png" /></p>
 <pre>
 <b>输入：</b>grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
 <b>输出：</b>7
 <b>解释：</b>一条可行的路径为：
 - 时刻 t = 0 ，我们在格子 (0,0) 。
 - 时刻 t = 1 ，我们移动到格子 (0,1) ，可以移动的原因是 grid[0][1] &lt;= 1 。
 - 时刻 t = 2 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] &lt;= 2 。
 - 时刻 t = 3 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] &lt;= 3 。
 - 时刻 t = 4 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] &lt;= 4 。
 - 时刻 t = 5 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] &lt;= 5 。
 - 时刻 t = 6 ，我们移动到格子 (1,3) ，可以移动的原因是 grid[1][3] &lt;= 6 。
 - 时刻 t = 7 ，我们移动到格子 (2,3) ，可以移动的原因是 grid[2][3] &lt;= 7 。
 最终到达时刻为 7 。这是最早可以到达的时间。
 </pre>
 <p><strong>示例 2：</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png" style="width: 151px; height: 151px;" /></p>
 <pre>
 <b>输入：</b>grid = [[0,2,4],[3,2,1],[1,0,4]]
 <b>输出：</b>-1
 <b>解释：</b>没法从左上角按题目规定走到右下角。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>m == grid.length</code></li>
 	<li><code>n == grid[i].length</code></li>
 	<li><code>2 &lt;= m, n &lt;= 1000</code></li>
 	<li><code>4 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
 	<li><code>grid[0][0] == 0</code></li>
 </ul>
--- a/(Chinese)/子字符串异或查询
+++ b/(Chinese)/子字符串异或查询
@ -0,0 +1,48 @@
 <p>给你一个 <strong>二进制字符串</strong>&nbsp;<code>s</code>&nbsp;和一个整数数组&nbsp;<code>queries</code>&nbsp;，其中&nbsp;<code>queries[i] = [first<sub>i</sub>, second<sub>i</sub>]</code>&nbsp;。</p>
 <p>对于第&nbsp;<code>i</code>&nbsp;个查询，找到 <code>s</code>&nbsp;的 <strong>最短子字符串</strong>&nbsp;，它对应的 <strong>十进制</strong>值&nbsp;<code>val</code>&nbsp;与&nbsp;<code>first<sub>i</sub></code>&nbsp;<b>按位异或</b>&nbsp;得到&nbsp;<code>second<sub>i</sub></code>&nbsp;，换言之，<code>val ^ first<sub>i</sub> == second<sub>i</sub></code>&nbsp;。</p>
 <p>第&nbsp;<code>i</code>&nbsp;个查询的答案是子字符串&nbsp;<code>[left<sub>i</sub>, right<sub>i</sub>]</code> 的两个端点（下标从&nbsp;<strong>0</strong>&nbsp;开始），如果不存在这样的子字符串，则答案为&nbsp;<code>[-1, -1]</code>&nbsp;。如果有多个答案，请你选择&nbsp;<code>left<sub>i</sub></code>&nbsp;最小的一个。</p>
 <p>请你返回一个数组&nbsp;<code>ans</code>&nbsp;，其中&nbsp;<code>ans[i] = [left<sub>i</sub>, right<sub>i</sub>]</code>&nbsp;是第&nbsp;<code>i</code>&nbsp;个查询的答案。</p>
 <p><strong>子字符串</strong>&nbsp;是一个字符串中一段连续非空的字符序列。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>s = "101101", queries = [[0,5],[1,2]]
 <b>输出：</b>[[0,2],[2,3]]
 <b>解释：</b>第一个查询，端点为 <code>[0,2]</code> 的子字符串为 <strong>"101"</strong> ，对应十进制数字 <strong><code>5 ，且</code></strong> <strong><code>5 ^ 0 = 5</code></strong>&nbsp;，所以第一个查询的答案为 <code>[0,2]。第二个查询中，</code>端点为 <code>[2,3] 的子字符串为 </code><strong>"11" ，对应十进制数字</strong> <strong>3</strong>&nbsp;，且 <strong>3<code> ^ 1 = 2</code></strong><code>&nbsp;。所以第二个查询的答案为</code> <code>[2,3]</code> 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>s = "0101", queries = [[12,8]]
 <b>输出：</b>[[-1,-1]]
 <b>解释：</b>这个例子中，没有符合查询的答案，所以返回 <code>[-1,-1] 。</code>
 </pre>
 <p><strong>示例 3：</strong></p>
 <pre>
 <b>输入：</b>s = "1", queries = [[4,5]]
 <b>输出：</b>[[0,0]]
 <b>解释：</b>这个例子中，端点为 <code>[0,0]</code> 的子字符串对应的十进制值为 <strong><code>1</code></strong><code>&nbsp;，且</code> <strong><code>1 ^ 4 = 5</code></strong><code>&nbsp;。所以答案为</code> <code>[0,0] 。</code>
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
 	<li><code>s[i]</code>&nbsp;要么是&nbsp;<code>'0'</code>&nbsp;，要么是&nbsp;<code>'1'</code>&nbsp;。</li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= first<sub>i</sub>, second<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
 </ul>
 <p>&nbsp;</p>
--- a/(Chinese)/将整数减少到零需要的最少操作数
+++ b/(Chinese)/将整数减少到零需要的最少操作数
@ -0,0 +1,43 @@
 <p>给你一个正整数 <code>n</code> ，你可以执行下述操作 <strong>任意</strong> 次：</p>
 <ul>
 	<li><code>n</code> 加上或减去 <code>2</code> 的某个 <strong>幂</strong></li>
 </ul>
 <p>返回使 <code>n</code> 等于 <code>0</code> 需要执行的 <strong>最少</strong> 操作数。</p>
 <p>如果 <code>x == 2<sup>i</sup></code> 且其中 <code>i &gt;= 0</code> ，则数字 <code>x</code> 是 <code>2</code> 的幂。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <strong>输入：</strong>n = 39
 <strong>输出：</strong>3
 <strong>解释：</strong>我们可以执行下述操作：
 - n 加上 2<sup>0</sup> = 1 ，得到 n = 40 。
 - n 减去 2<sup>3</sup> = 8 ，得到 n = 32 。
 - n 减去 2<sup>5</sup> = 32 ，得到 n = 0 。
 可以证明使 n 等于 0 需要执行的最少操作数是 3 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <strong>输入：</strong>n = 54
 <strong>输出：</strong>3
 <strong>解释：</strong>我们可以执行下述操作：
 - n 加上 2<sup>1</sup> = 2 ，得到 n = 56 。
 - n 加上 2<sup>3</sup> = 8 ，得到 n = 64 。
 - n 减去 2<sup>6</sup> = 64 ，得到 n = 0 。
 使 n 等于 0 需要执行的最少操作数是 3 。 
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/[left-and-right-sum-differences].html
+++ b/[left-and-right-sum-differences].html
@ -0,0 +1,42 @@
 <p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，请你找出一个下标从 <strong>0</strong> 开始的整数数组 <code>answer</code> ，其中：</p>
 <ul>
 	<li><code>answer.length == nums.length</code></li>
 	<li><code>answer[i] = |leftSum[i] - rightSum[i]|</code></li>
 </ul>
 <p>其中：</p>
 <ul>
 	<li><code>leftSum[i]</code> 是数组 <code>nums</code> 中下标 <code>i</code> 左侧元素之和。如果不存在对应的元素，<code>leftSum[i] = 0</code> 。</li>
 	<li><code>rightSum[i]</code> 是数组 <code>nums</code> 中下标 <code>i</code> 右侧元素之和。如果不存在对应的元素，<code>rightSum[i] = 0</code> 。</li>
 </ul>
 <p>返回数组 <code>answer</code> 。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre><strong>输入：</strong>nums = [10,4,8,3]
 <strong>输出：</strong>[15,1,11,22]
 <strong>解释：</strong>数组 leftSum 为 [0,10,14,22] 且数组 rightSum 为 [15,11,3,0] 。
 数组 answer 为 [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22] 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre><strong>输入：</strong>nums = [1]
 <strong>输出：</strong>[0]
 <strong>解释：</strong>数组 leftSum 为 [0] 且数组 rightSum 为 [0] 。
 数组 answer 为 [|0 - 0|] = [0] 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/[find-the-divisibility-array-of-a-string].html
+++ b/[find-the-divisibility-array-of-a-string].html
@ -0,0 +1,39 @@
 <p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>word</code> ，长度为 <code>n</code> ，由从 <code>0</code> 到 <code>9</code> 的数字组成。另给你一个正整数 <code>m</code> 。</p>
 <p><code>word</code> 的 <strong>可整除数组</strong> <code>div</code>&nbsp; 是一个长度为 <code>n</code> 的整数数组，并满足：</p>
 <ul>
 	<li>如果 <code>word[0,...,i]</code> 所表示的 <strong>数值</strong> 能被 <code>m</code> 整除，<code>div[i] = 1</code></li>
 	<li>否则，<code>div[i] = 0</code></li>
 </ul>
 <p>返回<em> </em><code>word</code> 的可整除数组。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <strong>输入：</strong>word = "998244353", m = 3
 <strong>输出：</strong>[1,1,0,0,0,1,1,0,0]
 <strong>解释：</strong>仅有 4 个前缀可以被 3 整除："9"、"99"、"998244" 和 "9982443" 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <strong>输入：</strong>word = "1010", m = 10
 <strong>输出：</strong>[0,1,0,1]
 <strong>解释：</strong>仅有 2 个前缀可以被 10 整除："10" 和 "1010" 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 	<li><code>word.length == n</code></li>
 	<li><code>word</code> 由数字 <code>0</code> 到 <code>9</code> 组成</li>
 	<li><code>1 &lt;= m &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[find-the-string-with-lcp].html
+++ b/[find-the-string-with-lcp].html
@ -0,0 +1,44 @@
 <p>对任一由 <code>n</code> 个小写英文字母组成的字符串 <code>word</code> ，我们可以定义一个 <code>n x n</code> 的矩阵，并满足：</p>
 <ul>
 	<li><code>lcp[i][j]</code> 等于子字符串&nbsp;<code>word[i,...,n-1]</code> 和 <code>word[j,...,n-1]</code> 之间的最长公共前缀的长度。</li>
 </ul>
 <p>给你一个 <code>n x n</code> 的矩阵 <code>lcp</code> 。返回与 <code>lcp</code> 对应的、按字典序最小的字符串&nbsp;<code>word</code> 。如果不存在这样的字符串，则返回空字符串。</p>
 <p>对于长度相同的两个字符串 <code>a</code> 和 <code>b</code> ，如果在 <code>a</code> 和 <code>b</code> 不同的第一个位置，字符串 <code>a</code> 的字母在字母表中出现的顺序先于 <code>b</code> 中的对应字母，则认为字符串 <code>a</code> 按字典序比字符串 <code>b</code> 小。例如，<code>"aabd"</code> 在字典上小于 <code>"aaca"</code> ，因为二者不同的第一位置是第三个字母，而&nbsp;<code>'b'</code> 先于 <code>'c'</code> 出现。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <strong>输入：</strong>lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
 <strong>输出：</strong>"abab"
 <strong>解释：</strong>lcp 对应由两个交替字母组成的任意 4 字母字符串，字典序最小的是 "abab" 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <strong>输入：</strong>lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
 <strong>输出：</strong>"aaaa"
 <strong>解释：</strong>lcp 对应只有一个不同字母的任意 4 字母字符串，字典序最小的是 "aaaa" 。 
 </pre>
 <p><strong>示例 3：</strong></p>
 <pre>
 <strong>输入：</strong>lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
 <strong>输出：</strong>""
 <strong>解释：</strong>lcp[3][3] 无法等于 3 ，因为 word[3,...,3] 仅由单个字母组成；因此，不存在答案。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= n ==&nbsp;</code><code>lcp.length == </code><code>lcp[i].length</code>&nbsp;<code>&lt;= 1000</code></li>
 	<li><code><font face="monospace">0 &lt;= lcp[i][j] &lt;= n</font></code></li>
 </ul>
--- a/[find-the-array-concatenation-value].html
+++ b/[find-the-array-concatenation-value].html
@ -0,0 +1,64 @@
 <p>给你一个下标从 <strong>0</strong> 开始的整数数组&nbsp;<code>nums</code> 。</p>
 <p>现定义两个数字的 <strong>串联</strong>&nbsp;是由这两个数值串联起来形成的新数字。</p>
 <ul>
 	<li>例如，<code>15</code><span style="">&nbsp;和&nbsp;</span><code>49</code>&nbsp;的串联是&nbsp;<code>1549</code> 。</li>
 </ul>
 <p><code>nums</code>&nbsp;的 <strong>串联值</strong>&nbsp;最初等于 <code>0</code> 。执行下述操作直到&nbsp;<code>nums</code>&nbsp;变为空：</p>
 <ul>
 	<li>如果&nbsp;<code>nums</code>&nbsp;中存在不止一个数字，分别选中 <code>nums</code> 中的第一个元素和最后一个元素，将二者串联得到的值加到&nbsp;<code>nums</code>&nbsp;的 <strong>串联值</strong> 上，然后从&nbsp;<code>nums</code>&nbsp;中删除第一个和最后一个元素。</li>
 	<li>如果仅存在一个元素，则将该元素的值加到&nbsp;<code>nums</code> 的串联值上，然后删除这个元素。</li>
 </ul>
 <p>返回执行完所有操作后<em>&nbsp;</em><code>nums</code> 的串联值。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>nums = [7,52,2,4]
 <b>输出：</b>596
 <b>解释：</b>在执行任一步操作前，nums 为 [7,52,2,4] ，串联值为 0 。
 - 在第一步操作中：
 我们选中第一个元素 7 和最后一个元素 4 。
 二者的串联是 74 ，将其加到串联值上，所以串联值等于 74 。
 接着我们从 nums 中移除这两个元素，所以 nums 变为 [52,2] 。
 - 在第二步操作中： 
 我们选中第一个元素 52 和最后一个元素 2 。 
 二者的串联是 522 ，将其加到串联值上，所以串联值等于 596 。
 接着我们从 nums 中移除这两个元素，所以 nums 变为空。
 由于串联值等于 596 ，所以答案就是 596 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>nums = [5,14,13,8,12]
 <b>输出：</b>673
 <b>解释：</b>在执行任一步操作前，nums 为 [5,14,13,8,12] ，串联值为 0 。 
 - 在第一步操作中： 
 我们选中第一个元素 5 和最后一个元素 12 。 
 二者的串联是 512 ，将其加到串联值上，所以串联值等于 512 。 
 接着我们从 nums 中移除这两个元素，所以 nums 变为 [14,13,8] 。
 - 在第二步操作中：
 我们选中第一个元素 14 和最后一个元素 8 。
 二者的串联是 148 ，将其加到串联值上，所以串联值等于 660 。
 接着我们从 nums 中移除这两个元素，所以 nums 变为 [13] 。 
 - 在第三步操作中：
 nums 只有一个元素，所以我们选中 13 并将其加到串联值上，所以串联值等于 673 。
 接着我们从 nums 中移除这个元素，所以 nums 变为空。 
 由于串联值等于 673 ，所以答案就是 673 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
 </ul>
--- a/[count-the-number-of-square-free-subsets].html
+++ b/[count-the-number-of-square-free-subsets].html
@ -0,0 +1,40 @@
 <p>给你一个正整数数组 <code>nums</code> 。</p>
 <p>如果数组 <code>nums</code> 的子集中的元素乘积是一个 <strong>无平方因子数</strong> ，则认为该子集是一个 <strong>无平方</strong> 子集。</p>
 <p><strong>无平方因子数</strong> 是无法被除 <code>1</code> 之外任何平方数整除的数字。</p>
 <p>返回数组 <code>nums</code> 中 <strong>无平方</strong> 且 <strong>非空</strong> 的子集数目。因为答案可能很大，返回对 <code>10<sup>9</sup> + 7</code> 取余的结果。</p>
 <p><code>nums</code> 的 <strong>非空子集</strong> 是可以由删除 <code>nums</code> 中一些元素（可以不删除，但不能全部删除）得到的一个数组。如果构成两个子集时选择删除的下标不同，则认为这两个子集不同。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <strong>输入：</strong>nums = [3,4,4,5]
 <strong>输出：</strong>3
 <strong>解释：</strong>示例中有 3 个无平方子集：
 - 由第 0 个元素 [3] 组成的子集。其元素的乘积是 3 ，这是一个无平方因子数。
 - 由第 3 个元素 [5] 组成的子集。其元素的乘积是 5 ，这是一个无平方因子数。
 - 由第 0 个和第 3 个元素 [3,5] 组成的子集。其元素的乘积是 15 ，这是一个无平方因子数。
 可以证明给定数组中不存在超过 3 个无平方子集。</pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <strong>输入：</strong>nums = [1]
 <strong>输出：</strong>1
 <strong>解释：</strong>示例中有 1 个无平方子集：
 - 由第 0 个元素 [1] 组成的子集。其元素的乘积是 1 ，这是一个无平方因子数。
 可以证明给定数组中不存在超过 1 个无平方子集。</pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length&nbsp;&lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 30</code></li>
 </ul>
--- a/(Chinese)/更新数组后处理求和查询
+++ b/(Chinese)/更新数组后处理求和查询
@ -0,0 +1,42 @@
 <p>给你两个下标从 <strong>0</strong>&nbsp;开始的数组&nbsp;<code>nums1</code> 和&nbsp;<code>nums2</code>&nbsp;，和一个二维数组&nbsp;<code>queries</code>&nbsp;表示一些操作。总共有 3 种类型的操作：</p>
 <ol>
 	<li>操作类型 1 为&nbsp;<code>queries[i]&nbsp;= [1, l, r]</code>&nbsp;。你需要将 <code>nums1</code>&nbsp;从下标&nbsp;<code>l</code>&nbsp;到下标 <code>r</code>&nbsp;的所有 <code>0</code>&nbsp;反转成 <code>1</code>&nbsp;或将 <code>1</code>&nbsp;反转成 <code>0</code>&nbsp;。<code>l</code>&nbsp;和 <code>r</code>&nbsp;下标都从 <strong>0</strong>&nbsp;开始。</li>
 	<li>操作类型 2 为&nbsp;<code>queries[i]&nbsp;= [2, p, 0]</code>&nbsp;。对于&nbsp;<code>0 &lt;= i &lt; n</code>&nbsp;中的所有下标，令&nbsp;<code>nums2[i] =&nbsp;nums2[i]&nbsp;+ nums1[i]&nbsp;* p</code>&nbsp;。</li>
 	<li>操作类型 3 为&nbsp;<code>queries[i]&nbsp;= [3, 0, 0]</code>&nbsp;。求&nbsp;<code>nums2</code>&nbsp;中所有元素的和。</li>
 </ol>
 <p>请你返回一个数组，包含所有第三种操作类型的答案。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>nums1 = [1,0,1], nums2 = [0,0,0], queries = [[1,1,1],[2,1,0],[3,0,0]]
 <b>输出：</b>[3]
 <strong>解释：</strong>第一个操作后 nums1 变为 [1,1,1] 。第二个操作后，nums2 变成 [1,1,1] ，所以第三个操作的答案为 3 。所以返回 [3] 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>nums1 = [1], nums2 = [5], queries = [[2,0,0],[3,0,0]]
 <b>输出：</b>[5]
 <b>解释：</b>第一个操作后，nums2 保持不变为 [5] ，所以第二个操作的答案是 5 。所以返回 [5] 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length,nums2.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums1.length = nums2.length</code></li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>queries[i].length = 3</code></li>
 	<li><code>0 &lt;= l &lt;= r &lt;= nums1.length - 1</code></li>
 	<li><code>0 &lt;= p &lt;= 10<sup>6</sup></code></li>
 	<li><code>0 &lt;= nums1[i] &lt;= 1</code></li>
 	<li><code>0 &lt;= nums2[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[maximum-difference-by-remapping-a-digit].html
+++ b/[maximum-difference-by-remapping-a-digit].html
@ -0,0 +1,43 @@
 <p>给你一个整数&nbsp;<code>num</code>&nbsp;。你知道 Danny Mittal 会偷偷将 <code>0</code>&nbsp;到 <code>9</code>&nbsp;中的一个数字 <strong>替换</strong> 成另一个数字。</p>
 <p>请你返回将 <code>num</code>&nbsp;中&nbsp;<strong>恰好一个</strong>&nbsp;数字进行替换后，得到的最大值和最小值的差位多少。</p>
 <p><strong>注意：</strong></p>
 <ul>
 	<li>当 Danny 将一个数字 <code>d1</code> 替换成另一个数字 <code>d2</code> 时，Danny 需要将&nbsp;<code>nums</code>&nbsp;中所有 <code>d1</code>&nbsp;都替换成&nbsp;<code>d2</code>&nbsp;。</li>
 	<li>Danny 可以将一个数字替换成它自己，也就是说&nbsp;<code>num</code>&nbsp;可以不变。</li>
 	<li>Danny 可以将数字分别替换成两个不同的数字分别得到最大值和最小值。</li>
 	<li>替换后得到的数字可以包含前导 0 。</li>
 	<li>Danny Mittal 获得周赛 326 前 10 名，让我们恭喜他。</li>
 </ul>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>num = 11891
 <b>输出：</b>99009
 <b>解释：</b>
 为了得到最大值，我们将数字 1 替换成数字 9 ，得到 99899 。
 为了得到最小值，我们将数字 1 替换成数字 0 ，得到 890 。
 两个数字的差值为 99009 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>num = 90
 <b>输出：</b>99
 <strong>解释：</strong>
 可以得到的最大值是 99（将 0 替换成 9），最小值是 0（将 9 替换成 0）。
 所以我们得到 99 。</pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= num &lt;= 10<sup>8</sup></code></li>
 </ul>
--- a/(Chinese)/最小无法得到的或值
+++ b/(Chinese)/最小无法得到的或值
@ -0,0 +1,30 @@
 <p>给你一个下标从 <strong>0</strong>&nbsp;开始的整数数组&nbsp;<code>nums</code>&nbsp;。</p>
 <p>如果存在一些整数满足&nbsp;<code>0 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt; ... &lt; index<sub>k</sub> &lt; nums.length</code>&nbsp;，得到&nbsp;<code>nums[index<sub>1</sub>] | nums[index<sub>2</sub>] | ... | nums[index<sub>k</sub>] = x</code>&nbsp;，那么我们说&nbsp;<code>x</code>&nbsp;是&nbsp;<strong>可表达的</strong>&nbsp;。换言之，如果一个整数能由&nbsp;<code>nums</code>&nbsp;的某个子序列的或运算得到，那么它就是可表达的。</p>
 <p>请你返回 <code>nums</code>&nbsp;不可表达的 <strong>最小非零整数</strong>&nbsp;。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre><b>输入：</b>nums = [2,1]
 <b>输出：</b>4
 <b>解释：</b>1 和 2 已经在数组中，因为 nums[0] | nums[1] = 2 | 1 = 3 ，所以 3 是可表达的。由于 4 是不可表达的，所以我们返回 4 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre><b>输入：</b>nums = [5,3,2]
 <b>输出：</b>1
 <b>解释：</b>1 是最小不可表达的数字。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[subsequence-with-the-minimum-score].html
+++ b/[subsequence-with-the-minimum-score].html
@ -0,0 +1,49 @@
 <p>给你两个字符串&nbsp;<code>s</code> 和&nbsp;<code>t</code>&nbsp;。</p>
 <p>你可以从字符串 <code>t</code>&nbsp;中删除任意数目的字符。</p>
 <p>如果没有从字符串&nbsp;<code>t</code>&nbsp;中删除字符，那么得分为&nbsp;<code>0</code>&nbsp;，否则：</p>
 <ul>
 	<li>令&nbsp;<code>left</code>&nbsp;为删除字符中的最小下标。</li>
 	<li>令&nbsp;<code>right</code>&nbsp;为删除字符中的最大下标。</li>
 </ul>
 <p>字符串的得分为&nbsp;<code>right - left + 1</code>&nbsp;。</p>
 <p>请你返回使<em>&nbsp;</em><code>t</code><em> </em>成为<em>&nbsp;</em><code>s</code>&nbsp;子序列的最小得分。</p>
 <p>一个字符串的 <strong>子序列</strong>&nbsp;是从原字符串中删除一些字符后（也可以一个也不删除），剩余字符不改变顺序得到的字符串。（比方说&nbsp;<code>"ace"</code> 是&nbsp;<code>"<strong><em>a</em></strong>b<strong><em>c</em></strong>d<strong><em>e</em></strong>"</code>&nbsp;的子序列，但是&nbsp;<code>"aec"</code>&nbsp;不是）。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>s = "abacaba", t = "bzaa"
 <b>输出：</b>1
 <b>解释：</b>这个例子中，我们删除下标 1 处的字符 "z" （下标从 0 开始）。
 字符串 t 变为 "baa" ，它是字符串 "abacaba" 的子序列，得分为 1 - 1 + 1 = 1 。
 1 是能得到的最小得分。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>s = "cde", t = "xyz"
 <b>输出：</b>3
 <b>解释：</b>这个例子中，我们将下标为 0， 1 和 2 处的字符 "x" ，"y" 和 "z" 删除（下标从 0 开始）。
 字符串变成 "" ，它是字符串 "cde" 的子序列，得分为 2 - 0 + 1 = 3 。
 3 是能得到的最小得分。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>s</code> 和&nbsp;<code>t</code>&nbsp;都只包含小写英文字母。</li>
 </ul>
 <p>&nbsp;</p>
--- a/[find-the-maximum-number-of-marked-indices].html
+++ b/[find-the-maximum-number-of-marked-indices].html
@ -0,0 +1,47 @@
 <p>给你一个下标从 <strong>0</strong>&nbsp;开始的整数数组&nbsp;<code>nums</code>&nbsp;。</p>
 <p>一开始，所有下标都没有被标记。你可以执行以下操作任意次：</p>
 <ul>
 	<li>选择两个 <strong>互不相同且未标记</strong>&nbsp;的下标&nbsp;<code>i</code> 和&nbsp;<code>j</code>&nbsp;，满足&nbsp;<code>2 * nums[i] &lt;= nums[j]</code>&nbsp;，标记下标&nbsp;<code>i</code> 和&nbsp;<code>j</code>&nbsp;。</li>
 </ul>
 <p>请你执行上述操作任意次，返回<em>&nbsp;</em><code>nums</code>&nbsp;中最多可以标记的下标数目。</p>
 <p>&nbsp;</p>
 <p><strong>示例 1：</strong></p>
 <pre>
 <b>输入：</b>nums = [3,5,2,4]
 <b>输出：</b>2
 <strong>解释：</strong>第一次操作中，选择 i = 2 和 j = 1 ，操作可以执行的原因是 2 * nums[2] &lt;= nums[1] ，标记下标 2 和 1 。
 没有其他更多可执行的操作，所以答案为 2 。
 </pre>
 <p><strong>示例 2：</strong></p>
 <pre>
 <b>输入：</b>nums = [9,2,5,4]
 <b>输出：</b>4
 <strong>解释：</strong>第一次操作中，选择 i = 3 和 j = 0 ，操作可以执行的原因是 2 * nums[3] &lt;= nums[0] ，标记下标 3 和 0 。
 第二次操作中，选择 i = 1 和 j = 2 ，操作可以执行的原因是 2 * nums[1] &lt;= nums[2] ，标记下标 1 和 2 。
 没有其他更多可执行的操作，所以答案为 4 。
 </pre>
 <p><strong>示例 3：</strong></p>
 <pre>
 <b>输入：</b>nums = [7,6,8]
 <b>输出：</b>0
 <strong>解释：</strong>没有任何可以执行的操作，所以答案为 0 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[count-the-number-of-fair-pairs].html
+++ b/[count-the-number-of-fair-pairs].html
@ -0,0 +1,37 @@
 <p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数数组&nbsp;<code>nums</code>&nbsp;，和两个整数&nbsp;<code>lower</code> 和&nbsp;<code>upper</code> ，返回 <strong>公平数对的数目</strong> 。</p>
 <p>如果&nbsp;<code>(i, j)</code>&nbsp;数对满足以下情况，则认为它是一个 <strong>公平数对</strong>&nbsp;：</p>
 <ul>
 	<li><code>0 &lt;= i &lt; j &lt; n</code>，且</li>
 	<li><code>lower &lt;= nums[i] + nums[j] &lt;= upper</code></li>
 </ul>
 <p>&nbsp;</p>
 <p><b>示例 1：</b></p>
 <pre>
 <b>输入：</b>nums = [0,1,7,4,4,5], lower = 3, upper = 6
 <b>输出：</b>6
 <b>解释：</b>共计 6 个公平数对：(0,3)、(0,4)、(0,5)、(1,3)、(1,4) 和 (1,5) 。
 </pre>
 <p><b>示例 2：</b></p>
 <pre>
 <b>输入：</b>nums = [1,7,9,2,5], lower = 11, upper = 11
 <b>输出：</b>1
 <b>解释：</b>只有单个公平数对：(2,3) 。
 </pre>
 <p>&nbsp;</p>
 <p><strong>提示：</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums.length == n</code></li>
 	<li><code>-10<sup>9</sup>&nbsp;&lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 	<li><code>-10<sup>9</sup>&nbsp;&lt;= lower &lt;= upper &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/(English)/修改两个元素的最小分数(English)
+++ b/(English)/修改两个元素的最小分数(English)
@ -0,0 +1,41 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <ul>
 	<li>The <strong>low</strong> score of <code><font face="monospace">nums</font></code> is the minimum value of <code>|nums[i]&nbsp;- nums[j]|</code> over all <code>0 &lt;= i &lt; j &lt; nums.length</code>.</li>
 	<li>The <strong>high</strong> score of&nbsp;<code><font face="monospace">nums</font></code> is the maximum value of <code>|nums[i]&nbsp;- nums[j]|</code> over all <code>0 &lt;= i &lt; j &lt; nums.length</code>.</li>
 	<li>The <strong>score</strong> of <code>nums</code> is the sum of the <strong>high</strong> and <strong>low</strong> scores of nums.</li>
 </ul>
 <p>To minimize the score of <code>nums</code>, we can change the value of <strong>at most two</strong> elements of <code>nums</code>.</p>
 <p>Return <em>the <strong>minimum</strong> possible <strong>score</strong> after changing&nbsp;the value of <strong>at most two</strong> elements o</em>f <code>nums</code>.</p>
 <p>Note that <code>|x|</code> denotes the absolute value of <code>x</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,4,3]
 <strong>Output:</strong> 0
 <strong>Explanation:</strong> Change value of nums[1] and nums[2] to 1 so that nums becomes [1,1,1]. Now, the value of <code>|nums[i] - nums[j]|</code> is always equal to 0, so we return 0 + 0 = 0.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,4,7,8,5]
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> Change nums[0] and nums[1] to be 6. Now nums becomes [6,6,7,8,5].
 Our low score is achieved when i = 0 and j = 1, in which case |<code>nums[i] - nums[j]</code>| = |6 - 6| = 0.
 Our high score is achieved when i = 3 and j = 4, in which case |<code>nums[i] - nums[j]</code>| = |8 - 5| = 3.
 The sum of our high and low score is 3, which we can prove to be minimal.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>3 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[merge-two-2d-arrays-by-summing-values].html
+++ b/[merge-two-2d-arrays-by-summing-values].html
@ -0,0 +1,49 @@
 <p>You are given two <strong>2D</strong> integer arrays <code>nums1</code> and <code>nums2.</code></p>
 <ul>
 	<li><code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
 	<li><code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
 </ul>
 <p>Each array contains <strong>unique</strong> ids and is sorted in <strong>ascending</strong> order by id.</p>
 <p>Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:</p>
 <ul>
 	<li>Only ids that appear in at least one of the two arrays should be included in the resulting array.</li>
 	<li>Each id should be included <strong>only once</strong> and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays then its value in that array is considered to be <code>0</code>.</li>
 </ul>
 <p>Return <em>the resulting array</em>. The returned array must be sorted in ascending order by id.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
 <strong>Output:</strong> [[1,6],[2,3],[3,2],[4,6]]
 <strong>Explanation:</strong> The resulting array contains the following:
 - id = 1, the value of this id is 2 + 4 = 6.
 - id = 2, the value of this id is 3.
 - id = 3, the value of this id is 2.
 - id = 4, the value of this id is 5 + 1 = 6.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
 <strong>Output:</strong> [[1,3],[2,4],[3,6],[4,3],[5,5]]
 <strong>Explanation:</strong> There are no common ids, so we just include each id with its value in the resulting list.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 200</code></li>
 	<li><code>nums1[i].length == nums2[j].length == 2</code></li>
 	<li><code>1 &lt;= id<sub>i</sub>, val<sub>i</sub> &lt;= 1000</code></li>
 	<li>Both arrays contain unique ids.</li>
 	<li>Both arrays are in&nbsp;strictly ascending order by id.</li>
 </ul>
--- a/(English)/在网格图中访问一个格子的最少时间(English)
+++ b/(English)/在网格图中访问一个格子的最少时间(English)
@ -0,0 +1,56 @@
 <p>You are given a <code>m x n</code> matrix <code>grid</code> consisting of <b>non-negative</b> integers where <code>grid[row][col]</code> represents the <strong>minimum</strong> time required to be able to visit the cell <code>(row, col)</code>, which means you can visit the cell <code>(row, col)</code> only when the time you visit it is greater than or equal to <code>grid[row][col]</code>.</p>
 <p>You are standing in the <strong>top-left</strong> cell of the matrix in the <code>0<sup>th</sup></code> second, and you must move to <strong>any</strong> adjacent cell in the four directions: up, down, left, and right. Each move you make takes 1 second.</p>
 <p>Return <em>the <strong>minimum</strong> time required in which you can visit the bottom-right cell of the matrix</em>. If you cannot visit the bottom-right cell, then return <code>-1</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png" /></p>
 <pre>
 <strong>Input:</strong> grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
 <strong>Output:</strong> 7
 <strong>Explanation:</strong> One of the paths that we can take is the following:
 - at t = 0, we are on the cell (0,0).
 - at t = 1, we move to the cell (0,1). It is possible because grid[0][1] &lt;= 1.
 - at t = 2, we move to the cell (1,1). It is possible because grid[1][1] &lt;= 2.
 - at t = 3, we move to the cell (1,2). It is possible because grid[1][2] &lt;= 3.
 - at t = 4, we move to the cell (1,1). It is possible because grid[1][1] &lt;= 4.
 - at t = 5, we move to the cell (1,2). It is possible because grid[1][2] &lt;= 5.
 - at t = 6, we move to the cell (1,3). It is possible because grid[1][3] &lt;= 6.
 - at t = 7, we move to the cell (2,3). It is possible because grid[1][3] &lt;= 7.
 The final time is 7. It can be shown that it is the minimum time possible.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png" style="width: 151px; height: 151px;" /></p>
 <pre>
 <strong>Input:</strong> grid = [[0,2,4],[3,2,1],[1,0,4]]
 <strong>Output:</strong> -1
 <strong>Explanation:</strong> There is no path from the top left to the bottom-right cell.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>m == grid.length</code></li>
 	<li><code>n == grid[i].length</code></li>
 	<li><code>2 &lt;= m, n &lt;= 1000</code></li>
 	<li><code>4 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
 	<li><code>grid[0][0] == 0</code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/(English)/子字符串异或查询(English)
+++ b/(English)/子字符串异或查询(English)
@ -0,0 +1,45 @@
 <p>You are given a <strong>binary string</strong> <code>s</code>, and a <strong>2D</strong> integer array <code>queries</code> where <code>queries[i] = [first<sub>i</sub>, second<sub>i</sub>]</code>.</p>
 <p>For the <code>i<sup>th</sup></code> query, find the <strong>shortest substring</strong> of <code>s</code> whose <strong>decimal value</strong>, <code>val</code>, yields <code>second<sub>i</sub></code> when <strong>bitwise XORed</strong> with <code>first<sub>i</sub></code>. In other words, <code>val ^ first<sub>i</sub> == second<sub>i</sub></code>.</p>
 <p>The answer to the <code>i<sup>th</sup></code> query is the endpoints (<strong>0-indexed</strong>) of the substring <code>[left<sub>i</sub>, right<sub>i</sub>]</code> or <code>[-1, -1]</code> if no such substring exists. If there are multiple answers, choose the one with the <strong>minimum</strong> <code>left<sub>i</sub></code>.</p>
 <p><em>Return an array</em> <code>ans</code> <em>where</em> <code>ans[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> <em>is the answer to the</em> <code>i<sup>th</sup></code> <em>query.</em></p>
 <p>A <strong>substring</strong> is a contiguous non-empty sequence of characters within a string.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;101101&quot;, queries = [[0,5],[1,2]]
 <strong>Output:</strong> [[0,2],[2,3]]
 <strong>Explanation:</strong> For the first query the substring in range <code>[0,2]</code> is <strong>&quot;101&quot;</strong> which has a decimal value of <strong><code>5</code></strong>, and <strong><code>5 ^ 0 = 5</code></strong>, hence the answer to the first query is <code>[0,2]</code>. In the second query, the substring in range <code>[2,3]</code> is <strong>&quot;11&quot;,</strong> and has a decimal value of <strong>3</strong>, and <strong>3<code> ^ 1 = 2</code></strong>.&nbsp;So, <code>[2,3]</code> is returned for the second query. 
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;0101&quot;, queries = [[12,8]]
 <strong>Output:</strong> [[-1,-1]]
 <strong>Explanation:</strong> In this example there is no substring that answers the query, hence <code>[-1,-1] is returned</code>.
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;1&quot;, queries = [[4,5]]
 <strong>Output:</strong> [[0,0]]
 <strong>Explanation:</strong> For this example, the substring in range <code>[0,0]</code> has a decimal value of <strong><code>1</code></strong>, and <strong><code>1 ^ 4 = 5</code></strong>. So, the answer is <code>[0,0]</code>.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
 	<li><code>s[i]</code> is either <code>&#39;0&#39;</code> or <code>&#39;1&#39;</code>.</li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= first<sub>i</sub>, second<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/(English)/将整数减少到零需要的最少操作数(English)
+++ b/(English)/将整数减少到零需要的最少操作数(English)
@ -0,0 +1,41 @@
 <p>You are given a positive integer <code>n</code>, you can do the following operation <strong>any</strong> number of times:</p>
 <ul>
 	<li>Add or subtract a <strong>power</strong> of <code>2</code> from <code>n</code>.</li>
 </ul>
 <p>Return <em>the <strong>minimum</strong> number of operations to make </em><code>n</code><em> equal to </em><code>0</code>.</p>
 <p>A number <code>x</code> is power of <code>2</code> if <code>x == 2<sup>i</sup></code>&nbsp;where <code>i &gt;= 0</code><em>.</em></p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> n = 39
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> We can do the following operations:
 - Add 2<sup>0</sup> = 1 to n, so now n = 40.
 - Subtract 2<sup>3</sup> = 8 from n, so now n = 32.
 - Subtract 2<sup>5</sup> = 32 from n, so now n = 0.
 It can be shown that 3 is the minimum number of operations we need to make n equal to 0.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> n = 54
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> We can do the following operations:
 - Add 2<sup>1</sup> = 2 to n, so now n = 56.
 - Add 2<sup>3</sup> = 8 to n, so now n = 64.
 - Subtract 2<sup>6</sup> = 64 from n, so now n = 0.
 So the minimum number of operations is 3.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/(English)/左右元素和的差值(English)
+++ b/(English)/左右元素和的差值(English)
@ -0,0 +1,42 @@
 <p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, find a <strong>0-indexed </strong>integer array <code>answer</code> where:</p>
 <ul>
    <li><code>answer.length == nums.length</code>.</li>
    <li><code>answer[i] = |leftSum[i] - rightSum[i]|</code>.</li>
 </ul>
 <p>Where:</p>
 <ul>
    <li><code>leftSum[i]</code> is the sum of elements to the left of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>leftSum[i] = 0</code>.</li>
    <li><code>rightSum[i]</code> is the sum of elements to the right of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>rightSum[i] = 0</code>.</li>
 </ul>
 <p>Return <em>the array</em> <code>answer</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [10,4,8,3]
 <strong>Output:</strong> [15,1,11,22]
 <strong>Explanation:</strong> The array leftSum is [0,10,14,22] and the array rightSum is [15,11,3,0].
 The array answer is [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22].
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1]
 <strong>Output:</strong> [0]
 <strong>Explanation:</strong> The array leftSum is [0] and the array rightSum is [0].
 The array answer is [|0 - 0|] = [0].
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/(English)/找出字符串的可整除数组(English)
+++ b/(English)/找出字符串的可整除数组(English)
@ -0,0 +1,37 @@
 <p>You are given a <strong>0-indexed</strong> string <code>word</code> of length <code>n</code>&nbsp;consisting of digits, and a positive integer&nbsp;<code>m</code>.</p>
 <p>The <strong>divisibility array</strong> <code>div</code> of <code>word</code> is an integer array of length <code>n</code> such that:</p>
 <ul>
 	<li><code>div[i] = 1</code> if the&nbsp;<strong>numeric value</strong>&nbsp;of&nbsp;<code>word[0,...,i]</code> is divisible by <code>m</code>, or</li>
 	<li><code>div[i] = 0</code> otherwise.</li>
 </ul>
 <p>Return<em> the divisibility array of</em><em> </em><code>word</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> word = &quot;998244353&quot;, m = 3
 <strong>Output:</strong> [1,1,0,0,0,1,1,0,0]
 <strong>Explanation:</strong> There are only 4 prefixes that are divisible by 3: &quot;9&quot;, &quot;99&quot;, &quot;998244&quot;, and &quot;9982443&quot;.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> word = &quot;1010&quot;, m = 10
 <strong>Output:</strong> [0,1,0,1]
 <strong>Explanation:</strong> There are only 2 prefixes that are divisible by 10: &quot;10&quot;, and &quot;1010&quot;.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 	<li><code><font face="monospace">word.length == n</font></code></li>
 	<li><code><font face="monospace">word</font></code><font face="monospace"> consists of digits from <code>0</code>&nbsp;to <code>9</code></font></li>
 	<li><code><font face="monospace">1 &lt;= m &lt;= 10<sup>9</sup></font></code></li>
 </ul>
--- a/[find-the-string-with-lcp].html
+++ b/[find-the-string-with-lcp].html
@ -0,0 +1,42 @@
 <p>We define the <code>lcp</code> matrix of any <strong>0-indexed</strong> string <code>word</code> of <code>n</code> lowercase English letters as an <code>n x n</code> grid such that:</p>
 <ul>
 	<li><code>lcp[i][j]</code> is equal to the length of the <strong>longest common prefix</strong> between the substrings <code>word[i,n-1]</code> and <code>word[j,n-1]</code>.</li>
 </ul>
 <p>Given an&nbsp;<code>n x n</code> matrix <code>lcp</code>, return the alphabetically smallest string <code>word</code> that corresponds to <code>lcp</code>. If there is no such string, return an empty string.</p>
 <p>A string <code>a</code> is lexicographically smaller than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears earlier in the alphabet than the corresponding letter in <code>b</code>. For example, <code>&quot;aabd&quot;</code> is lexicographically smaller than <code>&quot;aaca&quot;</code> because the first position they differ is at the third letter, and <code>&#39;b&#39;</code> comes before <code>&#39;c&#39;</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
 <strong>Output:</strong> &quot;abab&quot;
 <strong>Explanation:</strong> lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is &quot;abab&quot;.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
 <strong>Output:</strong> &quot;aaaa&quot;
 <strong>Explanation:</strong> lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is &quot;aaaa&quot;. 
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
 <strong>Output:</strong> &quot;&quot;
 <strong>Explanation:</strong> lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n ==&nbsp;</code><code>lcp.length == </code><code>lcp[i].length</code>&nbsp;<code>&lt;= 1000</code></li>
 	<li><code><font face="monospace">0 &lt;= lcp[i][j] &lt;= n</font></code></li>
 </ul>
--- a/(English)/找出数组的串联值(English)
+++ b/(English)/找出数组的串联值(English)
@ -0,0 +1,71 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <p>The <strong>concatenation</strong> of two numbers is the number formed by concatenating their numerals.</p>
 <ul>
 	<li>For example, the concatenation of <code>15</code>, <code>49</code> is <code>1549</code>.</li>
 </ul>
 <p>The <strong>concatenation value</strong> of <code>nums</code> is initially equal to <code>0</code>. Perform this operation until <code>nums</code> becomes empty:</p>
 <ul>
 	<li>If there exists more than one number in <code>nums</code>, pick the first element and last element in <code>nums</code> respectively and add the value of their concatenation to the <strong>concatenation value</strong> of <code>nums</code>, then delete the first and last element from <code>nums</code>.</li>
 	<li>If one element exists, add its value to the <strong>concatenation value</strong> of <code>nums</code>, then delete it.</li>
 </ul>
 <p>Return<em> the concatenation value of the <code>nums</code></em>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [7,52,2,4]
 <strong>Output:</strong> 596
 <strong>Explanation:</strong> Before performing any operation, nums is [7,52,2,4] and concatenation value is 0.
 - In the first operation:
 We pick the first element, 7, and the last element, 4.
 Their concatenation is 74, and we add it to the concatenation value, so it becomes equal to 74.
 Then we delete them from nums, so nums becomes equal to [52,2].
 - In the second operation:
 We pick the first element, 52, and the last element, 2.
 Their concatenation is 522, and we add it to the concatenation value, so it becomes equal to 596.
 Then we delete them from the nums, so nums becomes empty.
 Since the concatenation value is 596 so the answer is 596.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [5,14,13,8,12]
 <strong>Output:</strong> 673
 <strong>Explanation:</strong> Before performing any operation, nums is [5,14,13,8,12] and concatenation value is 0.
 - In the first operation:
 We pick the first element, 5, and the last element, 12.
 Their concatenation is 512, and we add it to the concatenation value, so it becomes equal to 512.
 Then we delete them from the nums, so nums becomes equal to [14,13,8].
 - In the second operation:
 We pick the first element, 14, and the last element, 8.
 Their concatenation is 148, and we add it to the concatenation value, so it becomes equal to 660.
 Then we delete them from the nums, so nums becomes equal to [13].
 - In the third operation:
 nums has only one element, so we pick 13 and add it to the concatenation value, so it becomes equal to 673.
 Then we delete it from nums, so nums become empty.
 Since the concatenation value is 673 so the answer is 673.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/[count-the-number-of-square-free-subsets].html
+++ b/[count-the-number-of-square-free-subsets].html
@ -0,0 +1,39 @@
 <p>You are given a positive integer <strong>0-indexed</strong>&nbsp;array <code>nums</code>.</p>
 <p>A subset of the array <code>nums</code> is <strong>square-free</strong> if the product of its elements is a <strong>square-free integer</strong>.</p>
 <p>A <strong>square-free integer</strong> is an integer that is divisible by no square number other than <code>1</code>.</p>
 <p>Return <em>the number of square-free non-empty subsets of the array</em> <strong>nums</strong>. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
 <p>A <strong>non-empty</strong>&nbsp;<strong>subset</strong> of <code>nums</code> is an array that can be obtained by deleting some (possibly none but not all) elements from <code>nums</code>. Two subsets are different if and only if the chosen indices to delete are different.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [3,4,4,5]
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> There are 3 square-free subsets in this example:
 - The subset consisting of the 0<sup>th</sup> element [3]. The product of its elements is 3, which is a square-free integer.
 - The subset consisting of the 3<sup>rd</sup> element [5]. The product of its elements is 5, which is a square-free integer.
 - The subset consisting of 0<sup>th</sup> and 3<sup>rd</sup> elements [3,5]. The product of its elements is 15, which is a square-free integer.
 It can be proven that there are no more than 3 square-free subsets in the given array.</pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1]
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> There is 1 square-free subset in this example:
 - The subset consisting of the 0<sup>th</sup> element [1]. The product of its elements is 1, which is a square-free integer.
 It can be proven that there is no more than 1 square-free subset in the given array.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length&nbsp;&lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 30</code></li>
 </ul>
--- a/(English)/更新数组后处理求和查询(English)
+++ b/(English)/更新数组后处理求和查询(English)
@ -0,0 +1,40 @@
 <p>You are given two <strong>0-indexed</strong> arrays <code>nums1</code> and <code>nums2</code> and a 2D array <code>queries</code> of queries. There are three types of queries:</p>
 <ol>
 	<li>For a query of type 1, <code>queries[i]&nbsp;= [1, l, r]</code>. Flip the values from <code>0</code> to <code>1</code> and from <code>1</code> to <code>0</code> in <code>nums1 </code>from index <code>l</code> to index <code>r</code>. Both <code>l</code> and <code>r</code> are <strong>0-indexed</strong>.</li>
 	<li>For a query of type 2, <code>queries[i]&nbsp;= [2, p, 0]</code>. For every index <code>0 &lt;= i &lt; n</code>, set&nbsp;<code>nums2[i] =&nbsp;nums2[i]&nbsp;+ nums1[i]&nbsp;* p</code>.</li>
 	<li>For a query of type 3, <code>queries[i]&nbsp;= [3, 0, 0]</code>. Find the sum of the elements in <code>nums2</code>.</li>
 </ol>
 <p>Return <em>an array containing all the answers to the third type&nbsp;queries.</em></p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [1,0,1], nums2 = [0,0,0], queries = [[1,1,1],[2,1,0],[3,0,0]]
 <strong>Output:</strong> [3]
 <strong>Explanation:</strong> After the first query nums1 becomes [1,1,1]. After the second query, nums2 becomes [1,1,1], so the answer to the third query is 3. Thus, [3] is returned.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [1], nums2 = [5], queries = [[2,0,0],[3,0,0]]
 <strong>Output:</strong> [5]
 <strong>Explanation:</strong> After the first query, nums2 remains [5], so the answer to the second query is 5. Thus, [5] is returned.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length,nums2.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums1.length = nums2.length</code></li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code><font face="monospace">queries[i].length = 3</font></code></li>
 	<li><code><font face="monospace">0 &lt;= l &lt;= r &lt;= nums1.length - 1</font></code></li>
 	<li><code><font face="monospace">0 &lt;= p &lt;= 10<sup>6</sup></font></code></li>
 	<li><code>0 &lt;= nums1[i] &lt;= 1</code></li>
 	<li><code>0 &lt;= nums2[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/(English)/替换一个数字后的最大差值(English)
+++ b/(English)/替换一个数字后的最大差值(English)
@ -0,0 +1,41 @@
 <p>You are given an integer <code>num</code>. You know that Danny Mittal will sneakily <strong>remap</strong> one of the <code>10</code> possible digits (<code>0</code> to <code>9</code>) to another digit.</p>
 <p>Return <em>the difference between the maximum and minimum</em><em>&nbsp;values Danny can make by remapping&nbsp;<strong>exactly</strong> <strong>one</strong> digit</em><em> in </em><code>num</code>.</p>
 <p><strong>Notes:</strong></p>
 <ul>
 	<li>When Danny remaps a digit <font face="monospace">d1</font>&nbsp;to another digit <font face="monospace">d2</font>, Danny replaces all occurrences of <code>d1</code>&nbsp;in <code>num</code>&nbsp;with <code>d2</code>.</li>
 	<li>Danny can remap a digit to itself, in which case <code>num</code>&nbsp;does not change.</li>
 	<li>Danny can remap different digits for obtaining minimum and maximum values respectively.</li>
 	<li>The resulting number after remapping can contain leading zeroes.</li>
 	<li>We mentioned &quot;Danny Mittal&quot; to congratulate him on being in the top 10 in Weekly Contest 326.</li>
 </ul>
 <p>&nbsp;</p>
 <p><strong>Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> num = 11891
 <strong>Output:</strong> 99009
 <strong>Explanation:</strong> 
 To achieve the maximum value, Danny can remap the digit 1 to the digit 9 to yield 99899.
 To achieve the minimum value, Danny can remap the digit 1 to the digit 0, yielding 890.
 The difference between these two numbers is 99009.
 </pre>
 <p><strong>Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> num = 90
 <strong>Output:</strong> 99
 <strong>Explanation:</strong>
 The maximum value that can be returned by the function is 99 (if 0 is replaced by 9) and the minimum value that can be returned by the function is 0 (if 9 is replaced by 0).
 Thus, we return 99.</pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= num &lt;= 10<sup>8</sup></code></li>
 </ul>
--- a/(English)/最小无法得到的或值(English)
+++ b/(English)/最小无法得到的或值(English)
@ -0,0 +1,30 @@
 <p>You are given a <strong>0-indexed</strong>&nbsp;integer array <code>nums</code>.</p>
 <p>We say that an integer x is <strong>expressible</strong> from <code>nums</code> if there exist some integers <code>0 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt; ... &lt; index<sub>k</sub> &lt; nums.length</code> for which <code>nums[index<sub>1</sub>] | nums[index<sub>2</sub>] | ... | nums[index<sub>k</sub>] = x</code>. In other words, an integer is expressible if it can be written as the bitwise OR of some subsequence of <code>nums</code>.</p>
 <p>Return <em>the minimum <strong>positive non-zero integer</strong>&nbsp;that is not </em><em>expressible from </em><code>nums</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [2,1]
 <strong>Output:</strong> 4
 <strong>Explanation:</strong> 1 and 2 are already present in the array. We know that 3 is expressible, since nums[0] | nums[1] = 2 | 1 = 3. Since 4 is not expressible, we return 4.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [5,3,2]
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> We can show that 1 is the smallest number that is not expressible.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/[subsequence-with-the-minimum-score].html
+++ b/[subsequence-with-the-minimum-score].html
@ -0,0 +1,45 @@
 <p>You are given two strings <code>s</code> and <code>t</code>.</p>
 <p>You are allowed to remove any number of characters from the string <code>t</code>.</p>
 <p>The score of the string is <code>0</code> if no characters are removed from the string <code>t</code>, otherwise:</p>
 <ul>
 	<li>Let <code>left</code> be the minimum index among all removed characters.</li>
 	<li>Let <code>right</code> be the maximum index among all removed characters.</li>
 </ul>
 <p>Then the score of the string is <code>right - left + 1</code>.</p>
 <p>Return <em>the minimum possible score to make </em><code>t</code><em>&nbsp;a subsequence of </em><code>s</code><em>.</em></p>
 <p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>&quot;ace&quot;</code> is a subsequence of <code>&quot;<u>a</u>b<u>c</u>d<u>e</u>&quot;</code> while <code>&quot;aec&quot;</code> is not).</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;abacaba&quot;, t = &quot;bzaa&quot;
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> In this example, we remove the character &quot;z&quot; at index 1 (0-indexed).
 The string t becomes &quot;baa&quot; which is a subsequence of the string &quot;abacaba&quot; and the score is 1 - 1 + 1 = 1.
 It can be proven that 1 is the minimum score that we can achieve.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;cde&quot;, t = &quot;xyz&quot;
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> In this example, we remove characters &quot;x&quot;, &quot;y&quot; and &quot;z&quot; at indices 0, 1, and 2 (0-indexed).
 The string t becomes &quot;&quot; which is a subsequence of the string &quot;cde&quot; and the score is 2 - 0 + 1 = 3.
 It can be proven that 3 is the minimum score that we can achieve.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>s</code> and <code>t</code> consist of only lowercase English letters.</li>
 </ul>
--- a/[find-the-maximum-number-of-marked-indices].html
+++ b/[find-the-maximum-number-of-marked-indices].html
@ -0,0 +1,55 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <p>Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:</p>
 <ul>
 	<li>Pick two <strong>different unmarked</strong> indices <code>i</code> and <code>j</code> such that <code>2 * nums[i] &lt;= nums[j]</code>, then mark <code>i</code> and <code>j</code>.</li>
 </ul>
 <p>Return <em>the maximum possible number of marked indices in <code>nums</code> using the above operation any number of times</em>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [3,5,2,4]
 <strong>Output:</strong> 2
 <strong>Explanation: </strong>In the first operation: pick i = 2 and j = 1, the operation is allowed because 2 * nums[2] &lt;= nums[1]. Then mark index 2 and 1.
 It can be shown that there&#39;s no other valid operation so the answer is 2.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [9,2,5,4]
 <strong>Output:</strong> 4
 <strong>Explanation: </strong>In the first operation: pick i = 3 and j = 0, the operation is allowed because 2 * nums[3] &lt;= nums[0]. Then mark index 3 and 0.
 In the second operation: pick i = 1 and j = 2, the operation is allowed because 2 * nums[1] &lt;= nums[2]. Then mark index 1 and 2.
 Since there is no other operation, the answer is 4.
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [7,6,8]
 <strong>Output:</strong> 0
 <strong>Explanation: </strong>There is no valid operation to do, so the answer is 0.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/(English)/统计公平数对的数目(English)
+++ b/(English)/统计公平数对的数目(English)
@ -0,0 +1,35 @@
 <p>Given a <strong>0-indexed</strong> integer array <code>nums</code> of size <code>n</code> and two integers <code>lower</code> and <code>upper</code>, return <em>the number of fair pairs</em>.</p>
 <p>A pair <code>(i, j)</code> is <b>fair </b>if:</p>
 <ul>
 	<li><code>0 &lt;= i &lt; j &lt; n</code>, and</li>
 	<li><code>lower &lt;= nums[i] + nums[j] &lt;= upper</code></li>
 </ul>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [0,1,7,4,4,5], lower = 3, upper = 6
 <strong>Output:</strong> 6
 <strong>Explanation:</strong> There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,7,9,2,5], lower = 11, upper = 11
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> There is a single fair pair: (2,3).
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums.length == n</code></li>
 	<li><code><font face="monospace">-10<sup>9</sup></font>&nbsp;&lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 	<li><code><font face="monospace">-10<sup>9</sup>&nbsp;&lt;= lower &lt;= upper &lt;= 10<sup>9</sup></font></code></li>
 </ul>
--- a/leetcode/origin-data.json
+++ b/leetcode/origin-data.json
--- a/leetcode/originData/count-the-number-of-fair-pairs.json
+++ b/leetcode/originData/count-the-number-of-fair-pairs.json
--- a/leetcode/originData/count-the-number-of-square-free-subsets.json
+++ b/leetcode/originData/count-the-number-of-square-free-subsets.json
--- a/leetcode/originData/find-the-array-concatenation-value.json
+++ b/leetcode/originData/find-the-array-concatenation-value.json
--- a/leetcode/originData/find-the-divisibility-array-of-a-string.json
+++ b/leetcode/originData/find-the-divisibility-array-of-a-string.json
--- a/leetcode/originData/find-the-maximum-number-of-marked-indices.json
+++ b/leetcode/originData/find-the-maximum-number-of-marked-indices.json
--- a/leetcode/originData/find-the-string-with-lcp.json
+++ b/leetcode/originData/find-the-string-with-lcp.json
--- a/leetcode/originData/handling-sum-queries-after-update.json
+++ b/leetcode/originData/handling-sum-queries-after-update.json
--- a/leetcode/originData/left-and-right-sum-differences.json
+++ b/leetcode/originData/left-and-right-sum-differences.json
--- a/leetcode/originData/maximum-difference-by-remapping-a-digit.json
+++ b/leetcode/originData/maximum-difference-by-remapping-a-digit.json
--- a/leetcode/originData/merge-two-2d-arrays-by-summing-values.json
+++ b/leetcode/originData/merge-two-2d-arrays-by-summing-values.json
--- a/leetcode/originData/minimum-impossible-or.json
+++ b/leetcode/originData/minimum-impossible-or.json
--- a/leetcode/originData/minimum-operations-to-reduce-an-integer-to-0.json
+++ b/leetcode/originData/minimum-operations-to-reduce-an-integer-to-0.json
--- a/leetcode/originData/minimum-score-by-changing-two-elements.json
+++ b/leetcode/originData/minimum-score-by-changing-two-elements.json
--- a/leetcode/originData/minimum-time-to-visit-a-cell-in-a-grid.json
+++ b/leetcode/originData/minimum-time-to-visit-a-cell-in-a-grid.json
--- a/leetcode/originData/subsequence-with-the-minimum-score.json
+++ b/leetcode/originData/subsequence-with-the-minimum-score.json
--- a/leetcode/originData/substring-xor-queries.json
+++ b/leetcode/originData/substring-xor-queries.json
--- a/leetcode/problem/count-the-number-of-fair-pairs.html
+++ b/leetcode/problem/count-the-number-of-fair-pairs.html
@ -0,0 +1,35 @@
 <p>Given a <strong>0-indexed</strong> integer array <code>nums</code> of size <code>n</code> and two integers <code>lower</code> and <code>upper</code>, return <em>the number of fair pairs</em>.</p>
 <p>A pair <code>(i, j)</code> is <b>fair </b>if:</p>
 <ul>
 	<li><code>0 &lt;= i &lt; j &lt; n</code>, and</li>
 	<li><code>lower &lt;= nums[i] + nums[j] &lt;= upper</code></li>
 </ul>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [0,1,7,4,4,5], lower = 3, upper = 6
 <strong>Output:</strong> 6
 <strong>Explanation:</strong> There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,7,9,2,5], lower = 11, upper = 11
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> There is a single fair pair: (2,3).
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums.length == n</code></li>
 	<li><code><font face="monospace">-10<sup>9</sup></font>&nbsp;&lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 	<li><code><font face="monospace">-10<sup>9</sup>&nbsp;&lt;= lower &lt;= upper &lt;= 10<sup>9</sup></font></code></li>
 </ul>
--- a/leetcode/problem/count-the-number-of-square-free-subsets.html
+++ b/leetcode/problem/count-the-number-of-square-free-subsets.html
@ -0,0 +1,39 @@
 <p>You are given a positive integer <strong>0-indexed</strong>&nbsp;array <code>nums</code>.</p>
 <p>A subset of the array <code>nums</code> is <strong>square-free</strong> if the product of its elements is a <strong>square-free integer</strong>.</p>
 <p>A <strong>square-free integer</strong> is an integer that is divisible by no square number other than <code>1</code>.</p>
 <p>Return <em>the number of square-free non-empty subsets of the array</em> <strong>nums</strong>. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
 <p>A <strong>non-empty</strong>&nbsp;<strong>subset</strong> of <code>nums</code> is an array that can be obtained by deleting some (possibly none but not all) elements from <code>nums</code>. Two subsets are different if and only if the chosen indices to delete are different.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [3,4,4,5]
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> There are 3 square-free subsets in this example:
 - The subset consisting of the 0<sup>th</sup> element [3]. The product of its elements is 3, which is a square-free integer.
 - The subset consisting of the 3<sup>rd</sup> element [5]. The product of its elements is 5, which is a square-free integer.
 - The subset consisting of 0<sup>th</sup> and 3<sup>rd</sup> elements [3,5]. The product of its elements is 15, which is a square-free integer.
 It can be proven that there are no more than 3 square-free subsets in the given array.</pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1]
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> There is 1 square-free subset in this example:
 - The subset consisting of the 0<sup>th</sup> element [1]. The product of its elements is 1, which is a square-free integer.
 It can be proven that there is no more than 1 square-free subset in the given array.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length&nbsp;&lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 30</code></li>
 </ul>
--- a/leetcode/problem/find-the-array-concatenation-value.html
+++ b/leetcode/problem/find-the-array-concatenation-value.html
@ -0,0 +1,71 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <p>The <strong>concatenation</strong> of two numbers is the number formed by concatenating their numerals.</p>
 <ul>
 	<li>For example, the concatenation of <code>15</code>, <code>49</code> is <code>1549</code>.</li>
 </ul>
 <p>The <strong>concatenation value</strong> of <code>nums</code> is initially equal to <code>0</code>. Perform this operation until <code>nums</code> becomes empty:</p>
 <ul>
 	<li>If there exists more than one number in <code>nums</code>, pick the first element and last element in <code>nums</code> respectively and add the value of their concatenation to the <strong>concatenation value</strong> of <code>nums</code>, then delete the first and last element from <code>nums</code>.</li>
 	<li>If one element exists, add its value to the <strong>concatenation value</strong> of <code>nums</code>, then delete it.</li>
 </ul>
 <p>Return<em> the concatenation value of the <code>nums</code></em>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [7,52,2,4]
 <strong>Output:</strong> 596
 <strong>Explanation:</strong> Before performing any operation, nums is [7,52,2,4] and concatenation value is 0.
 - In the first operation:
 We pick the first element, 7, and the last element, 4.
 Their concatenation is 74, and we add it to the concatenation value, so it becomes equal to 74.
 Then we delete them from nums, so nums becomes equal to [52,2].
 - In the second operation:
 We pick the first element, 52, and the last element, 2.
 Their concatenation is 522, and we add it to the concatenation value, so it becomes equal to 596.
 Then we delete them from the nums, so nums becomes empty.
 Since the concatenation value is 596 so the answer is 596.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [5,14,13,8,12]
 <strong>Output:</strong> 673
 <strong>Explanation:</strong> Before performing any operation, nums is [5,14,13,8,12] and concatenation value is 0.
 - In the first operation:
 We pick the first element, 5, and the last element, 12.
 Their concatenation is 512, and we add it to the concatenation value, so it becomes equal to 512.
 Then we delete them from the nums, so nums becomes equal to [14,13,8].
 - In the second operation:
 We pick the first element, 14, and the last element, 8.
 Their concatenation is 148, and we add it to the concatenation value, so it becomes equal to 660.
 Then we delete them from the nums, so nums becomes equal to [13].
 - In the third operation:
 nums has only one element, so we pick 13 and add it to the concatenation value, so it becomes equal to 673.
 Then we delete it from nums, so nums become empty.
 Since the concatenation value is 673 so the answer is 673.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/leetcode/problem/find-the-divisibility-array-of-a-string.html
+++ b/leetcode/problem/find-the-divisibility-array-of-a-string.html
@ -0,0 +1,37 @@
 <p>You are given a <strong>0-indexed</strong> string <code>word</code> of length <code>n</code>&nbsp;consisting of digits, and a positive integer&nbsp;<code>m</code>.</p>
 <p>The <strong>divisibility array</strong> <code>div</code> of <code>word</code> is an integer array of length <code>n</code> such that:</p>
 <ul>
 	<li><code>div[i] = 1</code> if the&nbsp;<strong>numeric value</strong>&nbsp;of&nbsp;<code>word[0,...,i]</code> is divisible by <code>m</code>, or</li>
 	<li><code>div[i] = 0</code> otherwise.</li>
 </ul>
 <p>Return<em> the divisibility array of</em><em> </em><code>word</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> word = &quot;998244353&quot;, m = 3
 <strong>Output:</strong> [1,1,0,0,0,1,1,0,0]
 <strong>Explanation:</strong> There are only 4 prefixes that are divisible by 3: &quot;9&quot;, &quot;99&quot;, &quot;998244&quot;, and &quot;9982443&quot;.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> word = &quot;1010&quot;, m = 10
 <strong>Output:</strong> [0,1,0,1]
 <strong>Explanation:</strong> There are only 2 prefixes that are divisible by 10: &quot;10&quot;, and &quot;1010&quot;.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 	<li><code><font face="monospace">word.length == n</font></code></li>
 	<li><code><font face="monospace">word</font></code><font face="monospace"> consists of digits from <code>0</code>&nbsp;to <code>9</code></font></li>
 	<li><code><font face="monospace">1 &lt;= m &lt;= 10<sup>9</sup></font></code></li>
 </ul>
--- a/leetcode/problem/find-the-maximum-number-of-marked-indices.html
+++ b/leetcode/problem/find-the-maximum-number-of-marked-indices.html
@ -0,0 +1,55 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <p>Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:</p>
 <ul>
 	<li>Pick two <strong>different unmarked</strong> indices <code>i</code> and <code>j</code> such that <code>2 * nums[i] &lt;= nums[j]</code>, then mark <code>i</code> and <code>j</code>.</li>
 </ul>
 <p>Return <em>the maximum possible number of marked indices in <code>nums</code> using the above operation any number of times</em>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [3,5,2,4]
 <strong>Output:</strong> 2
 <strong>Explanation: </strong>In the first operation: pick i = 2 and j = 1, the operation is allowed because 2 * nums[2] &lt;= nums[1]. Then mark index 2 and 1.
 It can be shown that there&#39;s no other valid operation so the answer is 2.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [9,2,5,4]
 <strong>Output:</strong> 4
 <strong>Explanation: </strong>In the first operation: pick i = 3 and j = 0, the operation is allowed because 2 * nums[3] &lt;= nums[0]. Then mark index 3 and 0.
 In the second operation: pick i = 1 and j = 2, the operation is allowed because 2 * nums[1] &lt;= nums[2]. Then mark index 1 and 2.
 Since there is no other operation, the answer is 4.
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [7,6,8]
 <strong>Output:</strong> 0
 <strong>Explanation: </strong>There is no valid operation to do, so the answer is 0.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/leetcode/problem/find-the-string-with-lcp.html
+++ b/leetcode/problem/find-the-string-with-lcp.html
@ -0,0 +1,42 @@
 <p>We define the <code>lcp</code> matrix of any <strong>0-indexed</strong> string <code>word</code> of <code>n</code> lowercase English letters as an <code>n x n</code> grid such that:</p>
 <ul>
 	<li><code>lcp[i][j]</code> is equal to the length of the <strong>longest common prefix</strong> between the substrings <code>word[i,n-1]</code> and <code>word[j,n-1]</code>.</li>
 </ul>
 <p>Given an&nbsp;<code>n x n</code> matrix <code>lcp</code>, return the alphabetically smallest string <code>word</code> that corresponds to <code>lcp</code>. If there is no such string, return an empty string.</p>
 <p>A string <code>a</code> is lexicographically smaller than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears earlier in the alphabet than the corresponding letter in <code>b</code>. For example, <code>&quot;aabd&quot;</code> is lexicographically smaller than <code>&quot;aaca&quot;</code> because the first position they differ is at the third letter, and <code>&#39;b&#39;</code> comes before <code>&#39;c&#39;</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
 <strong>Output:</strong> &quot;abab&quot;
 <strong>Explanation:</strong> lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is &quot;abab&quot;.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
 <strong>Output:</strong> &quot;aaaa&quot;
 <strong>Explanation:</strong> lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is &quot;aaaa&quot;. 
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
 <strong>Output:</strong> &quot;&quot;
 <strong>Explanation:</strong> lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n ==&nbsp;</code><code>lcp.length == </code><code>lcp[i].length</code>&nbsp;<code>&lt;= 1000</code></li>
 	<li><code><font face="monospace">0 &lt;= lcp[i][j] &lt;= n</font></code></li>
 </ul>
--- a/leetcode/problem/handling-sum-queries-after-update.html
+++ b/leetcode/problem/handling-sum-queries-after-update.html
@ -0,0 +1,40 @@
 <p>You are given two <strong>0-indexed</strong> arrays <code>nums1</code> and <code>nums2</code> and a 2D array <code>queries</code> of queries. There are three types of queries:</p>
 <ol>
 	<li>For a query of type 1, <code>queries[i]&nbsp;= [1, l, r]</code>. Flip the values from <code>0</code> to <code>1</code> and from <code>1</code> to <code>0</code> in <code>nums1 </code>from index <code>l</code> to index <code>r</code>. Both <code>l</code> and <code>r</code> are <strong>0-indexed</strong>.</li>
 	<li>For a query of type 2, <code>queries[i]&nbsp;= [2, p, 0]</code>. For every index <code>0 &lt;= i &lt; n</code>, set&nbsp;<code>nums2[i] =&nbsp;nums2[i]&nbsp;+ nums1[i]&nbsp;* p</code>.</li>
 	<li>For a query of type 3, <code>queries[i]&nbsp;= [3, 0, 0]</code>. Find the sum of the elements in <code>nums2</code>.</li>
 </ol>
 <p>Return <em>an array containing all the answers to the third type&nbsp;queries.</em></p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [1,0,1], nums2 = [0,0,0], queries = [[1,1,1],[2,1,0],[3,0,0]]
 <strong>Output:</strong> [3]
 <strong>Explanation:</strong> After the first query nums1 becomes [1,1,1]. After the second query, nums2 becomes [1,1,1], so the answer to the third query is 3. Thus, [3] is returned.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [1], nums2 = [5], queries = [[2,0,0],[3,0,0]]
 <strong>Output:</strong> [5]
 <strong>Explanation:</strong> After the first query, nums2 remains [5], so the answer to the second query is 5. Thus, [5] is returned.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length,nums2.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>nums1.length = nums2.length</code></li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code><font face="monospace">queries[i].length = 3</font></code></li>
 	<li><code><font face="monospace">0 &lt;= l &lt;= r &lt;= nums1.length - 1</font></code></li>
 	<li><code><font face="monospace">0 &lt;= p &lt;= 10<sup>6</sup></font></code></li>
 	<li><code>0 &lt;= nums1[i] &lt;= 1</code></li>
 	<li><code>0 &lt;= nums2[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/leetcode/problem/left-and-right-sum-differences.html
+++ b/leetcode/problem/left-and-right-sum-differences.html
@ -0,0 +1,42 @@
 <p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, find a <strong>0-indexed </strong>integer array <code>answer</code> where:</p>
 <ul>
    <li><code>answer.length == nums.length</code>.</li>
    <li><code>answer[i] = |leftSum[i] - rightSum[i]|</code>.</li>
 </ul>
 <p>Where:</p>
 <ul>
    <li><code>leftSum[i]</code> is the sum of elements to the left of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>leftSum[i] = 0</code>.</li>
    <li><code>rightSum[i]</code> is the sum of elements to the right of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>rightSum[i] = 0</code>.</li>
 </ul>
 <p>Return <em>the array</em> <code>answer</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [10,4,8,3]
 <strong>Output:</strong> [15,1,11,22]
 <strong>Explanation:</strong> The array leftSum is [0,10,14,22] and the array rightSum is [15,11,3,0].
 The array answer is [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22].
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1]
 <strong>Output:</strong> [0]
 <strong>Explanation:</strong> The array leftSum is [0] and the array rightSum is [0].
 The array answer is [|0 - 0|] = [0].
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/leetcode/problem/maximum-difference-by-remapping-a-digit.html
+++ b/leetcode/problem/maximum-difference-by-remapping-a-digit.html
@ -0,0 +1,41 @@
 <p>You are given an integer <code>num</code>. You know that Danny Mittal will sneakily <strong>remap</strong> one of the <code>10</code> possible digits (<code>0</code> to <code>9</code>) to another digit.</p>
 <p>Return <em>the difference between the maximum and minimum</em><em>&nbsp;values Danny can make by remapping&nbsp;<strong>exactly</strong> <strong>one</strong> digit</em><em> in </em><code>num</code>.</p>
 <p><strong>Notes:</strong></p>
 <ul>
 	<li>When Danny remaps a digit <font face="monospace">d1</font>&nbsp;to another digit <font face="monospace">d2</font>, Danny replaces all occurrences of <code>d1</code>&nbsp;in <code>num</code>&nbsp;with <code>d2</code>.</li>
 	<li>Danny can remap a digit to itself, in which case <code>num</code>&nbsp;does not change.</li>
 	<li>Danny can remap different digits for obtaining minimum and maximum values respectively.</li>
 	<li>The resulting number after remapping can contain leading zeroes.</li>
 	<li>We mentioned &quot;Danny Mittal&quot; to congratulate him on being in the top 10 in Weekly Contest 326.</li>
 </ul>
 <p>&nbsp;</p>
 <p><strong>Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> num = 11891
 <strong>Output:</strong> 99009
 <strong>Explanation:</strong> 
 To achieve the maximum value, Danny can remap the digit 1 to the digit 9 to yield 99899.
 To achieve the minimum value, Danny can remap the digit 1 to the digit 0, yielding 890.
 The difference between these two numbers is 99009.
 </pre>
 <p><strong>Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> num = 90
 <strong>Output:</strong> 99
 <strong>Explanation:</strong>
 The maximum value that can be returned by the function is 99 (if 0 is replaced by 9) and the minimum value that can be returned by the function is 0 (if 9 is replaced by 0).
 Thus, we return 99.</pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= num &lt;= 10<sup>8</sup></code></li>
 </ul>
--- a/leetcode/problem/merge-two-2d-arrays-by-summing-values.html
+++ b/leetcode/problem/merge-two-2d-arrays-by-summing-values.html
@ -0,0 +1,49 @@
 <p>You are given two <strong>2D</strong> integer arrays <code>nums1</code> and <code>nums2.</code></p>
 <ul>
 	<li><code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
 	<li><code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
 </ul>
 <p>Each array contains <strong>unique</strong> ids and is sorted in <strong>ascending</strong> order by id.</p>
 <p>Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:</p>
 <ul>
 	<li>Only ids that appear in at least one of the two arrays should be included in the resulting array.</li>
 	<li>Each id should be included <strong>only once</strong> and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays then its value in that array is considered to be <code>0</code>.</li>
 </ul>
 <p>Return <em>the resulting array</em>. The returned array must be sorted in ascending order by id.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
 <strong>Output:</strong> [[1,6],[2,3],[3,2],[4,6]]
 <strong>Explanation:</strong> The resulting array contains the following:
 - id = 1, the value of this id is 2 + 4 = 6.
 - id = 2, the value of this id is 3.
 - id = 3, the value of this id is 2.
 - id = 4, the value of this id is 5 + 1 = 6.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
 <strong>Output:</strong> [[1,3],[2,4],[3,6],[4,3],[5,5]]
 <strong>Explanation:</strong> There are no common ids, so we just include each id with its value in the resulting list.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 200</code></li>
 	<li><code>nums1[i].length == nums2[j].length == 2</code></li>
 	<li><code>1 &lt;= id<sub>i</sub>, val<sub>i</sub> &lt;= 1000</code></li>
 	<li>Both arrays contain unique ids.</li>
 	<li>Both arrays are in&nbsp;strictly ascending order by id.</li>
 </ul>
--- a/leetcode/problem/minimum-impossible-or.html
+++ b/leetcode/problem/minimum-impossible-or.html
@ -0,0 +1,30 @@
 <p>You are given a <strong>0-indexed</strong>&nbsp;integer array <code>nums</code>.</p>
 <p>We say that an integer x is <strong>expressible</strong> from <code>nums</code> if there exist some integers <code>0 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt; ... &lt; index<sub>k</sub> &lt; nums.length</code> for which <code>nums[index<sub>1</sub>] | nums[index<sub>2</sub>] | ... | nums[index<sub>k</sub>] = x</code>. In other words, an integer is expressible if it can be written as the bitwise OR of some subsequence of <code>nums</code>.</p>
 <p>Return <em>the minimum <strong>positive non-zero integer</strong>&nbsp;that is not </em><em>expressible from </em><code>nums</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [2,1]
 <strong>Output:</strong> 4
 <strong>Explanation:</strong> 1 and 2 are already present in the array. We know that 3 is expressible, since nums[0] | nums[1] = 2 | 1 = 3. Since 4 is not expressible, we return 4.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [5,3,2]
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> We can show that 1 is the smallest number that is not expressible.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/leetcode/problem/minimum-operations-to-reduce-an-integer-to-0.html
+++ b/leetcode/problem/minimum-operations-to-reduce-an-integer-to-0.html
@ -0,0 +1,41 @@
 <p>You are given a positive integer <code>n</code>, you can do the following operation <strong>any</strong> number of times:</p>
 <ul>
 	<li>Add or subtract a <strong>power</strong> of <code>2</code> from <code>n</code>.</li>
 </ul>
 <p>Return <em>the <strong>minimum</strong> number of operations to make </em><code>n</code><em> equal to </em><code>0</code>.</p>
 <p>A number <code>x</code> is power of <code>2</code> if <code>x == 2<sup>i</sup></code>&nbsp;where <code>i &gt;= 0</code><em>.</em></p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> n = 39
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> We can do the following operations:
 - Add 2<sup>0</sup> = 1 to n, so now n = 40.
 - Subtract 2<sup>3</sup> = 8 from n, so now n = 32.
 - Subtract 2<sup>5</sup> = 32 from n, so now n = 0.
 It can be shown that 3 is the minimum number of operations we need to make n equal to 0.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> n = 54
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> We can do the following operations:
 - Add 2<sup>1</sup> = 2 to n, so now n = 56.
 - Add 2<sup>3</sup> = 8 to n, so now n = 64.
 - Subtract 2<sup>6</sup> = 64 from n, so now n = 0.
 So the minimum number of operations is 3.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
 </ul>
--- a/leetcode/problem/minimum-score-by-changing-two-elements.html
+++ b/leetcode/problem/minimum-score-by-changing-two-elements.html
@ -0,0 +1,41 @@
 <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
 <ul>
 	<li>The <strong>low</strong> score of <code><font face="monospace">nums</font></code> is the minimum value of <code>|nums[i]&nbsp;- nums[j]|</code> over all <code>0 &lt;= i &lt; j &lt; nums.length</code>.</li>
 	<li>The <strong>high</strong> score of&nbsp;<code><font face="monospace">nums</font></code> is the maximum value of <code>|nums[i]&nbsp;- nums[j]|</code> over all <code>0 &lt;= i &lt; j &lt; nums.length</code>.</li>
 	<li>The <strong>score</strong> of <code>nums</code> is the sum of the <strong>high</strong> and <strong>low</strong> scores of nums.</li>
 </ul>
 <p>To minimize the score of <code>nums</code>, we can change the value of <strong>at most two</strong> elements of <code>nums</code>.</p>
 <p>Return <em>the <strong>minimum</strong> possible <strong>score</strong> after changing&nbsp;the value of <strong>at most two</strong> elements o</em>f <code>nums</code>.</p>
 <p>Note that <code>|x|</code> denotes the absolute value of <code>x</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,4,3]
 <strong>Output:</strong> 0
 <strong>Explanation:</strong> Change value of nums[1] and nums[2] to 1 so that nums becomes [1,1,1]. Now, the value of <code>|nums[i] - nums[j]|</code> is always equal to 0, so we return 0 + 0 = 0.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> nums = [1,4,7,8,5]
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> Change nums[0] and nums[1] to be 6. Now nums becomes [6,6,7,8,5].
 Our low score is achieved when i = 0 and j = 1, in which case |<code>nums[i] - nums[j]</code>| = |6 - 6| = 0.
 Our high score is achieved when i = 3 and j = 4, in which case |<code>nums[i] - nums[j]</code>| = |8 - 5| = 3.
 The sum of our high and low score is 3, which we can prove to be minimal.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>3 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
--- a/leetcode/problem/minimum-time-to-visit-a-cell-in-a-grid.html
+++ b/leetcode/problem/minimum-time-to-visit-a-cell-in-a-grid.html
@ -0,0 +1,56 @@
 <p>You are given a <code>m x n</code> matrix <code>grid</code> consisting of <b>non-negative</b> integers where <code>grid[row][col]</code> represents the <strong>minimum</strong> time required to be able to visit the cell <code>(row, col)</code>, which means you can visit the cell <code>(row, col)</code> only when the time you visit it is greater than or equal to <code>grid[row][col]</code>.</p>
 <p>You are standing in the <strong>top-left</strong> cell of the matrix in the <code>0<sup>th</sup></code> second, and you must move to <strong>any</strong> adjacent cell in the four directions: up, down, left, and right. Each move you make takes 1 second.</p>
 <p>Return <em>the <strong>minimum</strong> time required in which you can visit the bottom-right cell of the matrix</em>. If you cannot visit the bottom-right cell, then return <code>-1</code>.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png" /></p>
 <pre>
 <strong>Input:</strong> grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
 <strong>Output:</strong> 7
 <strong>Explanation:</strong> One of the paths that we can take is the following:
 - at t = 0, we are on the cell (0,0).
 - at t = 1, we move to the cell (0,1). It is possible because grid[0][1] &lt;= 1.
 - at t = 2, we move to the cell (1,1). It is possible because grid[1][1] &lt;= 2.
 - at t = 3, we move to the cell (1,2). It is possible because grid[1][2] &lt;= 3.
 - at t = 4, we move to the cell (1,1). It is possible because grid[1][1] &lt;= 4.
 - at t = 5, we move to the cell (1,2). It is possible because grid[1][2] &lt;= 5.
 - at t = 6, we move to the cell (1,3). It is possible because grid[1][3] &lt;= 6.
 - at t = 7, we move to the cell (2,3). It is possible because grid[1][3] &lt;= 7.
 The final time is 7. It can be shown that it is the minimum time possible.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png" style="width: 151px; height: 151px;" /></p>
 <pre>
 <strong>Input:</strong> grid = [[0,2,4],[3,2,1],[1,0,4]]
 <strong>Output:</strong> -1
 <strong>Explanation:</strong> There is no path from the top left to the bottom-right cell.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>m == grid.length</code></li>
 	<li><code>n == grid[i].length</code></li>
 	<li><code>2 &lt;= m, n &lt;= 1000</code></li>
 	<li><code>4 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
 	<li><code>grid[0][0] == 0</code></li>
 </ul>
 <p>&nbsp;</p>
 <style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
 }
 .spoiler {overflow:hidden;}
 .spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
 .spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
 .spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
 </style>
--- a/leetcode/problem/subsequence-with-the-minimum-score.html
+++ b/leetcode/problem/subsequence-with-the-minimum-score.html
@ -0,0 +1,45 @@
 <p>You are given two strings <code>s</code> and <code>t</code>.</p>
 <p>You are allowed to remove any number of characters from the string <code>t</code>.</p>
 <p>The score of the string is <code>0</code> if no characters are removed from the string <code>t</code>, otherwise:</p>
 <ul>
 	<li>Let <code>left</code> be the minimum index among all removed characters.</li>
 	<li>Let <code>right</code> be the maximum index among all removed characters.</li>
 </ul>
 <p>Then the score of the string is <code>right - left + 1</code>.</p>
 <p>Return <em>the minimum possible score to make </em><code>t</code><em>&nbsp;a subsequence of </em><code>s</code><em>.</em></p>
 <p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>&quot;ace&quot;</code> is a subsequence of <code>&quot;<u>a</u>b<u>c</u>d<u>e</u>&quot;</code> while <code>&quot;aec&quot;</code> is not).</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;abacaba&quot;, t = &quot;bzaa&quot;
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> In this example, we remove the character &quot;z&quot; at index 1 (0-indexed).
 The string t becomes &quot;baa&quot; which is a subsequence of the string &quot;abacaba&quot; and the score is 1 - 1 + 1 = 1.
 It can be proven that 1 is the minimum score that we can achieve.
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;cde&quot;, t = &quot;xyz&quot;
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> In this example, we remove characters &quot;x&quot;, &quot;y&quot; and &quot;z&quot; at indices 0, 1, and 2 (0-indexed).
 The string t becomes &quot;&quot; which is a subsequence of the string &quot;cde&quot; and the score is 2 - 0 + 1 = 3.
 It can be proven that 3 is the minimum score that we can achieve.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>s</code> and <code>t</code> consist of only lowercase English letters.</li>
 </ul>
--- a/leetcode/problem/substring-xor-queries.html
+++ b/leetcode/problem/substring-xor-queries.html
@ -0,0 +1,45 @@
 <p>You are given a <strong>binary string</strong> <code>s</code>, and a <strong>2D</strong> integer array <code>queries</code> where <code>queries[i] = [first<sub>i</sub>, second<sub>i</sub>]</code>.</p>
 <p>For the <code>i<sup>th</sup></code> query, find the <strong>shortest substring</strong> of <code>s</code> whose <strong>decimal value</strong>, <code>val</code>, yields <code>second<sub>i</sub></code> when <strong>bitwise XORed</strong> with <code>first<sub>i</sub></code>. In other words, <code>val ^ first<sub>i</sub> == second<sub>i</sub></code>.</p>
 <p>The answer to the <code>i<sup>th</sup></code> query is the endpoints (<strong>0-indexed</strong>) of the substring <code>[left<sub>i</sub>, right<sub>i</sub>]</code> or <code>[-1, -1]</code> if no such substring exists. If there are multiple answers, choose the one with the <strong>minimum</strong> <code>left<sub>i</sub></code>.</p>
 <p><em>Return an array</em> <code>ans</code> <em>where</em> <code>ans[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> <em>is the answer to the</em> <code>i<sup>th</sup></code> <em>query.</em></p>
 <p>A <strong>substring</strong> is a contiguous non-empty sequence of characters within a string.</p>
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;101101&quot;, queries = [[0,5],[1,2]]
 <strong>Output:</strong> [[0,2],[2,3]]
 <strong>Explanation:</strong> For the first query the substring in range <code>[0,2]</code> is <strong>&quot;101&quot;</strong> which has a decimal value of <strong><code>5</code></strong>, and <strong><code>5 ^ 0 = 5</code></strong>, hence the answer to the first query is <code>[0,2]</code>. In the second query, the substring in range <code>[2,3]</code> is <strong>&quot;11&quot;,</strong> and has a decimal value of <strong>3</strong>, and <strong>3<code> ^ 1 = 2</code></strong>.&nbsp;So, <code>[2,3]</code> is returned for the second query. 
 </pre>
 <p><strong class="example">Example 2:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;0101&quot;, queries = [[12,8]]
 <strong>Output:</strong> [[-1,-1]]
 <strong>Explanation:</strong> In this example there is no substring that answers the query, hence <code>[-1,-1] is returned</code>.
 </pre>
 <p><strong class="example">Example 3:</strong></p>
 <pre>
 <strong>Input:</strong> s = &quot;1&quot;, queries = [[4,5]]
 <strong>Output:</strong> [[0,0]]
 <strong>Explanation:</strong> For this example, the substring in range <code>[0,0]</code> has a decimal value of <strong><code>1</code></strong>, and <strong><code>1 ^ 4 = 5</code></strong>. So, the answer is <code>[0,0]</code>.
 </pre>
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 <ul>
 	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
 	<li><code>s[i]</code> is either <code>&#39;0&#39;</code> or <code>&#39;1&#39;</code>.</li>
 	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
 	<li><code>0 &lt;= first<sub>i</sub>, second<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
 </ul>