From 8a4f5cbc94954f100f407d7083693ea8ecc85d6c Mon Sep 17 00:00:00 2001
From: Yang Libin <contact@yanglibin.info>
Date: Thu, 24 Aug 2023 03:32:18 +0000
Subject: [PATCH] feat: add new lc problems

---
 .../0100-0199/0137.Single Number II/README.md |   2 +-
 solution/0100-0199/0139.Word Break/README.md  |   2 +-
 .../0175.Combine Two Tables/README.md         |  10 +-
 .../README.md                                 |   6 +-
 .../0100-0199/0182.Duplicate Emails/README.md |   6 +-
 .../0400-0499/0401.Binary Watch/README_EN.md  |   2 +-
 solution/0500-0599/0529.Minesweeper/README.md |   4 +-
 .../0534.Game Play Analysis III/README.md     |  19 +-
 .../0550.Game Play Analysis IV/README.md      |  21 +-
 .../README.md                                 |   8 +-
 .../0500-0599/0582.Kill Process/README.md     |  14 +-
 .../0620.Not Boring Movies/README.md          |  39 ++-
 solution/0600-0699/0627.Swap Salary/README.md |   6 +-
 .../README_EN.md                              |   2 +-
 .../0800-0899/0899.Orderly Queue/README_EN.md |   2 +-
 .../README.md                                 |  10 +-
 .../1068.Product Sales Analysis I/README.md   |  25 +-
 .../1069.Product Sales Analysis II/README.md  |  30 ++-
 .../1070.Product Sales Analysis III/README.md |   2 +-
 .../1077.Project Employees III/README.md      |  24 +-
 .../1084.Sales Analysis III/README.md         |  14 +-
 .../1000-1099/1098.Unpopular Books/README.md  |  44 ++--
 .../1107.New Users Daily Count/README.md      |  28 +-
 .../README.md                                 |   6 +-
 .../1100-1199/1113.Reported Posts/README.md   |  29 ++-
 .../1126.Active Businesses/README.md          |  28 +-
 .../1132.Reported Posts II/README.md          |  10 +-
 .../README.md                                 |  14 +-
 .../README.md                                 |   4 +-
 .../1100-1199/1149.Article Views II/README.md |   6 +-
 .../1158.Market Analysis I/README.md          |  17 +-
 .../README.md                                 |  10 +-
 .../README_EN.md                              |   2 +-
 .../README.md                                 |   2 +-
 .../README.md                                 | 173 +++++++++++-
 .../README_EN.md                              | 167 +++++++++++-
 .../Solution.cpp                              |  32 +++
 .../Solution.go                               |  28 ++
 .../Solution.java                             |  30 +++
 .../Solution.py                               |  33 +++
 .../Solution.ts                               |  29 +++
 .../README_EN.md                              |   2 +-
 .../1400-1499/1454.Active Users/README.md     |  29 ++-
 .../README.md                                 |   2 +-
 .../README.md                                 |  23 +-
 .../README.md                                 |  22 +-
 .../README_EN.md                              |   8 +-
 .../1729.Find Followers Count/README.md       |   4 +-
 .../1782.Count Pairs Of Nodes/README.md       |  26 +-
 .../README.md                                 |   8 +-
 .../README.md                                 |   6 +-
 .../README.md                                 |  11 +-
 .../README_EN.md                              |   4 +-
 .../2394.Employees With Deductions/README.md  |  10 +-
 .../README_EN.md                              |   8 +-
 .../README.md                                 |   4 +-
 .../README.md                                 |  10 +-
 .../README_EN.md                              |   6 +-
 .../2688.Find Active Users/README.md          |  14 +-
 .../2688.Find Active Users/README_EN.md       |   8 +-
 .../README.md                                 |  19 +-
 .../README_EN.md                              |  20 +-
 .../2738.Count Occurrences in Text/README.md  |   8 +-
 .../2748.Number of Beautiful Pairs/README.md  |  10 +-
 .../README.md                                 |   6 +-
 .../README_EN.md                              |   8 +-
 .../README.md                                 |   8 +-
 .../README_EN.md                              |   2 +-
 .../README.md                                 |  10 +-
 .../2793.Status of Flight Tickets/README.md   |   6 +-
 .../README_EN.md                              |  10 +-
 .../README.md                                 | 246 ++++++++++++++++++
 .../README_EN.md                              | 232 +++++++++++++++++
 .../Solution.cpp                              |  33 +++
 .../Solution.go                               |  35 +++
 .../Solution.java                             |  34 +++
 .../Solution.py                               |  20 ++
 .../Solution.ts                               |  26 ++
 solution/CONTEST_README.md                    |   2 +-
 solution/README.md                            |  19 +-
 solution/README_EN.md                         |  19 +-
 solution/config.py                            |   2 +-
 solution/summary.md                           |   1 +
 solution/summary_en.md                        |   1 +
 84 files changed, 1571 insertions(+), 351 deletions(-)
 create mode 100644 solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.cpp
 create mode 100644 solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.go
 create mode 100644 solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.java
 create mode 100644 solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.py
 create mode 100644 solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.ts
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README.md
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README_EN.md
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.cpp
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.go
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.java
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.py
 create mode 100644 solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.ts

diff --git a/solution/0100-0199/0137.Single Number II/README.md b/solution/0100-0199/0137.Single Number II/README.md
index 15c7f2917c9f8..f311a032edcb3 100644
--- a/solution/0100-0199/0137.Single Number II/README.md	
+++ b/solution/0100-0199/0137.Single Number II/README.md	
@@ -8,7 +8,7 @@
 
 <p>给你一个整数数组&nbsp;<code>nums</code> ，除某个元素仅出现 <strong>一次</strong> 外，其余每个元素都恰出现 <strong>三次 。</strong>请你找出并返回那个只出现了一次的元素。</p>
 
-<p>你必须设计并实现线性时间复杂度的算法且不使用额外空间来解决此问题。</p>
+<p>你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0100-0199/0139.Word Break/README.md b/solution/0100-0199/0139.Word Break/README.md
index 718c3b8142d25..94435beccd0b7 100644
--- a/solution/0100-0199/0139.Word Break/README.md	
+++ b/solution/0100-0199/0139.Word Break/README.md	
@@ -44,7 +44,7 @@
 	<li><code>1 &lt;= s.length &lt;= 300</code></li>
 	<li><code>1 &lt;= wordDict.length &lt;= 1000</code></li>
 	<li><code>1 &lt;= wordDict[i].length &lt;= 20</code></li>
-	<li><code>s</code> 和 <code>wordDict[i]</code> 仅有小写英文字母组成</li>
+	<li><code>s</code> 和 <code>wordDict[i]</code> 仅由小写英文字母组成</li>
 	<li><code>wordDict</code> 中的所有字符串 <strong>互不相同</strong></li>
 </ul>
 
diff --git a/solution/0100-0199/0175.Combine Two Tables/README.md b/solution/0100-0199/0175.Combine Two Tables/README.md
index 1b22ecd086223..a7687edaed4b0 100644
--- a/solution/0100-0199/0175.Combine Two Tables/README.md	
+++ b/solution/0100-0199/0175.Combine Two Tables/README.md	
@@ -16,7 +16,7 @@
 | FirstName   | varchar |
 | LastName    | varchar |
 +-------------+---------+
-personId 是该表的主键列。
+personId 是该表的主键（具有唯一值的列）。
 该表包含一些人的 ID 和他们的姓和名的信息。
 </pre>
 
@@ -33,15 +33,17 @@ personId 是该表的主键列。
 | City        | varchar |
 | State       | varchar |
 +-------------+---------+
-addressId 是该表的主键列。
+addressId 是该表的主键（具有唯一值的列）。
 该表的每一行都包含一个 ID = PersonId 的人的城市和州的信息。
 </pre>
 
-<p>编写一个SQL查询来报告 <code>Person</code> 表中每个人的姓、名、城市和州。如果 <code>personId</code> 的地址不在&nbsp;<code>Address</code>&nbsp;表中，则报告为空 &nbsp;<code>null</code>&nbsp;。</p>
+<p>&nbsp;</p>
+
+<p>编写解决方案，报告 <code>Person</code> 表中每个人的姓、名、城市和州。如果 <code>personId</code> 的地址不在&nbsp;<code>Address</code>&nbsp;表中，则报告为&nbsp;<code>null</code>&nbsp;。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0100-0199/0181.Employees Earning More Than Their Managers/README.md b/solution/0100-0199/0181.Employees Earning More Than Their Managers/README.md
index bb1b0613bb5dc..d17397fb31abb 100644
--- a/solution/0100-0199/0181.Employees Earning More Than Their Managers/README.md	
+++ b/solution/0100-0199/0181.Employees Earning More Than Their Managers/README.md	
@@ -17,17 +17,17 @@
 | salary      | int     |
 | managerId   | int     |
 +-------------+---------+
-Id是该表的主键。
+id 是该表的主键（具有唯一值的列）。
 该表的每一行都表示雇员的ID、姓名、工资和经理的ID。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个SQL查询来查找收入比经理高的员工。</p>
+<p>编写解决方案，找出收入比经理高的员工。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0100-0199/0182.Duplicate Emails/README.md b/solution/0100-0199/0182.Duplicate Emails/README.md
index 254236020bb7f..5a95c4292d88f 100644
--- a/solution/0100-0199/0182.Duplicate Emails/README.md	
+++ b/solution/0100-0199/0182.Duplicate Emails/README.md	
@@ -17,17 +17,17 @@
 | id          | int     |
 | email       | varchar |
 +-------------+---------+
-id 是该表的主键列。
+id 是该表的主键（具有唯一值的列）。
 此表的每一行都包含一封电子邮件。电子邮件不包含大写字母。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询来报告所有重复的电子邮件。 请注意，可以保证电子邮件字段不为 NULL。</p>
+<p>编写解决方案来报告所有重复的电子邮件。 请注意，可以保证电子邮件字段不为 NULL。</p>
 
 <p>以&nbsp;<strong>任意顺序&nbsp;</strong>返回结果表。</p>
 
-<p>查询结果格式如下例。</p>
+<p>结果格式如下例。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0400-0499/0401.Binary Watch/README_EN.md b/solution/0400-0499/0401.Binary Watch/README_EN.md
index 677441a6d2f85..61e9f928170ad 100644
--- a/solution/0400-0499/0401.Binary Watch/README_EN.md	
+++ b/solution/0400-0499/0401.Binary Watch/README_EN.md	
@@ -20,7 +20,7 @@
 	<li>For example, <code>&quot;01:00&quot;</code> is not valid. It should be <code>&quot;1:00&quot;</code>.</li>
 </ul>
 
-<p>The minute must be consist of two digits and may contain a leading zero.</p>
+<p>The minute must&nbsp;consist of two digits and may contain a leading zero.</p>
 
 <ul>
 	<li>For example, <code>&quot;10:2&quot;</code> is not valid. It should be <code>&quot;10:02&quot;</code>.</li>
diff --git a/solution/0500-0599/0529.Minesweeper/README.md b/solution/0500-0599/0529.Minesweeper/README.md
index 38f5c90ca3455..16d01d4cc0a63 100644
--- a/solution/0500-0599/0529.Minesweeper/README.md
+++ b/solution/0500-0599/0529.Minesweeper/README.md
@@ -32,14 +32,14 @@
 <p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
-<img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0500-0599/0529.Minesweeper/images/minesweeper_example_1.png" style="width: 500px; max-width: 400px; height: 269px;" />
+<img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0500-0599/0529.Minesweeper/images/untitled.jpeg" style="width: 500px; max-width: 400px; height: 269px;" />
 <pre>
 <strong>输入：</strong>board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0]
 <strong>输出：</strong>[["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
 </pre>
 
 <p><strong>示例 2：</strong></p>
-<img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0500-0599/0529.Minesweeper/images/minesweeper_example_2.png" style="width: 500px; max-width: 400px; height: 275px;" />
+<img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0500-0599/0529.Minesweeper/images/untitled-2.jpeg" style="width: 500px; max-width: 400px; height: 275px;" />
 <pre>
 <strong>输入：</strong>board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2]
 <strong>输出：</strong>[["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
diff --git a/solution/0500-0599/0534.Game Play Analysis III/README.md b/solution/0500-0599/0534.Game Play Analysis III/README.md
index 576428e36b6e0..b4ab54396d679 100644
--- a/solution/0500-0599/0534.Game Play Analysis III/README.md	
+++ b/solution/0500-0599/0534.Game Play Analysis III/README.md	
@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>Table:&nbsp;<code>Activity</code></p>
+<p>表：<code>Activity</code></p>
 
 <pre>
 +--------------+---------+
@@ -17,18 +17,25 @@
 | event_date   | date    |
 | games_played | int     |
 +--------------+---------+
-（player_id，event_date）是此表的主键。
+（player_id，event_date）是此表的主键（具有唯一值的列）。
 这张表显示了某些游戏的玩家的活动情况。
 每一行是一个玩家的记录，他在某一天使用某个设备注销之前登录并玩了很多游戏（可能是 0 ）。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，同时报告每组玩家和日期，以及玩家到目前为止玩了多少游戏。也就是说，在此日期之前玩家所玩的游戏总数。详细情况请查看示例。</p>
+<p>编写一个解决方案，同时报告每组玩家和日期，以及玩家到 <strong>目前为止</strong> 玩了多少游戏。也就是说，玩家在该日期之前所玩的游戏总数。详细情况请查看示例。</p>
 
-<p>查询结果格式如下所示：</p>
+<p>以 <strong>任意顺序</strong> 返回结果表。</p>
+
+<p>结果格式如下所示。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
 <pre>
+<strong>输入：</strong>
 Activity table:
 +-----------+-----------+------------+--------------+
 | player_id | device_id | event_date | games_played |
@@ -39,8 +46,7 @@ Activity table:
 | 3         | 1         | 2016-03-02 | 0            |
 | 3         | 4         | 2018-07-03 | 5            |
 +-----------+-----------+------------+--------------+
-
-Result table:
+<strong>输出：</strong>
 +-----------+------------+---------------------+
 | player_id | event_date | games_played_so_far |
 +-----------+------------+---------------------+
@@ -50,6 +56,7 @@ Result table:
 | 3         | 2016-03-02 | 0                   |
 | 3         | 2018-07-03 | 5                   |
 +-----------+------------+---------------------+
+<strong>解释：</strong>
 对于 ID 为 1 的玩家，2016-05-02 共玩了 5+6=11 个游戏，2017-06-25 共玩了 5+6+1=12 个游戏。
 对于 ID 为 3 的玩家，2018-07-03 共玩了 0+5=5 个游戏。
 请注意，对于每个玩家，我们只关心玩家的登录日期。
diff --git a/solution/0500-0599/0550.Game Play Analysis IV/README.md b/solution/0500-0599/0550.Game Play Analysis IV/README.md
index 256c6f618a325..31e03832a8efb 100644
--- a/solution/0500-0599/0550.Game Play Analysis IV/README.md	
+++ b/solution/0500-0599/0550.Game Play Analysis IV/README.md	
@@ -8,7 +8,8 @@
 
 <p>Table:&nbsp;<code>Activity</code></p>
 
-<pre>+--------------+---------+
+<pre>
++--------------+---------+
 | Column Name  | Type    |
 +--------------+---------+
 | player_id    | int     |
@@ -16,18 +17,24 @@
 | event_date   | date    |
 | games_played | int     |
 +--------------+---------+
-（player_id，event_date）是此表的主键。
+（player_id，event_date）是此表的主键（具有唯一值的列的组合）。
 这张表显示了某些游戏的玩家的活动情况。
 每一行是一个玩家的记录，他在某一天使用某个设备注销之前登录并玩了很多游戏（可能是 0）。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，报告在首次登录的第二天再次登录的玩家的比率，四舍五入到小数点后两位。换句话说，您需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。</p>
+<p>编写解决方案，报告在首次登录的第二天再次登录的玩家的 <strong>比率</strong>，<strong>四舍五入到小数点后两位</strong>。换句话说，你需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。</p>
+
+<p>结果格式如下所示：</p>
 
-<p>查询结果格式如下所示：</p>
+<p>&nbsp;</p>
 
-<pre>Activity table:
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>
+Activity table:
 +-----------+-----------+------------+--------------+
 | player_id | device_id | event_date | games_played |
 +-----------+-----------+------------+--------------+
@@ -37,13 +44,13 @@
 | 3         | 1         | 2016-03-02 | 0            |
 | 3         | 4         | 2018-07-03 | 5            |
 +-----------+-----------+------------+--------------+
-
-Result table:
+<strong>输出：</strong>
 +-----------+
 | fraction  |
 +-----------+
 | 0.33      |
 +-----------+
+<strong>解释：</strong>
 只有 ID 为 1 的玩家在第一天登录后才重新登录，所以答案是 1/3 = 0.33
 </pre>
 
diff --git a/solution/0500-0599/0580.Count Student Number in Departments/README.md b/solution/0500-0599/0580.Count Student Number in Departments/README.md
index 711c46cc60665..c5446960cf1dd 100644
--- a/solution/0500-0599/0580.Count Student Number in Departments/README.md	
+++ b/solution/0500-0599/0580.Count Student Number in Departments/README.md	
@@ -17,7 +17,7 @@
 | gender       | varchar |
 | dept_id      | int     |
 +--------------+---------+
-Student_id是该表的主键。
+student_id 是该表的主键（具有唯一值的列）。
 dept_id是Department表中dept_id的外键。
 该表的每一行都表示学生的姓名、性别和所属系的id。
 </pre>
@@ -33,16 +33,16 @@ dept_id是Department表中dept_id的外键。
 | dept_id     | int     |
 | dept_name   | varchar |
 +-------------+---------+
-Dept_id是该表的主键。
+dept_id是该表的主键（具有唯一值的列）。
 该表的每一行包含一个部门的id和名称。</pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个SQL查询，为&nbsp;<code>Department</code>&nbsp;表中的所有部门(甚至是没有当前学生的部门)报告各自的部门名称和每个部门的学生人数。</p>
+<p>编写解决方案，为&nbsp;<code>Department</code>&nbsp;表中的所有部门(甚至是没有当前学生的部门)报告各自的部门名称和每个部门的学生人数。</p>
 
 <p>按 <code>student_number</code> <strong>降序&nbsp;</strong>返回结果表。如果是平局，则按 <code>dept_name</code> 的&nbsp; <strong>字母顺序&nbsp;</strong>排序。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0500-0599/0582.Kill Process/README.md b/solution/0500-0599/0582.Kill Process/README.md
index 63f0ee3bed9e9..f02fcfef1f247 100644
--- a/solution/0500-0599/0582.Kill Process/README.md	
+++ b/solution/0500-0599/0582.Kill Process/README.md	
@@ -6,14 +6,14 @@
 
 <!-- 这里写题目描述 -->
 
-<p>系统中存在 <code>n</code> 个进程，形成一个有根树结构。给你两个整数数组 <code>pid</code> 和 <code>ppid</code> ，其中 <code>pid[i]</code> 是第 <code>i</code> 个进程的 ID ，<code>ppid[i]</code> 是第 <code>i</code> 个进程的父进程 ID 。</p>
+<p>系统中存在 <code>n</code>&nbsp;个进程，形成一个有根树结构。给你两个整数数组&nbsp;<code>pid</code> 和 <code>ppid</code> ，其中 <code>pid[i]</code> 是第 <code>i</code> 个进程的 ID ，<code>ppid[i]</code> 是第 <code>i</code> 个进程的父进程 ID 。</p>
 
 <p>每一个进程只有 <strong>一个父进程</strong> ，但是可能会有 <strong>一个或者多个子进程</strong> 。只有一个进程的 <code>ppid[i] = 0</code> ，意味着这个进程 <strong>没有父进程</strong> 。</p>
 
 <p>当一个进程 <strong>被杀掉</strong> 的时候，它所有的子进程和后代进程都要被杀掉。</p>
 
-<p>给你一个整数 <code>kill</code> 表示要杀掉​​进程的 ID ，返回杀掉该进程后的所有进程 ID 的列表。可以按 <strong>任意顺序</strong> 返回答案。</p>
- 
+<p>给你一个整数 <code>kill</code> 表示要杀掉​​进程的 ID ，返回被杀掉的进程的 ID 列表。可以按 <strong>任意顺序</strong> 返回答案。</p>
+&nbsp;
 
 <p><strong>示例 1：</strong></p>
 <img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0500-0599/0582.Kill%20Process/images/ptree.jpg" style="width: 207px; height: 302px;" />
@@ -30,16 +30,16 @@
 <strong>输出：</strong>[1]
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
 	<li><code>n == pid.length</code></li>
 	<li><code>n == ppid.length</code></li>
-	<li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
-	<li><code>1 <= pid[i] <= 5 * 10<sup>4</sup></code></li>
-	<li><code>0 <= ppid[i] <= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= pid[i] &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= ppid[i] &lt;= 5 * 10<sup>4</sup></code></li>
 	<li>仅有一个进程没有父进程</li>
 	<li><code>pid</code> 中的所有值 <strong>互不相同</strong></li>
 	<li>题目数据保证 <code>kill</code> 在 <code>pid</code> 中</li>
diff --git a/solution/0600-0699/0620.Not Boring Movies/README.md b/solution/0600-0699/0620.Not Boring Movies/README.md
index f6994c36636c1..24c52ec2f6293 100644
--- a/solution/0600-0699/0620.Not Boring Movies/README.md	
+++ b/solution/0600-0699/0620.Not Boring Movies/README.md	
@@ -6,15 +6,36 @@
 
 <!-- 这里写题目描述 -->
 
-<p>某城市开了一家新的电影院，吸引了很多人过来看电影。该电影院特别注意用户体验，专门有个 LED显示板做电影推荐，上面公布着影评和相关电影描述。</p>
+<p>表：<code>cinema</code></p>
 
-<p>作为该电影院的信息部主管，您需要编写一个 SQL查询，找出所有影片描述为<strong>非</strong>&nbsp;<code>boring</code>&nbsp;(不无聊)&nbsp;的并且<strong> id 为奇数&nbsp;</strong>的影片，结果请按等级 <code>rating</code> 排列。</p>
+<pre>
++----------------+----------+
+| Column Name    | Type     |
++----------------+----------+
+| id             | int      |
+| movie          | varchar  |
+| description    | varchar  |
+| rating         | float    |
++----------------+----------+
+id 是该表的主键(具有唯一值的列)。
+每行包含有关电影名称、类型和评级的信息。
+评级为 [0,10] 范围内的小数点后 2 位浮点数。
+</pre>
+
+<p>&nbsp;</p>
+
+<p>编写解决方案，找出所有影片描述为&nbsp;<strong>非</strong>&nbsp;<code>boring</code>&nbsp;(不无聊)&nbsp;的并且<strong> id 为奇数&nbsp;</strong>的影片。</p>
+
+<p>返回结果按&nbsp;<code>rating</code>&nbsp;<strong>降序排列</strong>。</p>
+
+<p>结果格式如下示例。</p>
 
 <p>&nbsp;</p>
 
-<p>例如，下表 <code>cinema</code>:</p>
+<p><strong>示例 1：</strong></p>
 
 <pre>
+<strong>输入：</strong>
 +---------+-----------+--------------+-----------+
 |   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
@@ -23,22 +44,18 @@
 |   3     | irish     |   boring     |   6.2     |
 |   4     | Ice song  |   Fantacy    |   8.6     |
 |   5     | House card|   Interesting|   9.1     |
-+---------+-----------+--------------+-----------+
-</pre>
-
-<p>对于上面的例子，则正确的输出是为：</p>
-
-<pre>
+<strong>+---------+-----------+--------------+-----------+
+输出：</strong>
 +---------+-----------+--------------+-----------+
 |   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
 |   5     | House card|   Interesting|   9.1     |
 |   1     | War       |   great 3D   |   8.9     |
 +---------+-----------+--------------+-----------+
+<strong>解释：</strong>
+我们有三部电影，它们的 id 是奇数:1、3 和 5。id = 3 的电影是 boring 的，所以我们不把它包括在答案中。
 </pre>
 
-<p>&nbsp;</p>
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
diff --git a/solution/0600-0699/0627.Swap Salary/README.md b/solution/0600-0699/0627.Swap Salary/README.md
index 09845cd9b15f8..36dc0d44a84e1 100644
--- a/solution/0600-0699/0627.Swap Salary/README.md	
+++ b/solution/0600-0699/0627.Swap Salary/README.md	
@@ -19,18 +19,18 @@
 | sex         | ENUM     |
 | salary      | int      |
 +-------------+----------+
-id 是这个表的主键。
+id 是这个表的主键（具有唯一值的列）。
 sex 这一列的值是 ENUM 类型，只能从 ('m', 'f') 中取。
 本表包含公司雇员的信息。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>请你编写一个 SQL 查询来交换所有的 <code>'f'</code> 和 <code>'m'</code> （即，将所有 <code>'f'</code> 变为 <code>'m'</code> ，反之亦然），仅使用 <strong>单个 update 语句</strong> ，且不产生中间临时表。</p>
+<p>请你编写一个解决方案来交换所有的 <code>'f'</code> 和 <code>'m'</code> （即，将所有 <code>'f'</code> 变为 <code>'m'</code> ，反之亦然），仅使用 <strong>单个 update 语句</strong> ，且不产生中间临时表。</p>
 
 <p>注意，你必须仅使用一条 update 语句，且 <strong>不能</strong> 使用 select 语句。</p>
 
-<p>查询结果如下例所示。</p>
+<p>结果如下例所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README_EN.md b/solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README_EN.md
index f3a56e35281fc..d3c3afc8dd134 100644
--- a/solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README_EN.md	
+++ b/solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README_EN.md	
@@ -4,7 +4,7 @@
 
 ## Description
 
-<p>Let&#39;s define a function <code>countUniqueChars(s)</code> that returns the number of unique characters on <code>s</code>.</p>
+<p>Let&#39;s define a function <code>countUniqueChars(s)</code> that returns the number of unique characters in&nbsp;<code>s</code>.</p>
 
 <ul>
 	<li>For example, calling <code>countUniqueChars(s)</code> if <code>s = &quot;LEETCODE&quot;</code> then <code>&quot;L&quot;</code>, <code>&quot;T&quot;</code>, <code>&quot;C&quot;</code>, <code>&quot;O&quot;</code>, <code>&quot;D&quot;</code> are the unique characters since they appear only once in <code>s</code>, therefore <code>countUniqueChars(s) = 5</code>.</li>
diff --git a/solution/0800-0899/0899.Orderly Queue/README_EN.md b/solution/0800-0899/0899.Orderly Queue/README_EN.md
index 83865a731a136..8ada9f00ca1d4 100644
--- a/solution/0800-0899/0899.Orderly Queue/README_EN.md	
+++ b/solution/0800-0899/0899.Orderly Queue/README_EN.md	
@@ -4,7 +4,7 @@
 
 ## Description
 
-<p>You are given a string <code>s</code> and an integer <code>k</code>. You can choose one of the first <code>k</code> letters of <code>s</code> and append it at the end of the string..</p>
+<p>You are given a string <code>s</code> and an integer <code>k</code>. You can choose one of the first <code>k</code> letters of <code>s</code> and append it at the end of the string.</p>
 
 <p>Return <em>the lexicographically smallest string you could have after applying the mentioned step any number of moves</em>.</p>
 
diff --git a/solution/0900-0999/0958.Check Completeness of a Binary Tree/README.md b/solution/0900-0999/0958.Check Completeness of a Binary Tree/README.md
index 18dd32c183c9f..d20d831798b90 100644
--- a/solution/0900-0999/0958.Check Completeness of a Binary Tree/README.md	
+++ b/solution/0900-0999/0958.Check Completeness of a Binary Tree/README.md	
@@ -6,9 +6,9 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定一个二叉树的<meta charset="UTF-8" />&nbsp;<code>root</code>&nbsp;，确定它是否是一个&nbsp;<em>完全二叉树</em>&nbsp;。</p>
+<p>给你一棵二叉树的根节点<meta charset="UTF-8" />&nbsp;<code>root</code> ，请你判断这棵树是否是一棵 <strong>完全二叉树</strong>&nbsp;。</p>
 
-<p>在一个&nbsp;<strong><a href="https://baike.baidu.com/item/完全二叉树/7773232?fr=aladdin" target="_blank">完全二叉树</a></strong>&nbsp;中，除了最后一个关卡外，所有关卡都是完全被填满的，并且最后一个关卡中的所有节点都是尽可能靠左的。它可以包含<meta charset="UTF-8" />&nbsp;<code>1</code>&nbsp;到<meta charset="UTF-8" />&nbsp;<code>2<sup>h</sup></code>&nbsp;节点之间的最后一级 <code>h</code> 。</p>
+<p>在一棵 <strong><a href="https://baike.baidu.com/item/完全二叉树/7773232?fr=aladdin" target="_blank">完全二叉树</a></strong> 中，除了最后一层外，所有层都被完全填满，并且最后一层中的所有节点都尽可能靠左。最后一层（第 <code>h</code> 层）中可以包含<meta charset="UTF-8" />&nbsp;<code>1</code>&nbsp;到<meta charset="UTF-8" />&nbsp;<code>2<sup>h</sup></code> 个节点。</p>
 
 <p>&nbsp;</p>
 
@@ -19,7 +19,7 @@
 <pre>
 <strong>输入：</strong>root = [1,2,3,4,5,6]
 <strong>输出：</strong>true
-<strong>解释：</strong>最后一层前的每一层都是满的（即，结点值为 {1} 和 {2,3} 的两层），且最后一层中的所有结点（{4,5,6}）都尽可能地向左。
+<strong>解释：</strong>最后一层前的每一层都是满的（即，节点值为 {1} 和 {2,3} 的两层），且最后一层中的所有节点（{4,5,6}）尽可能靠左。
 </pre>
 
 <p><strong>示例 2：</strong></p>
@@ -29,7 +29,7 @@
 <pre>
 <strong>输入：</strong>root = [1,2,3,4,5,null,7]
 <strong>输出：</strong>false
-<strong>解释：</strong>值为 7 的结点没有尽可能靠向左侧。
+<strong>解释：</strong>值为 7 的节点不满足条件「节点尽可能靠左」。
 </pre>
 
 <p>&nbsp;</p>
@@ -37,7 +37,7 @@
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li>树的结点数在范围 <meta charset="UTF-8" />&nbsp;<code>[1, 100]</code>&nbsp;内。</li>
+	<li>树中节点数目在范围 <code>[1, 100]</code> 内</li>
 	<li><code>1 &lt;= Node.val &lt;= 1000</code></li>
 </ul>
 
diff --git a/solution/1000-1099/1068.Product Sales Analysis I/README.md b/solution/1000-1099/1068.Product Sales Analysis I/README.md
index f39590050231e..7552083ec63d2 100644
--- a/solution/1000-1099/1068.Product Sales Analysis I/README.md	
+++ b/solution/1000-1099/1068.Product Sales Analysis I/README.md	
@@ -18,9 +18,10 @@
 | quantity    | int   |
 | price       | int   |
 +-------------+-------+
-(sale_id, year) 是销售表 Sales 的主键.
-product_id 是关联到产品表 Product 的外键.
-注意: price 表示每单位价格
+(sale_id, year) 是销售表 Sales 的主键（具有唯一值的列的组合）。
+product_id 是关联到产品表 Product 的外键（reference 列）。
+该表的每一行显示 product_id 在某一年的销售情况。
+注意: price 表示每单位价格。
 </pre>
 
 <p>产品表&nbsp;<code>Product</code>：</p>
@@ -32,21 +33,25 @@ product_id 是关联到产品表 Product 的外键.
 | product_id   | int     |
 | product_name | varchar |
 +--------------+---------+
-product_id&nbsp;是表的主键.
+product_id&nbsp;是表的主键（具有唯一值的列）。
+该表的每一行表示每种产品的产品名称。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>写一条SQL&nbsp;查询语句获取 <code>Sales</code>&nbsp;表中所有产品对应的 <strong>产品名称 product_name</strong> 以及该产品的所有 <strong>售卖年份 year</strong>&nbsp;和 <strong>价格 price</strong> 。</p>
+<p>编写解决方案，以获取 <code>Sales</code>&nbsp;表中所有 <code>sale_id</code> 对应的&nbsp;<code>product_name</code> 以及该产品的所有<strong>&nbsp;</strong><code>year</code>&nbsp;和<strong>&nbsp;</strong><code>price</code> 。</p>
 
-<p>查询结果中的顺序无特定要求。</p>
+<p>返回结果表&nbsp;<strong>无顺序要求</strong> 。</p>
 
-<p>查询结果格式示例如下：</p>
+<p>结果格式示例如下。</p>
 
 <p>&nbsp;</p>
 
+<p><strong>示例 1：</strong></p>
+
 <pre>
-<code>Sales</code> 表：
+<code><strong>输入：</strong>
+Sales</code> 表：
 +---------+------------+------+----------+-------+
 | sale_id | product_id | year | quantity | price |
 +---------+------------+------+----------+-------+ 
@@ -54,7 +59,6 @@ product_id&nbsp;是表的主键.
 | 2       | 100        | 2009 | 12       | 5000  |
 | 7       | 200        | 2011 | 15       | 9000  |
 +---------+------------+------+----------+-------+
-
 Product 表：
 +------------+--------------+
 | product_id | product_name |
@@ -63,8 +67,7 @@ Product 表：
 | 200        | Apple        |
 | 300        | Samsung      |
 +------------+--------------+
-
-Result 表：
+<strong>输出：</strong>
 +--------------+-------+-------+
 | product_name | year  | price |
 +--------------+-------+-------+
diff --git a/solution/1000-1099/1069.Product Sales Analysis II/README.md b/solution/1000-1099/1069.Product Sales Analysis II/README.md
index 603361d8ef651..65718b7935956 100644
--- a/solution/1000-1099/1069.Product Sales Analysis II/README.md	
+++ b/solution/1000-1099/1069.Product Sales Analysis II/README.md	
@@ -8,7 +8,8 @@
 
 <p>销售表：<code>Sales</code></p>
 
-<pre>+-------------+-------+
+<pre>
++-------------+-------+
 | Column Name | Type  |
 +-------------+-------+
 | sale_id     | int   |
@@ -17,31 +18,40 @@
 | quantity    | int   |
 | price       | int   |
 +-------------+-------+
-sale_id 是这个表的主键。
-product_id 是 Product 表的外键。
+sale_id 是这个表的主键（具有唯一值的列）。
+product_id 是 Product 表的外键（reference 列）。
+该表的每一行显示产品product_id在某一年的销售情况。
 请注意价格是每单位的。
 </pre>
 
 <p>产品表：<code>Product</code></p>
 
-<pre>+--------------+---------+
+<pre>
++--------------+---------+
 | Column Name  | Type    |
 +--------------+---------+
 | product_id   | int     |
 | product_name | varchar |
 +--------------+---------+
-product_id 是这个表的主键。
+product_id 是这个表的主键（具有唯一值的列）。
+该表的每一行表示每种产品的产品名称。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，按产品 id <code>product_id</code> 来统计每个产品的销售总量。</p>
+<p>编写解决方案，统计每个产品的销售总量。</p>
+
+<p>返回结果表 <strong>无顺序要求</strong> 。</p>
+
+<p>结果格式如下例子所示。</p>
 
 <p>&nbsp;</p>
 
-<p>查询结果格式如下面例子所示:</p>
+<p><strong>示例 1：</strong></p>
 
-<pre><code>Sales</code> 表：
+<pre>
+<code><strong>输入：</strong>
+Sales</code> 表：
 +---------+------------+------+----------+-------+
 | sale_id | product_id | year | quantity | price |
 +---------+------------+------+----------+-------+ 
@@ -49,7 +59,6 @@ product_id 是这个表的主键。
 | 2       | 100        | 2009 | 12       | 5000  |
 | 7       | 200        | 2011 | 15       | 9000  |
 +---------+------------+------+----------+-------+
-
 Product 表：
 +------------+--------------+
 | product_id | product_name |
@@ -58,8 +67,7 @@ Product 表：
 | 200        | Apple        |
 | 300        | Samsung      |
 +------------+--------------+
-
-Result 表：
+<strong>输出：</strong>
 +--------------+----------------+
 | product_id   | total_quantity |
 +--------------+----------------+
diff --git a/solution/1000-1099/1070.Product Sales Analysis III/README.md b/solution/1000-1099/1070.Product Sales Analysis III/README.md
index fe7927cce59cf..81abd4682e212 100644
--- a/solution/1000-1099/1070.Product Sales Analysis III/README.md	
+++ b/solution/1000-1099/1070.Product Sales Analysis III/README.md	
@@ -40,7 +40,7 @@ product_id 是这张表的主键（具有唯一值的列）。
 
 <p>&nbsp;</p>
 
-<p>编写解决方案，选出每个销售产品&nbsp;<strong>第一年</strong> 销售的 <strong>产品 id</strong>、<strong>年份</strong>、<strong>数量&nbsp;</strong>和 <strong>价格</strong>。</p>
+<p>编写解决方案，选出每个售出过的产品&nbsp;<strong>第一年</strong> 销售的 <strong>产品 id</strong>、<strong>年份</strong>、<strong>数量&nbsp;</strong>和 <strong>价格</strong>。</p>
 
 <p>结果表中的条目可以按 <strong>任意顺序</strong> 排列。</p>
 
diff --git a/solution/1000-1099/1077.Project Employees III/README.md b/solution/1000-1099/1077.Project Employees III/README.md
index c78ef0bdb270c..61d30992994a7 100644
--- a/solution/1000-1099/1077.Project Employees III/README.md	
+++ b/solution/1000-1099/1077.Project Employees III/README.md	
@@ -15,8 +15,9 @@
 | project_id  | int     |
 | employee_id | int     |
 +-------------+---------+
-(project_id, employee_id) 是这个表的主键
-employee_id 是员工表 Employee 的外键
+(project_id, employee_id) 是这个表的主键（具有唯一值的列的组合）
+employee_id 是员工表 Employee 的外键（reference 列）
+该表的每一行都表明具有 employee_id 的雇员正在处理具有 project_id 的项目。
 </pre>
 
 <p>员工表&nbsp;<code>Employee</code>：</p>
@@ -29,16 +30,24 @@ employee_id 是员工表 Employee 的外键
 | name             | varchar |
 | experience_years | int     |
 +------------------+---------+
-employee_id 是这个表的主键
+employee_id 是这个表的主键（具有唯一值的列）
+该表的每一行都包含一名雇员的信息。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>写 一个 SQL 查询语句，报告在每一个项目中经验最丰富的雇员是谁。如果出现经验年数相同的情况，请报告所有具有最大经验年数的员工。</p>
+<p>编写解决方案，报告在每一个项目中 <strong>经验最丰富</strong> 的雇员是谁。如果出现经验年数相同的情况，请报告所有具有最大经验年数的员工。</p>
 
-<p>查询结果格式在以下示例中：</p>
+<p>返回结果表 <strong>无顺序要求 。</strong></p>
+
+<p>结果格式如下示例所示。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
 <pre>
+<strong>输入：</strong>
 Project 表：
 +-------------+-------------+
 | project_id  | employee_id |
@@ -59,8 +68,7 @@ Employee 表：
 | 3           | John   | 3                |
 | 4           | Doe    | 2                |
 +-------------+--------+------------------+
-
-Result 表：
+<strong>输出：</strong>
 +-------------+---------------+
 | project_id  | employee_id   |
 +-------------+---------------+
@@ -68,7 +76,7 @@ Result 表：
 | 1           | 3             |
 | 2           | 1             |
 +-------------+---------------+
-employee_id 为 1 和 3 的员工在 project_id 为 1 的项目中拥有最丰富的经验。在 project_id 为 2 的项目中，employee_id 为 1 的员工拥有最丰富的经验。</pre>
+<strong>解释：</strong>employee_id 为 1 和 3 的员工在 project_id 为 1 的项目中拥有最丰富的经验。在 project_id 为 2 的项目中，employee_id 为 1 的员工拥有最丰富的经验。</pre>
 
 ## 解法
 
diff --git a/solution/1000-1099/1084.Sales Analysis III/README.md b/solution/1000-1099/1084.Sales Analysis III/README.md
index 2b78f6574a2a1..8a6f6ae57ba8b 100644
--- a/solution/1000-1099/1084.Sales Analysis III/README.md	
+++ b/solution/1000-1099/1084.Sales Analysis III/README.md	
@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>Table:&nbsp;<code>Product</code></p>
+<p>表：&nbsp;<code>Product</code></p>
 
 <pre>
 +--------------+---------+
@@ -16,11 +16,11 @@
 | product_name | varchar |
 | unit_price   | int     |
 +--------------+---------+
-Product_id是该表的主键。
+product_id 是该表的主键（具有唯一值的列）。
 该表的每一行显示每个产品的名称和价格。
 </pre>
 
-<p>Table:&nbsp;<code>Sales</code></p>
+<p>表：<code>Sales</code></p>
 
 <pre>
 +-------------+---------+
@@ -33,18 +33,18 @@ Product_id是该表的主键。
 | quantity    | int     |
 | price       | int     |
 +------ ------+---------+
-这个表没有主键，它可以有重复的行。
-product_id 是 Product 表的外键。
+这个表可能有重复的行。
+product_id 是 Product 表的外键（reference 列）。
 该表的每一行包含关于一个销售的一些信息。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个SQL查询，报告<code>2019年春季</code>才售出的产品。即<strong>仅</strong>在<code><strong>2019-01-01</strong></code>至<code><strong>2019-03-31</strong></code>（含）之间出售的商品。</p>
+<p>编写解决方案，报告<code>2019年春季</code>才售出的产品。即<strong>仅</strong>在<code><strong>2019-01-01</strong></code>至<code><strong>2019-03-31</strong></code>（含）之间出售的商品。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/1000-1099/1098.Unpopular Books/README.md b/solution/1000-1099/1098.Unpopular Books/README.md
index 117b40483ee1e..dd3f4846aa883 100644
--- a/solution/1000-1099/1098.Unpopular Books/README.md	
+++ b/solution/1000-1099/1098.Unpopular Books/README.md	
@@ -8,19 +8,21 @@
 
 <p>书籍表&nbsp;<code>Books</code>：</p>
 
-<pre>+----------------+---------+
+<pre>
++----------------+---------+
 | Column Name    | Type    |
 +----------------+---------+
 | book_id        | int     |
 | name           | varchar |
 | available_from | date    |
 +----------------+---------+
-book_id 是这个表的主键。
+book_id 是这个表的主键（具有唯一值的列）。
 </pre>
 
 <p>订单表&nbsp;<code>Orders</code>：</p>
 
-<pre>+----------------+---------+
+<pre>
++----------------+---------+
 | Column Name    | Type    |
 +----------------+---------+
 | order_id       | int     |
@@ -28,31 +30,34 @@ book_id 是这个表的主键。
 | quantity       | int     |
 | dispatch_date  | date    |
 +----------------+---------+
-order_id 是这个表的主键。
-book_id  是 Books 表的外键。
+order_id 是这个表的主键（具有唯一值的列）。
+book_id  是 Books 表的外键（reference 列）。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>你需要写一段 SQL 命令，筛选出过去一年中订单总量&nbsp;<strong>少于10本&nbsp;</strong>的&nbsp;<strong>书籍&nbsp;</strong>。</p>
+<p>编写解决方案，筛选出过去一年中订单总量&nbsp;<strong>少于 </strong><code>10</code><strong> 本&nbsp;</strong>的&nbsp;<strong>书籍</strong>，并且&nbsp;<strong>不考虑&nbsp;</strong>上架距今销售&nbsp;<strong>不满一个月</strong> 的书籍<strong>&nbsp;</strong>。<strong>假设今天是</strong>&nbsp;<code>2019-06-23</code>&nbsp;<strong>。</strong></p>
+
+<p>返回结果表 <strong>无顺序要求</strong> 。</p>
 
-<p>注意：<strong>不考虑&nbsp;</strong>上架（available from）距今&nbsp;<strong>不满一个月</strong> 的书籍。并且&nbsp;<strong>假设今天是</strong>&nbsp;<strong>2019-06-23&nbsp;</strong>。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
-<p>下面是样例输出结果：</p>
+<p><strong>示例 1：</strong></p>
 
-<pre>Books 表：
+<pre>
+<strong>输入：</strong>
+Books 表：
 +---------+--------------------+----------------+
 | book_id | name               | available_from |
 +---------+--------------------+----------------+
-| 1       | &quot;Kalila And Demna&quot; | 2010-01-01     |
-| 2       | &quot;28 Letters&quot;       | 2012-05-12     |
-| 3       | &quot;The Hobbit&quot;       | 2019-06-10     |
-| 4       | &quot;13 Reasons Why&quot;   | 2019-06-01     |
-| 5       | &quot;The Hunger Games&quot; | 2008-09-21     |
+| 1       | "Kalila And Demna" | 2010-01-01     |
+| 2       | "28 Letters"       | 2012-05-12     |
+| 3       | "The Hobbit"       | 2019-06-10     |
+| 4       | "13 Reasons Why"   | 2019-06-01     |
+| 5       | "The Hunger Games" | 2008-09-21     |
 +---------+--------------------+----------------+
-
 Orders 表：
 +----------+---------+----------+---------------+
 | order_id | book_id | quantity | dispatch_date |
@@ -65,14 +70,13 @@ Orders 表：
 | 6        | 5       | 9        | 2009-02-02    |
 | 7        | 5       | 8        | 2010-04-13    |
 +----------+---------+----------+---------------+
-
-Result 表：
+<strong>输出：</strong>
 +-----------+--------------------+
 | book_id   | name               |
 +-----------+--------------------+
-| 1         | &quot;Kalila And Demna&quot; |
-| 2         | &quot;28 Letters&quot;       |
-| 5         | &quot;The Hunger Games&quot; |
+| 1         | "Kalila And Demna" |
+| 2         | "28 Letters"       |
+| 5         | "The Hunger Games" |
 +-----------+--------------------+
 </pre>
 
diff --git a/solution/1100-1199/1107.New Users Daily Count/README.md b/solution/1100-1199/1107.New Users Daily Count/README.md
index 4a04195870ebd..aa1d982c791b1 100644
--- a/solution/1100-1199/1107.New Users Daily Count/README.md	
+++ b/solution/1100-1199/1107.New Users Daily Count/README.md	
@@ -8,24 +8,36 @@
 
 <p><code>Traffic</code>&nbsp;表：</p>
 
-<pre>+---------------+---------+
+<pre>
++---------------+---------+
 | Column Name   | Type    |
 +---------------+---------+
 | user_id       | int     |
 | activity      | enum    |
 | activity_date | date    |
 +---------------+---------+
-该表没有主键，它可能有重复的行。
-activity 列是 ENUM 类型，可能取 (&#39;login&#39;, &#39;logout&#39;, &#39;jobs&#39;, &#39;groups&#39;, &#39;homepage&#39;) 几个值之一。
+该表可能有重复的行。
+activity 列是 ENUM 类型，可能取 ('login', 'logout', 'jobs', 'groups', 'homepage') 几个值之一。
+
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，以查询从今天起最多 90 天内，每个日期该日期首次登录的用户数。假设今天是&nbsp;<strong>2019-06-30</strong>.</p>
+<p>编写解决方案，找出从今天起最多 90 天内，每个日期该日期首次登录的用户数。假设今天是&nbsp;<strong>2019-06-30 </strong>。</p>
+
+<p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果格式如下例所示：</p>
+<p>结果格式如下所示。</p>
+
+<p>&nbsp;</p>
 
-<pre>Traffic 表：
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>
+Traffic 表：
 +---------+----------+---------------+
 | user_id | activity | activity_date |
 +---------+----------+---------------+
@@ -45,14 +57,14 @@ activity 列是 ENUM 类型，可能取 (&#39;login&#39;, &#39;logout&#39;, &#39
 | 5       | login    | 2019-06-21    |
 | 5       | logout   | 2019-06-21    |
 +---------+----------+---------------+
-
-Result 表：
+<strong>输出：</strong>
 +------------+-------------+
 | login_date | user_count  |
 +------------+-------------+
 | 2019-05-01 | 1           |
 | 2019-06-21 | 2           |
 +------------+-------------+
+<strong>解释：</strong>
 请注意，我们只关心用户数非零的日期.
 ID 为 5 的用户第一次登陆于 2019-03-01，因此他不算在 2019-06-21 的的统计内。
 </pre>
diff --git a/solution/1100-1199/1112.Highest Grade For Each Student/README.md b/solution/1100-1199/1112.Highest Grade For Each Student/README.md
index fefd677763747..25bfcabf5b409 100644
--- a/solution/1100-1199/1112.Highest Grade For Each Student/README.md	
+++ b/solution/1100-1199/1112.Highest Grade For Each Student/README.md	
@@ -16,12 +16,12 @@
 | course_id     | int     |
 | grade         | int     |
 +---------------+---------+
-(student_id, course_id) 是该表的主键。
-</pre>
+(student_id, course_id) 是该表的主键（具有唯一值的列的组合）。
+grade 不会为 NULL。</pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，查询每位学生获得的最高成绩和它所对应的科目，若科目成绩并列，取&nbsp;<code>course_id</code>&nbsp;最小的一门。查询结果需按&nbsp;<code>student_id</code>&nbsp;增序进行排序。</p>
+<p>编写解决方案，找出每位学生获得的最高成绩和它所对应的科目，若科目成绩并列，取&nbsp;<code>course_id</code>&nbsp;最小的一门。查询结果需按&nbsp;<code>student_id</code>&nbsp;增序进行排序。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
diff --git a/solution/1100-1199/1113.Reported Posts/README.md b/solution/1100-1199/1113.Reported Posts/README.md
index 2c99120d0af2b..9c86697e34ad4 100644
--- a/solution/1100-1199/1113.Reported Posts/README.md	
+++ b/solution/1100-1199/1113.Reported Posts/README.md	
@@ -8,7 +8,8 @@
 
 <p>动作表：<code>Actions</code></p>
 
-<pre>+---------------+---------+
+<pre>
++---------------+---------+
 | Column Name   | Type    |
 +---------------+---------+
 | user_id       | int     |
@@ -17,18 +18,27 @@
 | action        | enum    |
 | extra         | varchar |
 +---------------+---------+
-此表没有主键，所以可能会有重复的行。
-action 字段是 ENUM 类型的，包含:(&#39;view&#39;, &#39;like&#39;, &#39;reaction&#39;, &#39;comment&#39;, <em><strong>&#39;report&#39;</strong></em>, &#39;share&#39;)
-extra 字段是可选的信息（可能为 null），其中的信息例如有：<em><strong>1.报告理由(a reason for report)</strong></em> 2.反应类型(a type of reaction)
+此表可能会有重复的行。
+action 字段是 ENUM 类型的，包含:('view', 'like', 'reaction', 'comment', <em><strong>'</strong></em>report<em><strong>'</strong></em>, 'share')
+extra 包含关于 action 的可选信息，例如举报的原因或反馈的类型。
+当 action 为 'report' 时 extra 不会为 NULL。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一条SQL，查询每种&nbsp;<em><strong>报告理由</strong></em>（report reason）在昨天的不同报告数量（post_id）。假设今天是&nbsp;<strong>2019-07-05</strong>。</p>
+<p>编写解决方案，针对每个举报原因统计昨天的举报帖子数量。假设今天是&nbsp;<code>2019-07-05</code>&nbsp;。</p>
+
+<p>返回结果表 <strong>无顺序要求 </strong>。</p>
+
+<p>结果格式如下示例所示。</p>
 
-<p>查询及结果的格式示例：</p>
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
-<pre>Actions table:
+<pre>
+<strong>输入：</strong>
+Actions table:
 +---------+---------+-------------+--------+--------+
 | user_id | post_id | action_date | action | extra  |
 +---------+---------+-------------+--------+--------+
@@ -46,15 +56,14 @@ extra 字段是可选的信息（可能为 null），其中的信息例如有：
 | 5       | 5       | 2019-07-04  | view   | null   |
 | 5       | 5       | 2019-07-04  | report | racism |
 +---------+---------+-------------+--------+--------+
-
-Result table:
+<strong>输出：</strong>
 +---------------+--------------+
 | report_reason | report_count |
 +---------------+--------------+
 | spam          | 1            |
 | racism        | 2            |
 +---------------+--------------+ 
-注意，我们只关心报告数量非零的结果。
+<strong>解释：</strong>注意，我们只关心举报帖数量非零的举报原因。
 </pre>
 
 ## 解法
diff --git a/solution/1100-1199/1126.Active Businesses/README.md b/solution/1100-1199/1126.Active Businesses/README.md
index d66e8b0f46fbe..38fa82f73eab1 100644
--- a/solution/1100-1199/1126.Active Businesses/README.md	
+++ b/solution/1100-1199/1126.Active Businesses/README.md	
@@ -16,19 +16,28 @@
 | event_type    | varchar |
 | occurences    | int     | 
 +---------------+---------+
-此表的主键是 (business_id, event_type)。
+(business_id, event_type) 是这个表的主键（具有唯一值的列的组合）。
 表中的每一行记录了某种类型的事件在某些业务中多次发生的信息。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>写一段 SQL 来查询所有活跃的业务。</p>
+<p><strong>平均活动</strong> 是指有特定 <code>event_type</code> 的具有该事件的所有公司的 <code>occurences</code>&nbsp;的均值。</p>
 
-<p>如果一个业务的某个事件类型的发生次数大于此事件类型在所有业务中的平均发生次数，并且该业务至少有两个这样的事件类型，那么该业务就可被看做是活跃业务。</p>
+<p><strong>活跃业务</strong> 是指具有&nbsp;<strong>多个</strong> <code>event_type</code>&nbsp;的业务，它们的 <code>occurences</code> <strong>严格大于</strong> 该事件的平均活动次数。</p>
 
-<p>查询结果格式如下所示：</p>
+<p>写一个解决方案，找到所有 <strong>活跃业务</strong>。</p>
+
+<p>以 <strong>任意顺序</strong> 返回结果表。</p>
+
+<p>结果格式如下所示。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
 <pre>
+<strong>输入：</strong>
 Events table:
 +-------------+------------+------------+
 | business_id | event_type | occurences |
@@ -41,15 +50,18 @@ Events table:
 | 1           | page views | 3          |
 | 2           | page views | 12         |
 +-------------+------------+------------+
-
-结果表
+<strong>输出：</strong>
 +-------------+
 | business_id |
 +-------------+
 | 1           |
 +-------------+ 
-&#39;reviews&#39;、 &#39;ads&#39; 和 &#39;page views&#39; 的总平均发生次数分别是 (7+3)/2=5, (11+7+6)/3=8, (3+12)/2=7.5。
-id 为 1 的业务有 7 个 &#39;reviews&#39; 事件（大于 5）和 11 个 &#39;ads&#39; 事件（大于 8），所以它是活跃业务。</pre>
+<strong>解释：</strong>
+每次活动的平均活动可计算如下:
+- 'reviews': (7+3)/2 = 5
+- 'ads': (11+7+6)/3 = 8
+- 'page views': (3+12)/2 = 7.5
+id=1 的业务有 7 个 'reviews' 事件(多于 5 个)和 11 个 'ads' 事件(多于 8 个)，所以它是一个活跃的业务。</pre>
 
 ## 解法
 
diff --git a/solution/1100-1199/1132.Reported Posts II/README.md b/solution/1100-1199/1132.Reported Posts II/README.md
index ee6685ba74e75..7838cc6f37546 100644
--- a/solution/1100-1199/1132.Reported Posts II/README.md	
+++ b/solution/1100-1199/1132.Reported Posts II/README.md	
@@ -18,7 +18,7 @@
 | action        | enum    |
 | extra         | varchar |
 +---------------+---------+
-这张表没有主键，并有可能存在重复的行。
+这张表可能存在重复的行。
 action 列的类型是 ENUM，可能的值为 ('view', 'like', 'reaction', 'comment', 'report', 'share')。
 extra 列拥有一些可选信息，例如：报告理由（a reason for report）或反应类型（a type of reaction）等。</pre>
 
@@ -33,17 +33,15 @@ extra 列拥有一些可选信息，例如：报告理由（a reason for report
 | post_id       | int     |
 | remove_date   | date    | 
 +---------------+---------+
-这张表的主键是 post_id。
+这张表的主键是 post_id（具有唯一值的列）。
 这张表的每一行表示一个被移除的帖子，原因可能是由于被举报或被管理员审查。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一段 SQL 来查找：在被报告为垃圾广告的帖子中，被移除的帖子的每日平均占比，<strong>四舍五入到小数点后 2 位</strong>。</p>
+<p>编写解决方案，统计在被报告为垃圾广告的帖子中，被移除的帖子的每日平均占比，<strong>四舍五入到小数点后 2 位</strong>。</p>
 
-<p>以 <strong>任意顺序</strong> 返回结果表。</p>
-
-<p>查询结果的格式如下。</p>
+<p>结果的格式如下。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/1100-1199/1141.User Activity for the Past 30 Days I/README.md b/solution/1100-1199/1141.User Activity for the Past 30 Days I/README.md
index 2c56706ed7277..5dedaca952d3d 100644
--- a/solution/1100-1199/1141.User Activity for the Past 30 Days I/README.md	
+++ b/solution/1100-1199/1141.User Activity for the Past 30 Days I/README.md	
@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>活动记录表：<code>Activity</code></p>
+<p>表：<code>Activity</code></p>
 
 <pre>
 +---------------+---------+
@@ -17,19 +17,19 @@
 | activity_date | date    |
 | activity_type | enum    |
 +---------------+---------+
-该表是用户在社交网站的活动记录。
-该表没有主键，可能包含重复数据。
-activity_type 字段为以下四种值 ('open_session', 'end_session', 'scroll_down', 'send_message')。
-每个 session_id 只属于一个用户。
+该表没有包含重复数据。
+activity_type 列是 ENUM(category) 类型， 从 ('open_session'， 'end_session'， 'scroll_down'， 'send_message') 取值。
+该表记录社交媒体网站的用户活动。
+注意，每个会话只属于一个用户。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>请写SQL查询出截至&nbsp;<code>2019-07-27</code>（包含2019-07-27），近<strong>&nbsp;</strong><code>30</code> 天的每日活跃用户数（当天只要有一条活动记录，即为活跃用户）。</p>
+<p>编写解决方案，统计截至&nbsp;<code>2019-07-27</code>（包含2019-07-27），近<strong>&nbsp;</strong><code>30</code> 天的每日活跃用户数（当天只要有一条活动记录，即为活跃用户）。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果示例如下。</p>
+<p>结果示例如下。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/1100-1199/1142.User Activity for the Past 30 Days II/README.md b/solution/1100-1199/1142.User Activity for the Past 30 Days II/README.md
index acf1cc4d37f7f..a68c3ae3eafd6 100644
--- a/solution/1100-1199/1142.User Activity for the Past 30 Days II/README.md	
+++ b/solution/1100-1199/1142.User Activity for the Past 30 Days II/README.md	
@@ -24,9 +24,9 @@ activity_type 列是 ENUM 类型，可以取（“ open_session”，“ end_ses
 
 <p>&nbsp;</p>
 
-<p>编写 SQL 查询以查找截至 <code>2019-07-27</code>（含）的 <code>30</code> 天内每个用户的平均会话数，<strong>四舍五入到小数点后两位</strong>。只统计那些会话期间用户至少进行一项活动的有效会话。</p>
+<p>编写解决方案，统计截至 <code>2019-07-27</code>（含）的 <code>30</code> 天内每个用户的平均会话数，<strong>四舍五入到小数点后两位</strong>。只统计那些会话期间用户至少进行一项活动的有效会话。</p>
 
-<p>查询结果格式如下例所示。</p>
+<p>结果格式如下例所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/1100-1199/1149.Article Views II/README.md b/solution/1100-1199/1149.Article Views II/README.md
index 2390d8b57f362..f86a19d44f3ab 100644
--- a/solution/1100-1199/1149.Article Views II/README.md	
+++ b/solution/1100-1199/1149.Article Views II/README.md	
@@ -17,18 +17,18 @@
 | viewer_id     | int     |
 | view_date     | date    |
 +---------------+---------+
-此表无主键，因此可能会存在重复行。
+此表可能会存在重复行。
 此表的每一行都表示某人在某天浏览了某位作者的某篇文章。 
 请注意，同一人的 author_id 和 viewer_id 是相同的。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一条 SQL 查询来找出在同一天阅读至少两篇文章的人。</p>
+<p>编写解决方案来找出在同一天阅读至少两篇文章的人。</p>
 
 <p>结果按照 <code>id</code> 升序排序。</p>
 
-<p>查询结果的格式如下。</p>
+<p>结果的格式如下。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/1100-1199/1158.Market Analysis I/README.md b/solution/1100-1199/1158.Market Analysis I/README.md
index 68d33fa1a27ef..0e1cfe63ba093 100644
--- a/solution/1100-1199/1158.Market Analysis I/README.md	
+++ b/solution/1100-1199/1158.Market Analysis I/README.md	
@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>Table: <code>Users</code></p>
+<p>表：&nbsp;<code>Users</code></p>
 
 <pre>
 +----------------+---------+
@@ -16,13 +16,13 @@
 | join_date      | date    |
 | favorite_brand | varchar |
 +----------------+---------+
-此表主键是 user_id。
+user_id 是此表主键（具有唯一值的列）。
 表中描述了购物网站的用户信息，用户可以在此网站上进行商品买卖。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>Table: <code>Orders</code></p>
+<p>表：&nbsp;<code>Orders</code></p>
 
 <pre>
 +---------------+---------+
@@ -34,13 +34,14 @@
 | buyer_id      | int     |
 | seller_id     | int     |
 +---------------+---------+
-此表主键是 order_id。
-外键是 item_id 和（buyer_id，seller_id）。
+order_id 是此表主键（具有唯一值的列）。
+item_id 是 Items 表的外键（reference 列）。
+（buyer_id，seller_id）是 User 表的外键。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>Table: <code>Items</code></p>
+<p>表：<code>Items</code></p>
 
 <pre>
 +---------------+---------+
@@ -49,12 +50,12 @@
 | item_id       | int     |
 | item_brand    | varchar |
 +---------------+---------+
-此表主键是 item_id。
+item_id 是此表的主键（具有唯一值的列）。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>请写出一条SQL语句以查询每个用户的注册日期和在 <strong><code>2019</code> </strong>年作为买家的订单总数。</p>
+<p>编写解决方案找出每个用户的注册日期和在 <strong><code>2019</code> </strong>年作为买家的订单总数。</p>
 
 <p>以 <strong>任意顺序</strong> 返回结果表。</p>
 
diff --git a/solution/1200-1299/1204.Last Person to Fit in the Bus/README.md b/solution/1200-1299/1204.Last Person to Fit in the Bus/README.md
index 4cb11a300d9c0..3deb934aeac53 100644
--- a/solution/1200-1299/1204.Last Person to Fit in the Bus/README.md	
+++ b/solution/1200-1299/1204.Last Person to Fit in the Bus/README.md	
@@ -50,11 +50,11 @@ Queue 表
 | 2         | Marie       | 200    | 4    |
 +-----------+-------------+--------+------+
 <strong>输出：</strong>
-+-------------------+
-| person_name       |
-+-------------------+
-| Thomas Jefferson  |
-+-------------------+
++-------------+
+| person_name |
++-------------+
+| John Cena   |
++-------------+
 <strong>解释：</strong>
 为了简化，Queue 表按 turn 列由小到大排序。
 +------+----+-----------+--------+--------------+
diff --git a/solution/1200-1299/1263.Minimum Moves to Move a Box to Their Target Location/README_EN.md b/solution/1200-1299/1263.Minimum Moves to Move a Box to Their Target Location/README_EN.md
index f5e30fca4e4df..5afc0b74fdd7e 100644
--- a/solution/1200-1299/1263.Minimum Moves to Move a Box to Their Target Location/README_EN.md	
+++ b/solution/1200-1299/1263.Minimum Moves to Move a Box to Their Target Location/README_EN.md	
@@ -13,7 +13,7 @@
 <ul>
 	<li>The character <code>&#39;S&#39;</code> represents the player. The player can move up, down, left, right in <code>grid</code> if it is a floor (empty cell).</li>
 	<li>The character <code>&#39;.&#39;</code> represents the floor which means a free cell to walk.</li>
-	<li>The character <code>&#39;#&#39; </code>represents the wall which means an obstacle (impossible to walk there).</li>
+	<li>The character<font face="monospace">&nbsp;</font><code>&#39;#&#39;</code><font face="monospace">&nbsp;</font>represents the wall which means an obstacle (impossible to walk there).</li>
 	<li>There is only one box <code>&#39;B&#39;</code> and one target cell <code>&#39;T&#39;</code> in the <code>grid</code>.</li>
 	<li>The box can be moved to an adjacent free cell by standing next to the box and then moving in the direction of the box. This is a <strong>push</strong>.</li>
 	<li>The player cannot walk through the box.</li>
diff --git a/solution/1200-1299/1267.Count Servers that Communicate/README.md b/solution/1200-1299/1267.Count Servers that Communicate/README.md
index a775913c90066..fbe75925d034e 100644
--- a/solution/1200-1299/1267.Count Servers that Communicate/README.md	
+++ b/solution/1200-1299/1267.Count Servers that Communicate/README.md	
@@ -58,7 +58,7 @@
 
 **方法一：计数**
 
-我们可以统计每一行、每一列的服务器数量，然后遍历每个服务器，若当前服务器所在的行或者列的服务器数量超过 1，说明当前服务器满足条件，结果加 $1$。
+我们可以统计每一行、每一列的服务器数量，然后遍历每个服务器，若当前服务器所在的行或者列的服务器数量超过 $1$，说明当前服务器满足条件，结果加 $1$。
 
 遍历结束后，返回结果即可。
 
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/README.md b/solution/1200-1299/1274.Number of Ships in a Rectangle/README.md
index 58e0aeecf9fd1..27fd7e055fcab 100644
--- a/solution/1200-1299/1274.Number of Ships in a Rectangle/README.md	
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/README.md	
@@ -53,6 +53,12 @@ ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：递归 + 分治**
+
+由于矩形内最多只有 $10$ 艘船，所以我们可以将矩形划分为四个子矩形，分别求出每个子矩形内船只的数目，然后将四个子矩形内船只的数目相加即可。如果一个子矩形内没有船只，那么就不需要再继续划分了。
+
+时间复杂度 $O(C \times \log \max(m, n))$，空间复杂度 $O(\log \max(m, n))$。其中 $C$ 为船只的数目，而 $m$ 和 $n$ 分别为矩形的长和宽。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -60,7 +66,39 @@ ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# """
+# This is Sea's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+# class Sea:
+#    def hasShips(self, topRight: 'Point', bottomLeft: 'Point') -> bool:
+#
+# class Point:
+# 	def __init__(self, x: int, y: int):
+# 		self.x = x
+# 		self.y = y
+
+
+class Solution:
+    def countShips(self, sea: "Sea", topRight: "Point", bottomLeft: "Point") -> int:
+        def dfs(topRight, bottomLeft):
+            x1, y1 = bottomLeft.x, bottomLeft.y
+            x2, y2 = topRight.x, topRight.y
+            if x1 > x2 or y1 > y2:
+                return 0
+            if not sea.hasShips(topRight, bottomLeft):
+                return 0
+            if x1 == x2 and y1 == y2:
+                return 1
+            midx = (x1 + x2) >> 1
+            midy = (y1 + y2) >> 1
+            a = dfs(topRight, Point(midx + 1, midy + 1))
+            b = dfs(Point(midx, y2), Point(x1, midy + 1))
+            c = dfs(Point(midx, midy), bottomLeft)
+            d = dfs(Point(x2, midy), Point(midx + 1, y1))
+            return a + b + c + d
+
+        return dfs(topRight, bottomLeft)
 ```
 
 ### **Java**
@@ -68,7 +106,140 @@ ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *     public boolean hasShips(int[] topRight, int[] bottomLeft);
+ * }
+ */
+
+class Solution {
+    public int countShips(Sea sea, int[] topRight, int[] bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, new int[] {midx + 1, midy + 1});
+        int b = countShips(sea, new int[] {midx, y2}, new int[] {x1, midy + 1});
+        int c = countShips(sea, new int[] {midx, midy}, bottomLeft);
+        int d = countShips(sea, new int[] {x2, midy}, new int[] {midx + 1, y1});
+        return a + b + c + d;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *   public:
+ *     bool hasShips(vector<int> topRight, vector<int> bottomLeft);
+ * };
+ */
+
+class Solution {
+public:
+    int countShips(Sea sea, vector<int> topRight, vector<int> bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, {midx + 1, midy + 1});
+        int b = countShips(sea, {midx, y2}, {x1, midy + 1});
+        int c = countShips(sea, {midx, midy}, bottomLeft);
+        int d = countShips(sea, {x2, midy}, {midx + 1, y1});
+        return a + b + c + d;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * type Sea struct {
+ *     func hasShips(topRight, bottomLeft []int) bool {}
+ * }
+ */
+
+func countShips(sea Sea, topRight, bottomLeft []int) int {
+	x1, y1 := bottomLeft[0], bottomLeft[1]
+	x2, y2 := topRight[0], topRight[1]
+	if x1 > x2 || y1 > y2 {
+		return 0
+	}
+	if !sea.hasShips(topRight, bottomLeft) {
+		return 0
+	}
+	if x1 == x2 && y1 == y2 {
+		return 1
+	}
+	midx := (x1 + x2) >> 1
+	midy := (y1 + y2) >> 1
+	a := countShips(sea, topRight, []int{midx + 1, midy + 1})
+	b := countShips(sea, []int{midx, y2}, []int{x1, midy + 1})
+	c := countShips(sea, []int{midx, midy}, bottomLeft)
+	d := countShips(sea, []int{x2, midy}, []int{midx + 1, y1})
+	return a + b + c + d
+}
+```
 
+### **TypeScript**
+
+```ts
+/**
+ * // This is the Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *      hasShips(topRight: number[], bottomLeft: number[]): boolean {}
+ * }
+ */
+
+function countShips(
+    sea: Sea,
+    topRight: number[],
+    bottomLeft: number[],
+): number {
+    const [x1, y1] = bottomLeft;
+    const [x2, y2] = topRight;
+    if (x1 > x2 || y1 > y2 || !sea.hasShips(topRight, bottomLeft)) {
+        return 0;
+    }
+    if (x1 === x2 && y1 === y2) {
+        return 1;
+    }
+    const midx = (x1 + x2) >> 1;
+    const midy = (y1 + y2) >> 1;
+    const a = countShips(sea, topRight, [midx + 1, midy + 1]);
+    const b = countShips(sea, [midx, y2], [x1, midy + 1]);
+    const c = countShips(sea, [midx, midy], bottomLeft);
+    const d = countShips(sea, [x2, midy], [midx + 1, y1]);
+    return a + b + c + d;
+}
 ```
 
 ### **...**
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/README_EN.md b/solution/1200-1299/1274.Number of Ships in a Rectangle/README_EN.md
index 816c565f59385..1f6c8226c0ffc 100644
--- a/solution/1200-1299/1274.Number of Ships in a Rectangle/README_EN.md	
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/README_EN.md	
@@ -48,13 +48,178 @@ ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
 ### **Python3**
 
 ```python
-
+# """
+# This is Sea's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+# class Sea:
+#    def hasShips(self, topRight: 'Point', bottomLeft: 'Point') -> bool:
+#
+# class Point:
+# 	def __init__(self, x: int, y: int):
+# 		self.x = x
+# 		self.y = y
+
+
+class Solution:
+    def countShips(self, sea: "Sea", topRight: "Point", bottomLeft: "Point") -> int:
+        def dfs(topRight, bottomLeft):
+            x1, y1 = bottomLeft.x, bottomLeft.y
+            x2, y2 = topRight.x, topRight.y
+            if x1 > x2 or y1 > y2:
+                return 0
+            if not sea.hasShips(topRight, bottomLeft):
+                return 0
+            if x1 == x2 and y1 == y2:
+                return 1
+            midx = (x1 + x2) >> 1
+            midy = (y1 + y2) >> 1
+            a = dfs(topRight, Point(midx + 1, midy + 1))
+            b = dfs(Point(midx, y2), Point(x1, midy + 1))
+            c = dfs(Point(midx, midy), bottomLeft)
+            d = dfs(Point(x2, midy), Point(midx + 1, y1))
+            return a + b + c + d
+
+        return dfs(topRight, bottomLeft)
 ```
 
 ### **Java**
 
 ```java
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *     public boolean hasShips(int[] topRight, int[] bottomLeft);
+ * }
+ */
+
+class Solution {
+    public int countShips(Sea sea, int[] topRight, int[] bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, new int[] {midx + 1, midy + 1});
+        int b = countShips(sea, new int[] {midx, y2}, new int[] {x1, midy + 1});
+        int c = countShips(sea, new int[] {midx, midy}, bottomLeft);
+        int d = countShips(sea, new int[] {x2, midy}, new int[] {midx + 1, y1});
+        return a + b + c + d;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *   public:
+ *     bool hasShips(vector<int> topRight, vector<int> bottomLeft);
+ * };
+ */
+
+class Solution {
+public:
+    int countShips(Sea sea, vector<int> topRight, vector<int> bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, {midx + 1, midy + 1});
+        int b = countShips(sea, {midx, y2}, {x1, midy + 1});
+        int c = countShips(sea, {midx, midy}, bottomLeft);
+        int d = countShips(sea, {x2, midy}, {midx + 1, y1});
+        return a + b + c + d;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * type Sea struct {
+ *     func hasShips(topRight, bottomLeft []int) bool {}
+ * }
+ */
+
+func countShips(sea Sea, topRight, bottomLeft []int) int {
+	x1, y1 := bottomLeft[0], bottomLeft[1]
+	x2, y2 := topRight[0], topRight[1]
+	if x1 > x2 || y1 > y2 {
+		return 0
+	}
+	if !sea.hasShips(topRight, bottomLeft) {
+		return 0
+	}
+	if x1 == x2 && y1 == y2 {
+		return 1
+	}
+	midx := (x1 + x2) >> 1
+	midy := (y1 + y2) >> 1
+	a := countShips(sea, topRight, []int{midx + 1, midy + 1})
+	b := countShips(sea, []int{midx, y2}, []int{x1, midy + 1})
+	c := countShips(sea, []int{midx, midy}, bottomLeft)
+	d := countShips(sea, []int{x2, midy}, []int{midx + 1, y1})
+	return a + b + c + d
+}
+```
 
+### **TypeScript**
+
+```ts
+/**
+ * // This is the Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *      hasShips(topRight: number[], bottomLeft: number[]): boolean {}
+ * }
+ */
+
+function countShips(
+    sea: Sea,
+    topRight: number[],
+    bottomLeft: number[],
+): number {
+    const [x1, y1] = bottomLeft;
+    const [x2, y2] = topRight;
+    if (x1 > x2 || y1 > y2 || !sea.hasShips(topRight, bottomLeft)) {
+        return 0;
+    }
+    if (x1 === x2 && y1 === y2) {
+        return 1;
+    }
+    const midx = (x1 + x2) >> 1;
+    const midy = (y1 + y2) >> 1;
+    const a = countShips(sea, topRight, [midx + 1, midy + 1]);
+    const b = countShips(sea, [midx, y2], [x1, midy + 1]);
+    const c = countShips(sea, [midx, midy], bottomLeft);
+    const d = countShips(sea, [x2, midy], [midx + 1, y1]);
+    return a + b + c + d;
+}
 ```
 
 ### **...**
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.cpp b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.cpp
new file mode 100644
index 0000000000000..524b4c577f9c1
--- /dev/null
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.cpp	
@@ -0,0 +1,32 @@
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *   public:
+ *     bool hasShips(vector<int> topRight, vector<int> bottomLeft);
+ * };
+ */
+
+class Solution {
+public:
+    int countShips(Sea sea, vector<int> topRight, vector<int> bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, {midx + 1, midy + 1});
+        int b = countShips(sea, {midx, y2}, {x1, midy + 1});
+        int c = countShips(sea, {midx, midy}, bottomLeft);
+        int d = countShips(sea, {x2, midy}, {midx + 1, y1});
+        return a + b + c + d;
+    }
+};
\ No newline at end of file
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.go b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.go
new file mode 100644
index 0000000000000..5faf0f8c52ae7
--- /dev/null
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.go	
@@ -0,0 +1,28 @@
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * type Sea struct {
+ *     func hasShips(topRight, bottomLeft []int) bool {}
+ * }
+ */
+
+func countShips(sea Sea, topRight, bottomLeft []int) int {
+	x1, y1 := bottomLeft[0], bottomLeft[1]
+	x2, y2 := topRight[0], topRight[1]
+	if x1 > x2 || y1 > y2 {
+		return 0
+	}
+	if !sea.hasShips(topRight, bottomLeft) {
+		return 0
+	}
+	if x1 == x2 && y1 == y2 {
+		return 1
+	}
+	midx := (x1 + x2) >> 1
+	midy := (y1 + y2) >> 1
+	a := countShips(sea, topRight, []int{midx + 1, midy + 1})
+	b := countShips(sea, []int{midx, y2}, []int{x1, midy + 1})
+	c := countShips(sea, []int{midx, midy}, bottomLeft)
+	d := countShips(sea, []int{x2, midy}, []int{midx + 1, y1})
+	return a + b + c + d
+}
\ No newline at end of file
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.java b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.java
new file mode 100644
index 0000000000000..42972e271ebf5
--- /dev/null
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.java	
@@ -0,0 +1,30 @@
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *     public boolean hasShips(int[] topRight, int[] bottomLeft);
+ * }
+ */
+
+class Solution {
+    public int countShips(Sea sea, int[] topRight, int[] bottomLeft) {
+        int x1 = bottomLeft[0], y1 = bottomLeft[1];
+        int x2 = topRight[0], y2 = topRight[1];
+        if (x1 > x2 || y1 > y2) {
+            return 0;
+        }
+        if (!sea.hasShips(topRight, bottomLeft)) {
+            return 0;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return 1;
+        }
+        int midx = (x1 + x2) >> 1;
+        int midy = (y1 + y2) >> 1;
+        int a = countShips(sea, topRight, new int[] {midx + 1, midy + 1});
+        int b = countShips(sea, new int[] {midx, y2}, new int[] {x1, midy + 1});
+        int c = countShips(sea, new int[] {midx, midy}, bottomLeft);
+        int d = countShips(sea, new int[] {x2, midy}, new int[] {midx + 1, y1});
+        return a + b + c + d;
+    }
+}
\ No newline at end of file
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.py b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.py
new file mode 100644
index 0000000000000..cbb1fafb756b4
--- /dev/null
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.py	
@@ -0,0 +1,33 @@
+# """
+# This is Sea's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+# class Sea:
+#    def hasShips(self, topRight: 'Point', bottomLeft: 'Point') -> bool:
+#
+# class Point:
+# 	def __init__(self, x: int, y: int):
+# 		self.x = x
+# 		self.y = y
+
+
+class Solution:
+    def countShips(self, sea: "Sea", topRight: "Point", bottomLeft: "Point") -> int:
+        def dfs(topRight, bottomLeft):
+            x1, y1 = bottomLeft.x, bottomLeft.y
+            x2, y2 = topRight.x, topRight.y
+            if x1 > x2 or y1 > y2:
+                return 0
+            if not sea.hasShips(topRight, bottomLeft):
+                return 0
+            if x1 == x2 and y1 == y2:
+                return 1
+            midx = (x1 + x2) >> 1
+            midy = (y1 + y2) >> 1
+            a = dfs(topRight, Point(midx + 1, midy + 1))
+            b = dfs(Point(midx, y2), Point(x1, midy + 1))
+            c = dfs(Point(midx, midy), bottomLeft)
+            d = dfs(Point(x2, midy), Point(midx + 1, y1))
+            return a + b + c + d
+
+        return dfs(topRight, bottomLeft)
diff --git a/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.ts b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.ts
new file mode 100644
index 0000000000000..f4540f6f6193b
--- /dev/null
+++ b/solution/1200-1299/1274.Number of Ships in a Rectangle/Solution.ts	
@@ -0,0 +1,29 @@
+/**
+ * // This is the Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Sea {
+ *      hasShips(topRight: number[], bottomLeft: number[]): boolean {}
+ * }
+ */
+
+function countShips(
+    sea: Sea,
+    topRight: number[],
+    bottomLeft: number[],
+): number {
+    const [x1, y1] = bottomLeft;
+    const [x2, y2] = topRight;
+    if (x1 > x2 || y1 > y2 || !sea.hasShips(topRight, bottomLeft)) {
+        return 0;
+    }
+    if (x1 === x2 && y1 === y2) {
+        return 1;
+    }
+    const midx = (x1 + x2) >> 1;
+    const midy = (y1 + y2) >> 1;
+    const a = countShips(sea, topRight, [midx + 1, midy + 1]);
+    const b = countShips(sea, [midx, y2], [x1, midy + 1]);
+    const c = countShips(sea, [midx, midy], bottomLeft);
+    const d = countShips(sea, [x2, midy], [midx + 1, y1]);
+    return a + b + c + d;
+}
diff --git a/solution/1300-1399/1383.Maximum Performance of a Team/README_EN.md b/solution/1300-1399/1383.Maximum Performance of a Team/README_EN.md
index 11e8065aad249..a350e1bfba38f 100644
--- a/solution/1300-1399/1383.Maximum Performance of a Team/README_EN.md	
+++ b/solution/1300-1399/1383.Maximum Performance of a Team/README_EN.md	
@@ -8,7 +8,7 @@
 
 <p>Choose <strong>at most</strong> <code>k</code> different engineers out of the <code>n</code> engineers to form a team with the maximum <strong>performance</strong>.</p>
 
-<p>The performance of a team is the sum of their engineers&#39; speeds multiplied by the minimum efficiency among their engineers.</p>
+<p>The performance of a team is the sum of its engineers&#39; speeds multiplied by the minimum efficiency among its engineers.</p>
 
 <p>Return <em>the maximum performance of this team</em>. Since the answer can be a huge number, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
 
diff --git a/solution/1400-1499/1454.Active Users/README.md b/solution/1400-1499/1454.Active Users/README.md
index 25c93215a8341..6b13bd94262ce 100644
--- a/solution/1400-1499/1454.Active Users/README.md	
+++ b/solution/1400-1499/1454.Active Users/README.md	
@@ -15,11 +15,11 @@
 | id            | int     |
 | name          | varchar |
 +---------------+---------+
-id 是该表主键.
+id 是该表主键（具有唯一值的列）
 该表包含账户 id 和账户的用户名.
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p>表 <code>Logins</code>:</p>
 
@@ -30,21 +30,26 @@ id 是该表主键.
 | id            | int     |
 | login_date    | date    |
 +---------------+---------+
-该表无主键, 可能包含重复项.
+该表可能包含重复项.
 该表包含登录用户的账户 id 和登录日期. 用户也许一天内登录多次.
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
-<p>写一个 SQL 查询,  找到活跃用户的 id 和 name.</p>
+<p><strong>活跃用户</strong> 是指那些至少连续&nbsp;5 天登录账户的用户。</p>
 
-<p>活跃用户是指那些至少连续 5 天登录账户的用户.</p>
+<p>编写解决方案,&nbsp; 找到 <strong>活跃用户</strong> 的 id 和 name。</p>
 
-<p>返回的结果表按照 id 排序.</p>
+<p>返回的结果表按照 <code>id</code> <strong>排序&nbsp;</strong>。</p>
 
-<p>结果表格式如下例所示:</p>
+<p>结果表格式如下例所示。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
 <pre>
+<strong>输入：</strong>
 Accounts 表:
 +----+----------+
 | id | name     |
@@ -67,21 +72,21 @@ Logins 表:
 | 1  | 2020-06-07 |
 | 7  | 2020-06-10 |
 +----+------------+
-
-Result 表:
+<strong>输出：</strong>
 +----+----------+
 | id | name     |
 +----+----------+
 | 7  | Jonathan |
 +----+----------+
+<strong>解释：</strong>
 id = 1 的用户 Winston 仅仅在不同的 2 天内登录了 2 次, 所以, Winston 不是活跃用户.
 id = 7 的用户 Jonathon 在不同的 6 天内登录了 7 次, , 6 天中有 5 天是连续的, 所以, Jonathan 是活跃用户.
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>进阶问题:</strong><br />
-如果活跃用户是那些至少连续 <code>n</code> 天登录账户的用户, 你能否写出通用的解决方案?</p>
+如果活跃用户是那些至少连续&nbsp;<code>n</code>&nbsp;天登录账户的用户,&nbsp;你能否写出通用的解决方案?</p>
 
 ## 解法
 
diff --git a/solution/1400-1499/1495.Friendly Movies Streamed Last Month/README.md b/solution/1400-1499/1495.Friendly Movies Streamed Last Month/README.md
index bb82ce6da42bb..07f23fd5637e4 100644
--- a/solution/1400-1499/1495.Friendly Movies Streamed Last Month/README.md	
+++ b/solution/1400-1499/1495.Friendly Movies Streamed Last Month/README.md	
@@ -84,7 +84,7 @@ TVProgram</code> 表:
 "Leetcode Movie" 是儿童不宜的电影.
 "Alg. for Kids" 不是电影.
 "Database Sols" 不是电影
-"Alladin" 是电影, 儿童适宜, 并且在 2020 年 6 月份播放.
+"Aladin" 是电影, 儿童适宜, 并且在 2020 年 6 月份播放.
 "Cinderella" 不在 2020 年 6 月份播放.</pre>
 
 ## 解法
diff --git a/solution/1600-1699/1625.Lexicographically Smallest String After Applying Operations/README.md b/solution/1600-1699/1625.Lexicographically Smallest String After Applying Operations/README.md
index 683a0daae0595..f1b1ca45b09d3 100644
--- a/solution/1600-1699/1625.Lexicographically Smallest String After Applying Operations/README.md	
+++ b/solution/1600-1699/1625.Lexicographically Smallest String After Applying Operations/README.md	
@@ -11,7 +11,7 @@
 <p>你可以在 <code>s</code> 上按任意顺序多次执行下面两个操作之一：</p>
 
 <ul>
-	<li>累加：将  <code>a</code> 加到 <code>s</code> 中所有下标为奇数的元素上（<strong>下标从 0 开始</strong>）。数字一旦超过 <code>9</code> 就会变成 <code>0</code>，如此循环往复。例如，<code>s = "3456"</code> 且 <code>a = 5</code>，则执行此操作后 <code>s</code> 变成 <code>"3951"</code>。</li>
+	<li>累加：将&nbsp; <code>a</code> 加到 <code>s</code> 中所有下标为奇数的元素上（<strong>下标从 0 开始</strong>）。数字一旦超过 <code>9</code> 就会变成 <code>0</code>，如此循环往复。例如，<code>s = "3456"</code> 且 <code>a = 5</code>，则执行此操作后 <code>s</code> 变成 <code>"3951"</code>。</li>
 	<li>轮转：将 <code>s</code> 向右轮转 <code>b</code> 位。例如，<code>s = "3456"</code> 且 <code>b = 1</code>，则执行此操作后 <code>s</code> 变成 <code>"6345"</code>。</li>
 </ul>
 
@@ -19,7 +19,7 @@
 
 <p>如果两个字符串长度相同，那么字符串 <code>a</code> 字典序比字符串 <code>b</code> 小可以这样定义：在 <code>a</code> 和 <code>b</code> 出现不同的第一个位置上，字符串 <code>a</code> 中的字符出现在字母表中的时间早于 <code>b</code> 中的对应字符。例如，<code>"0158”</code> 字典序比 <code>"0190"</code> 小，因为不同的第一个位置是在第三个字符，显然 <code>'5'</code> 出现在 <code>'9'</code> 之前。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
@@ -35,7 +35,7 @@
 累加："5222"
 累加："5121"
 轮转："2151"
-累加："2050"​​​​​​​​​​​​
+累加："2050"​​​​​
 无法获得字典序小于 "2050" 的字符串。
 </pre>
 
@@ -48,7 +48,7 @@
 初态："74"
 轮转："47"
 累加："42"
-轮转："24"​​​​​​​​​​​​
+轮转："24"​​​​​
 无法获得字典序小于 "24" 的字符串。
 </pre>
 
@@ -60,23 +60,16 @@
 <strong>解释：</strong>无法获得字典序小于 "0011" 的字符串。
 </pre>
 
-<p><strong>示例 4：</strong></p>
-
-<pre>
-<strong>输入：</strong>s = "43987654", a = 7, b = 3
-<strong>输出：</strong>"00553311"
-</pre>
-
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>2 <= s.length <= 100</code></li>
+	<li><code>2 &lt;= s.length &lt;= 100</code></li>
 	<li><code>s.length</code> 是偶数</li>
 	<li><code>s</code> 仅由数字 <code>0</code> 到 <code>9</code> 组成</li>
-	<li><code>1 <= a <= 9</code></li>
-	<li><code>1 <= b <= s.length - 1</code></li>
+	<li><code>1 &lt;= a &lt;= 9</code></li>
+	<li><code>1 &lt;= b &lt;= s.length - 1</code></li>
 </ul>
 
 ## 解法
diff --git a/solution/1600-1699/1661.Average Time of Process per Machine/README.md b/solution/1600-1699/1661.Average Time of Process per Machine/README.md
index 461f3cbc6a965..41c7245a6ff15 100644
--- a/solution/1600-1699/1661.Average Time of Process per Machine/README.md	
+++ b/solution/1600-1699/1661.Average Time of Process per Machine/README.md	
@@ -17,22 +17,22 @@
 | activity_type  | enum    |
 | timestamp      | float   |
 +----------------+---------+
-该表展示了一家工厂网站的用户活动.
-(machine_id, process_id, activity_type) 是当前表的主键.
-machine_id 是一台机器的ID号.
-process_id 是运行在各机器上的进程ID号.
-activity_type 是枚举类型 ('start', 'end').
-timestamp 是浮点类型,代表当前时间(以秒为单位).
-'start' 代表该进程在这台机器上的开始运行时间戳 , 'end' 代表该进程在这台机器上的终止运行时间戳.
-同一台机器，同一个进程都有一对开始时间戳和结束时间戳，而且开始时间戳永远在结束时间戳前面.</pre>
+该表展示了一家工厂网站的用户活动。
+(machine_id, process_id, activity_type) 是当前表的主键（具有唯一值的列的组合）。
+machine_id 是一台机器的ID号。
+process_id 是运行在各机器上的进程ID号。
+activity_type 是枚举类型 ('start', 'end')。
+timestamp 是浮点类型,代表当前时间(以秒为单位)。
+'start' 代表该进程在这台机器上的开始运行时间戳 , 'end' 代表该进程在这台机器上的终止运行时间戳。
+同一台机器，同一个进程都有一对开始时间戳和结束时间戳，而且开始时间戳永远在结束时间戳前面。</pre>
 
 <p>&nbsp;</p>
 
-<p>现在有一个工厂网站由几台机器运行，每台机器上运行着相同数量的进程. 请写出一条SQL计算每台机器各自完成一个进程任务的平均耗时.</p>
+<p>现在有一个工厂网站由几台机器运行，每台机器上运行着 <strong>相同数量的进程</strong> 。编写解决方案，计算每台机器各自完成一个进程任务的平均耗时。</p>
 
-<p>完成一个进程任务的时间指进程的<code>'end' 时间戳</code> 减去&nbsp;<code>'start' 时间戳</code>. 平均耗时通过计算每台机器上所有进程任务的总耗费时间除以机器上的总进程数量获得.</p>
+<p>完成一个进程任务的时间指进程的<code>'end' 时间戳</code> 减去&nbsp;<code>'start' 时间戳</code>。平均耗时通过计算每台机器上所有进程任务的总耗费时间除以机器上的总进程数量获得。</p>
 
-<p>结果表必须包含<code>machine_id（机器ID）</code> 和对应的&nbsp;<strong>average time（平均耗时）</strong>&nbsp;别名&nbsp;<code>processing_time</code>, 且<strong>四舍五入保留3位小数.</strong></p>
+<p>结果表必须包含<code>machine_id（机器ID）</code> 和对应的&nbsp;<strong>average time（平均耗时）</strong>&nbsp;别名&nbsp;<code>processing_time</code>，且<strong>四舍五入保留3位小数。</strong></p>
 
 <p>以 <strong>任意顺序</strong> 返回表。</p>
 
diff --git a/solution/1600-1699/1661.Average Time of Process per Machine/README_EN.md b/solution/1600-1699/1661.Average Time of Process per Machine/README_EN.md
index 02cfd7d0fcf39..2084f6d10ee63 100644
--- a/solution/1600-1699/1661.Average Time of Process per Machine/README_EN.md	
+++ b/solution/1600-1699/1661.Average Time of Process per Machine/README_EN.md	
@@ -16,17 +16,17 @@
 | timestamp      | float   |
 +----------------+---------+
 The table shows the user activities for a factory website.
-(machine_id, process_id, activity_type) is the primary key of this table.
+(machine_id, process_id, activity_type) is the primary key (combination of columns with unique values) of this table.
 machine_id is the ID of a machine.
 process_id is the ID of a process running on the machine with ID machine_id.
-activity_type is an ENUM of type (&#39;start&#39;, &#39;end&#39;).
+activity_type is an ENUM (category) of type (&#39;start&#39;, &#39;end&#39;).
 timestamp is a float representing the current time in seconds.
 &#39;start&#39; means the machine starts the process at the given timestamp and &#39;end&#39; means the machine ends the process at the given timestamp.
 The &#39;start&#39; timestamp will always be before the &#39;end&#39; timestamp for every (machine_id, process_id) pair.</pre>
 
 <p>&nbsp;</p>
 
-<p>There is a factory website that has several machines each running the <strong>same number of processes</strong>. Write an SQL query to find the <strong>average time</strong> each machine takes to complete a process.</p>
+<p>There is a factory website that has several machines each running the <strong>same number of processes</strong>. Write a solution&nbsp;to find the <strong>average time</strong> each machine takes to complete a process.</p>
 
 <p>The time to complete a process is the <code>&#39;end&#39; timestamp</code> minus the <code>&#39;start&#39; timestamp</code>. The average time is calculated by the total time to complete every process on the machine divided by the number of processes that were run.</p>
 
@@ -34,7 +34,7 @@ The &#39;start&#39; timestamp will always be before the &#39;end&#39; timestamp
 
 <p>Return the result table in <strong>any order</strong>.</p>
 
-<p>The query result format is in the following example.</p>
+<p>The result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/1700-1799/1729.Find Followers Count/README.md b/solution/1700-1799/1729.Find Followers Count/README.md
index feea236d6170a..f6c04e30f0eb2 100644
--- a/solution/1700-1799/1729.Find Followers Count/README.md	
+++ b/solution/1700-1799/1729.Find Followers Count/README.md	
@@ -15,12 +15,12 @@
 | user_id     | int  |
 | follower_id | int  |
 +-------------+------+
-(user_id, follower_id) 是这个表的主键。
+(user_id, follower_id) 是这个表的主键（具有唯一值的列的组合）。
 该表包含一个关注关系中关注者和用户的编号，其中关注者关注用户。</pre>
 
 <p>&nbsp;</p>
 
-<p>写出 SQL 语句，对于每一个用户，返回该用户的关注者数量。</p>
+<p>编写解决方案，对于每一个用户，返回该用户的关注者数量。</p>
 
 <p>按&nbsp;<code>user_id</code>&nbsp;的顺序返回结果表。</p>
 
diff --git a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
index 28f57f8953259..93f52d2276df8 100644
--- a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md	
+++ b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md	
@@ -6,20 +6,20 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给你一个无向图，无向图由整数 <code>n</code>  ，表示图中节点的数目，和 <code>edges</code> 组成，其中 <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> 表示 <code>u<sub>i</sub></code> 和 <code>v<sub>i</sub></code><sub> </sub>之间有一条无向边。同时给你一个代表查询的整数数组 <code>queries</code> 。</p>
+<p>给你一个无向图，无向图由整数&nbsp;<code>n</code>&nbsp;&nbsp;，表示图中节点的数目，和&nbsp;<code>edges</code>&nbsp;组成，其中&nbsp;<code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>&nbsp;表示&nbsp;<code>u<sub>i</sub></code> 和&nbsp;<code>v<sub>i</sub></code><sub>&nbsp;</sub>之间有一条无向边。同时给你一个代表查询的整数数组&nbsp;<code>queries</code>&nbsp;。</p>
 
 <p>第 <code>j</code> 个查询的答案是满足如下条件的点对 <code>(a, b)</code> 的数目：</p>
 
 <ul>
-	<li><code>a < b</code></li>
-	<li><code>cnt</code> 是与 <code>a</code> <strong>或者 </strong><code>b</code> 相连的边的数目，且 <code>cnt</code> <strong>严格大于 </strong><code>queries[j]</code> 。</li>
+	<li><code>a &lt; b</code></li>
+	<li><code>cnt</code>&nbsp;是与 <code>a</code>&nbsp;<strong>或者&nbsp;</strong><code>b</code>&nbsp;相连的边的数目，且 <code>cnt</code>&nbsp;<strong>严格大于&nbsp;</strong><code>queries[j]</code>&nbsp;。</li>
 </ul>
 
-<p>请你返回一个数组 <code>answers</code> ，其中 <code>answers.length == queries.length</code> 且 <code>answers[j]</code> 是第 <code>j</code> 个查询的答案。</p>
+<p>请你返回一个数组&nbsp;<code>answers</code>&nbsp;，其中&nbsp;<code>answers.length == queries.length</code> 且&nbsp;<code>answers[j]</code>&nbsp;是第 <code>j</code>&nbsp;个查询的答案。</p>
 
-<p>请注意，图中可能会有 <strong>重复边</strong> 。</p>
+<p>请注意，图中可能会有 <strong>重复边</strong>&nbsp;。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 <img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1700-1799/1782.Count%20Pairs%20Of%20Nodes/images/1614828447-GMnLVg-image.png" style="width: 310px; height: 278px;" />
@@ -27,6 +27,8 @@
 <b>输入：</b>n = 4, edges = [[1,2],[2,4],[1,3],[2,3],[2,1]], queries = [2,3]
 <b>输出：</b>[6,5]
 <b>解释：</b>每个点对中，与至少一个点相连的边的数目如上图所示。
+answers[0] = 6。所有的点对(a, b)中边数和都大于2，故有6个；
+answers[1] = 5。所有的点对(a, b)中除了(3,4)边数等于3，其它点对边数和都大于3，故有5个。
 </pre>
 
 <p><strong>示例 2：</strong></p>
@@ -36,17 +38,17 @@
 <b>输出：</b>[10,10,9,8,6]
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>2 <= n <= 2 * 10<sup>4</sup></code></li>
-	<li><code>1 <= edges.length <= 10<sup>5</sup></code></li>
-	<li><code>1 <= u<sub>i</sub>, v<sub>i</sub> <= n</code></li>
+	<li><code>2 &lt;= n &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= edges.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= u<sub>i</sub>, v<sub>i</sub> &lt;= n</code></li>
 	<li><code>u<sub>i </sub>!= v<sub>i</sub></code></li>
-	<li><code>1 <= queries.length <= 20</code></li>
-	<li><code>0 <= queries[j] < edges.length</code></li>
+	<li><code>1 &lt;= queries.length &lt;= 20</code></li>
+	<li><code>0 &lt;= queries[j] &lt; edges.length</code></li>
 </ul>
 
 ## 解法
diff --git a/solution/2000-2099/2041.Accepted Candidates From the Interviews/README.md b/solution/2000-2099/2041.Accepted Candidates From the Interviews/README.md
index e1284f84ed4e2..856cf6d9073a6 100644
--- a/solution/2000-2099/2041.Accepted Candidates From the Interviews/README.md	
+++ b/solution/2000-2099/2041.Accepted Candidates From the Interviews/README.md	
@@ -17,7 +17,7 @@
 | years_of_exp | int      |
 | interview_id | int      |
 +--------------+----------+
-candidate_id 是这个表的主键。
+candidate_id 是这个表的主键（具有唯一值的列）。
 该表的每一行都表示候选人的姓名、工作年限以及面试 ID 。
 </pre>
 
@@ -33,13 +33,13 @@ candidate_id 是这个表的主键。
 | round_id     | int  |
 | score        | int  |
 +--------------+------+
-(interview_id, round_id）是本表的主键。
+(interview_id, round_id）是本表的主键（具有唯一值的列的组合）。
 本表的每一行都表示一轮面试的分数
 </pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，查询出至少有两年工作经验、且面试分数之和 <strong>严格大于 <code>15</code>&nbsp;</strong>的候选人的 ID<strong> 。</strong></p>
+<p>编写解决方案，找出 <strong>至少有两年</strong> 工作经验、且面试分数之和 <strong>严格大于 <code>15</code>&nbsp;</strong>的候选人的 ID<strong> 。</strong></p>
 
 <p>可以以 <strong>任何顺序 </strong>返回结果表。</p>
 
@@ -47,7 +47,7 @@ candidate_id 是这个表的主键。
 
 <p>&nbsp;</p>
 
-<p><strong>示例：</strong></p>
+<p><strong>示例 1：</strong></p>
 
 <pre>
 <strong>输入：</strong>
diff --git a/solution/2200-2299/2238.Number of Times a Driver Was a Passenger/README.md b/solution/2200-2299/2238.Number of Times a Driver Was a Passenger/README.md
index 9f537b074fcc4..b9aa34341edaa 100644
--- a/solution/2200-2299/2238.Number of Times a Driver Was a Passenger/README.md	
+++ b/solution/2200-2299/2238.Number of Times a Driver Was a Passenger/README.md	
@@ -16,17 +16,17 @@
 | driver_id    | int  |
 | passenger_id | int  |
 +--------------+------+
-ride_id 是该表的主键。
+ride_id 是该表的主键（具有唯一值的列）。
 该表的每一行都包含驾驶员的 ID 和在 ride_id 中乘车的乘客的 ID。
 注意 driver_id != passenger_id。</pre>
 
 <p>&nbsp;</p>
 
-<p>编写一个 SQL 查询，获取每个司机的 ID 和他们作为乘客的次数。</p>
+<p>编写解决方案，获取每个司机的 ID 和他们作为乘客的次数。</p>
 
 <p data-group="1-1">以&nbsp;<strong>任意顺序&nbsp;</strong>返回结果表。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2300-2399/2337.Move Pieces to Obtain a String/README.md b/solution/2300-2399/2337.Move Pieces to Obtain a String/README.md
index 08a313eb7543a..49f5119f90836 100644
--- a/solution/2300-2399/2337.Move Pieces to Obtain a String/README.md	
+++ b/solution/2300-2399/2337.Move Pieces to Obtain a String/README.md	
@@ -19,18 +19,20 @@
 
 <p><strong>示例 1：</strong></p>
 
-<pre><strong>输入：</strong>start = "_L__R__R_", target = "L______RR"
+<pre>
+<strong>输入：</strong>start = "_L__R__R_", target = "L______RR"
 <strong>输出：</strong>true
 <strong>解释：</strong>可以从字符串 start 获得 target ，需要进行下面的移动：
 - 将第一个片段向左移动一步，字符串现在变为 "<strong>L</strong>___R__R_" 。
 - 将最后一个片段向右移动一步，字符串现在变为 "L___R___<strong>R</strong>" 。
-- 将第二个片段向右移动散步，字符串现在变为 "L______<strong>R</strong>R" 。
+- 将第二个片段向右移动三步，字符串现在变为 "L______<strong>R</strong>R" 。
 可以从字符串 start 得到 target ，所以返回 true 。
 </pre>
 
 <p><strong>示例 2：</strong></p>
 
-<pre><strong>输入：</strong>start = "R_L_", target = "__LR"
+<pre>
+<strong>输入：</strong>start = "R_L_", target = "__LR"
 <strong>输出：</strong>false
 <strong>解释：</strong>字符串 start 中的 'R' 片段可以向右移动一步得到 "_<strong>R</strong>L_" 。
 但是，在这一步之后，不存在可以移动的片段，所以无法从字符串 start 得到 target 。
@@ -38,7 +40,8 @@
 
 <p><strong>示例 3：</strong></p>
 
-<pre><strong>输入：</strong>start = "_R", target = "R_"
+<pre>
+<strong>输入：</strong>start = "_R", target = "R_"
 <strong>输出：</strong>false
 <strong>解释：</strong>字符串 start 中的片段只能向右移动，所以无法从字符串 start 得到 target 。</pre>
 
diff --git a/solution/2300-2399/2369.Check if There is a Valid Partition For The Array/README_EN.md b/solution/2300-2399/2369.Check if There is a Valid Partition For The Array/README_EN.md
index 936703d52ef42..74b118d12c424 100644
--- a/solution/2300-2399/2369.Check if There is a Valid Partition For The Array/README_EN.md	
+++ b/solution/2300-2399/2369.Check if There is a Valid Partition For The Array/README_EN.md	
@@ -9,8 +9,8 @@
 <p>We call a partition of the array <strong>valid</strong> if each of the obtained subarrays satisfies <strong>one</strong> of the following conditions:</p>
 
 <ol>
-	<li>The subarray consists of <strong>exactly</strong> <code>2</code> equal elements. For example, the subarray <code>[2,2]</code> is good.</li>
-	<li>The subarray consists of <strong>exactly</strong> <code>3</code> equal elements. For example, the subarray <code>[4,4,4]</code> is good.</li>
+	<li>The subarray consists of <strong>exactly</strong> <code>2,</code> equal elements. For example, the subarray <code>[2,2]</code> is good.</li>
+	<li>The subarray consists of <strong>exactly</strong> <code>3,</code> equal elements. For example, the subarray <code>[4,4,4]</code> is good.</li>
 	<li>The subarray consists of <strong>exactly</strong> <code>3</code> consecutive increasing elements, that is, the difference between adjacent elements is <code>1</code>. For example, the subarray <code>[3,4,5]</code> is good, but the subarray <code>[1,3,5]</code> is not.</li>
 </ol>
 
diff --git a/solution/2300-2399/2394.Employees With Deductions/README.md b/solution/2300-2399/2394.Employees With Deductions/README.md
index 378a78eaeab72..639a9eb349f1a 100644
--- a/solution/2300-2399/2394.Employees With Deductions/README.md	
+++ b/solution/2300-2399/2394.Employees With Deductions/README.md	
@@ -15,7 +15,7 @@
 | employee_id  | int  |
 | needed_hours | int  |
 +--------------+------+
-employee_id 是该表的主键。
+employee_id 是该表具有的唯一值的列。
 每一行都包含员工的 id 和他们获得工资所需的最低工作时数。
 </pre>
 
@@ -31,24 +31,24 @@ employee_id 是该表的主键。
 | in_time     | datetime |
 | out_time    | datetime |
 +-------------+----------+
-(employee_id, in_time, out_time) 是该表的主键。
+(employee_id, in_time, out_time) 是该表的主键（具有唯一值的列的组合）。
 该表的每一行都显示了员工的时间戳。in_time 是员工开始工作的时间，out_time 是员工结束工作的时间。
 所有时间都在 2022 年 10 月。out_time 可以是 in_time 之后的一天，这意味着该员工在午夜之后工作。
 </pre>
 
 <p>&nbsp;</p>
 
-<p>在公司里，每个员工每个月必须工作一定的小时数。员工在工作段中工作。员工工作的小时数可以通过员工在所有工作段中工作的分钟数的总和来计算。每个工作段的分钟数是四舍五入的。</p>
+<p>在公司里，每个员工每个月必须工作一定的小时数。员工在工作段中工作。员工工作的小时数可以通过员工在所有工作段中工作的分钟数的总和来计算。每个工作段的分钟数是向上取整的。</p>
 
 <ul>
 	<li>例如，如果员工在一个时间段中工作了 <code>51</code> 分 <code>2</code> 秒，我们就认为它是 <code>52</code> 分钟。</li>
 </ul>
 
-<p>编写一个 SQL 查询来报告将被开除的员工的 id。换句话说，报告没有工作所需时间的员工的 id。</p>
+<p>编写解决方案来报告将被开除的员工的 id。换句话说，报告没有工作所需时间的员工的 id。</p>
 
 <p data-group="1-1">以 <strong>任意顺序</strong> 返回结果表。</p>
 
-<p>查询结果格式如下所示。</p>
+<p>结果格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2300-2399/2394.Employees With Deductions/README_EN.md b/solution/2300-2399/2394.Employees With Deductions/README_EN.md
index 647df96244725..9cf380b7c7a41 100644
--- a/solution/2300-2399/2394.Employees With Deductions/README_EN.md	
+++ b/solution/2300-2399/2394.Employees With Deductions/README_EN.md	
@@ -13,7 +13,7 @@
 | employee_id  | int  |
 | needed_hours | int  |
 +--------------+------+
-employee_id is the primary key for this table.
+employee_id is column with unique values for this table.
 Each row contains the id of an employee and the minimum number of hours needed for them to work to get their salary.
 </pre>
 
@@ -29,7 +29,7 @@ Each row contains the id of an employee and the minimum number of hours needed f
 | in_time     | datetime |
 | out_time    | datetime |
 +-------------+----------+
-(employee_id, in_time, out_time) is the primary key for this table.
+(employee_id, in_time, out_time) is the primary key (combination of columns with unique values) for this table.
 Each row of this table shows the time stamps for an employee. in_time is the time the employee started to work, and out_time is the time the employee ended work.
 All the times are in October 2022. out_time can be one day after in_time which means the employee worked after the midnight.
 </pre>
@@ -42,11 +42,11 @@ All the times are in October 2022. out_time can be one day after in_time which m
 	<li>For example, if the employee worked for <code>51</code> minutes and <code>2</code> seconds in a session, we consider it <code>52</code> minutes.</li>
 </ul>
 
-<p>Write an SQL query to report the IDs of the employees that will be deducted. In other words, report the IDs of the employees that did not work the needed hours.</p>
+<p>Write a solution to report the IDs of the employees that will be deducted. In other words, report the IDs of the employees that did not work the needed hours.</p>
 
 <p>Return the result table <strong>in any order</strong>.</p>
 
-<p>The query result format is in the following example.</p>
+<p>The&nbsp;result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/2600-2699/2626.Array Reduce Transformation/README.md b/solution/2600-2699/2626.Array Reduce Transformation/README.md
index b40e15e24fcc1..1bc4186f8fa1a 100644
--- a/solution/2600-2699/2626.Array Reduce Transformation/README.md	
+++ b/solution/2600-2699/2626.Array Reduce Transformation/README.md	
@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>请你编写一个函数，它的参数为一个整数数组&nbsp;<code>nums</code>&nbsp;、一个计算函数&nbsp;<code>fn</code>&nbsp;和初始值&nbsp;<font color="#c7254e"><font face="Menlo, Monaco, Consolas, Courier New, monospace"><span style="font-size:12.6px"><span style="background-color:#f9f2f4">init&nbsp;</span></span></font></font>。返回一个数组&nbsp;<strong>归约后 </strong>的值。</p>
+<p>请你编写一个函数，它的参数为一个整数数组&nbsp;<code>nums</code>&nbsp;、一个计算函数&nbsp;<code>fn</code>&nbsp;和初始值<code>init</code>&nbsp;。返回一个数组&nbsp;<strong>归约后 </strong>的值。</p>
 
 <p>你可以定义一个数组&nbsp;<strong>归约后 </strong>的值，然后应用以下操作： <code>val = fn(init, nums[0])</code>&nbsp;， <code>val = fn(val, nums[1])</code>&nbsp;， <code>val = fn(val, nums[2])</code>&nbsp;，<code>...</code>&nbsp;直到数组中的每个元素都被处理完毕。返回 <code>val</code> 的最终值。</p>
 
@@ -42,7 +42,7 @@ fn = function sum(accum, curr) { return accum + curr * curr; }
 init = 100
 <strong>输出：</strong>130
 <strong>解释：</strong>
-初始值为 init=0 。
+初始值为 init=100 。
 (100) + nums[0]^2 = 101
 (101) + nums[1]^2 = 105
 (105) + nums[2]^2 = 114
diff --git a/solution/2600-2699/2686.Immediate Food Delivery III/README.md b/solution/2600-2699/2686.Immediate Food Delivery III/README.md
index 49bd4b392e1d6..8ee1fe0388ab7 100644
--- a/solution/2600-2699/2686.Immediate Food Delivery III/README.md	
+++ b/solution/2600-2699/2686.Immediate Food Delivery III/README.md	
@@ -10,25 +10,25 @@
 
 <pre>
 +-----------------------------+---------+
-| 字段名                       | 类型     |
+| 字段名                       | 类型   |
 +-----------------------------+---------+
 | delivery_id                 | int     |
 | customer_id                 | int     |
 | order_date                  | date    |
 | customer_pref_delivery_date | date    |
 +-----------------------------+---------+
-delivery_id 是该表的主键。
+delivery_id 是该表的具有唯一值的列。
 每一行包含有关向顾客交付食物的信息，顾客在某个日期下订单，并指定了一个首选交付日期（在订单日期当天或之后）。
 </pre>
 
+<p>&nbsp;</p>
+
 <p>如果顾客的首选交付日期与订单日期相同，则该订单称为 <strong>立即交付</strong>&nbsp;，否则称为 <strong>计划交付</strong>&nbsp;。</p>
 
-<p>编写一条 SQL 查询，找出每个唯一的 <code>order_date</code> 中立即交付订单的百分比。<strong>结果保留两位小数</strong>。</p>
+<p>编写解决方案，找出每个唯一的 <code>order_date</code> 中立即交付订单的百分比。<strong>结果保留两位小数</strong>。</p>
 
 <p>返回查询结果并按 <code>order_date</code> <strong>升序</strong> 排序。</p>
 
-<p>&nbsp;</p>
-
 <p>查询结果的格式如下所示。</p>
 
 <p>&nbsp;</p>
diff --git a/solution/2600-2699/2686.Immediate Food Delivery III/README_EN.md b/solution/2600-2699/2686.Immediate Food Delivery III/README_EN.md
index 13980e9f4e8c7..6827cace5702d 100644
--- a/solution/2600-2699/2686.Immediate Food Delivery III/README_EN.md	
+++ b/solution/2600-2699/2686.Immediate Food Delivery III/README_EN.md	
@@ -15,17 +15,17 @@
 | order_date                  | date    |
 | customer_pref_delivery_date | date    |
 +-----------------------------+---------+
-delivery_id is the primary key of this table.
+delivery_id is the column with unique values of this table.
 Each row contains information about food delivery to a customer that makes an order at some date and specifies a preferred delivery date (on the order date or after it).
 </pre>
 
 <p>If the customer&#39;s preferred delivery date is the same as the order date, then the order is called <strong>immediate,</strong>&nbsp;otherwise, it is <strong>scheduled</strong>.</p>
 
-<p>Write an SQL query to find the percentage of immediate orders on each unique&nbsp;<code>order_date</code>, <strong>rounded to 2 decimal places</strong>.&nbsp;</p>
+<p>Write a solution&nbsp;to find the percentage of immediate orders on each unique&nbsp;<code>order_date</code>, <strong>rounded to 2 decimal places</strong>.&nbsp;</p>
 
 <p>Return <em>the result table ordered by</em> <code>order_date</code> <em>in <strong>ascending</strong> order.</em></p>
 
-<p>The query result format is in the following example.</p>
+<p>The&nbsp;result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/2600-2699/2688.Find Active Users/README.md b/solution/2600-2699/2688.Find Active Users/README.md
index c68b91628559b..2cdc3123ea6d3 100644
--- a/solution/2600-2699/2688.Find Active Users/README.md	
+++ b/solution/2600-2699/2688.Find Active Users/README.md	
@@ -17,22 +17,16 @@
 | created_at  | datetime |
 | amount      | int      |
 +-------------+----------+
-在这个表中没有主键。该表可能包含重复的记录。
+在这个表可能包含重复的记录。
 每一行包括 user_id、购买的商品、购买日期和购买金额。</pre>
 
-<p>编写一个SQL查询，找出活跃用户。活跃用户是指在其任何一次购买之后的 <strong>七天内</strong>&nbsp;进行了第二次购买的用户。</p>
+<p>编写一个解决方案，找出活跃用户。活跃用户是指在其任何一次购买之后的 <strong>七天内</strong>&nbsp;进行了第二次购买的用户。</p>
 
-<p>&nbsp;</p>
-
-<p>例如，如果结束日期是2023年5月31日，那么在2023年5月31日和2023年6月7日之间（包括这两天）的任何日期都被视为"在7天内"。</p>
-
-<p>&nbsp;</p>
+<p>例如，如果结束日期是 2023年5月31日，那么在 2023年5月31日 和 2023年6月7日之间（包括这两天）的任何日期都被视为"在7天内"。</p>
 
 <p>返回 <strong>任意顺序</strong> 的 <code>user_id</code> 列表，表示活跃用户列表。</p>
 
-<p>&nbsp;</p>
-
-<p>查询结果的格式如下示例：</p>
+<p>结果的格式如下示例：</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2600-2699/2688.Find Active Users/README_EN.md b/solution/2600-2699/2688.Find Active Users/README_EN.md
index bd33d6d850ccc..8dc232d18abe1 100644
--- a/solution/2600-2699/2688.Find Active Users/README_EN.md	
+++ b/solution/2600-2699/2688.Find Active Users/README_EN.md	
@@ -15,17 +15,17 @@
 | created_at  | datetime |
 | amount      | int      |
 +-------------+----------+
-There is no primary key in this table. The table may contain duplicate records. 
+This table may contain duplicate records. 
 Each row includes the user ID, the purchased item, the date of purchase, and the purchase amount.
 </pre>
 
-<p>Write an SQL query that&#39;ll identify active users. An active user is a user that has made a second purchase <strong>within 7&nbsp;days&nbsp;</strong>of any other of their purchases.</p>
+<p>Write a solution to identify active users. An active user is a user that has made a second purchase <strong>within 7&nbsp;days&nbsp;</strong>of any other of their purchases.</p>
 
 <p>For example, if the ending date is May 31, 2023.&nbsp;So any date between May 31, 2023, and June 7, 2023 (inclusive) would be considered &quot;within 7 days&quot; of May 31, 2023.</p>
 
-<p>Return&nbsp;<em>a list of&nbsp;</em><code>user_id</code>&nbsp;<em>which denotes the list of active users&nbsp;in <strong>any order</strong>.</em></p>
+<p>Return&nbsp;a list of&nbsp;<code>user_id</code>&nbsp;which denotes the list of active users&nbsp;in <strong>any order</strong>.</p>
 
-<p>The query result format is in the following example.</p>
+<p>The&nbsp;result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/2700-2799/2726.Calculator with Method Chaining/README.md b/solution/2700-2799/2726.Calculator with Method Chaining/README.md
index 3cf42beba0ae0..e5e242191f0b8 100644
--- a/solution/2700-2799/2726.Calculator with Method Chaining/README.md	
+++ b/solution/2700-2799/2726.Calculator with Method Chaining/README.md	
@@ -26,7 +26,8 @@
 <p><b>示例 1：</b></p>
 
 <pre>
-<b>输入：</b>actions = ["Calculator", "add", "subtract", "getResult"], values = [10, 5, 7]
+<b>输入：</b>actions = ["Calculator", "add", "subtract", "getResult"], 
+values = [10, 5, 7]
 <b>输出：</b>8
 <b>解释：</b>
 new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
@@ -35,7 +36,8 @@ new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
 <p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<b>输入：</b>actions = ["Calculator", "multiply", "power", "getResult"], values = [2, 5, 2]
+<b>输入：</b>actions = ["Calculator", "multiply", "power", "getResult"], 
+values = [2, 5, 2]
 <b>输出：</b>100
 <b>解释：</b>
 new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
@@ -44,7 +46,8 @@ new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
 <p><strong class="example">示例 3：</strong></p>
 
 <pre>
-<b>输入：</b>actions = ["Calculator", "divide", "getResult"], values = [20, 0]
+<b>输入：</b>actions = ["Calculator", "divide", "getResult"], 
+values = [20, 0]
 <b>输出：</b>"Division by zero is not allowed"
 <b>解释：</b>
 new Calculator(20).divide(0).getResult() // 20 / 0 
@@ -57,11 +60,13 @@ new Calculator(20).divide(0).getResult() // 20 / 0
 <p><strong>提示：</strong></p>
 
 <ul>
+	<li><code>actions</code>&nbsp;是一个有效的 JSON 字符串数组</li>
+	<li><code>values</code>&nbsp;是一个有效的 JSON 字符串数组</li>
 	<li><code>2 &lt;= actions.length &lt;= 2 * 10<sup>4</sup></code></li>
-	<li><code>1 &lt;= values.length &lt;= 2 * 10<sup>4</sup></code><code>&nbsp;- 1</code></li>
-	<li><code>actions[i] 是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素</code></li>
-	<li><code><font face="monospace">最后一个操作总是&nbsp;"getResult"</font></code></li>
-	<li><code><font face="monospace">values </font>是一个数字的 JSON 数组</code></li>
+	<li><code>1 &lt;= values.length &lt;= 2 * 10<sup>4</sup>&nbsp;- 1</code></li>
+	<li><code>actions[i]</code>&nbsp;是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素</li>
+	<li>第一个操作总是 "Calculator"</li>
+	<li>最后一个操作总是&nbsp;"getResult"</li>
 </ul>
 
 ## 解法
diff --git a/solution/2700-2799/2726.Calculator with Method Chaining/README_EN.md b/solution/2700-2799/2726.Calculator with Method Chaining/README_EN.md
index 540ce977769ad..f29424b3cd192 100644
--- a/solution/2700-2799/2726.Calculator with Method Chaining/README_EN.md	
+++ b/solution/2700-2799/2726.Calculator with Method Chaining/README_EN.md	
@@ -23,7 +23,9 @@
 <p><strong class="example">Example 1:</strong></p>
 
 <pre>
-<strong>Input:</strong> actions = [&quot;Calculator&quot;, &quot;add&quot;, &quot;subtract&quot;, &quot;getResult&quot;], values = [10, 5, 7]
+<strong>Input:</strong> 
+actions = [&quot;Calculator&quot;, &quot;add&quot;, &quot;subtract&quot;, &quot;getResult&quot;], 
+values = [10, 5, 7]
 <strong>Output:</strong> 8
 <strong>Explanation:</strong> 
 new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
@@ -32,7 +34,9 @@ new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
 <p><strong class="example">Example 2:</strong></p>
 
 <pre>
-<strong>Input:</strong> actions = [&quot;Calculator&quot;, &quot;multiply&quot;, &quot;power&quot;, &quot;getResult&quot;], values = [2, 5, 2]
+<strong>Input:</strong> 
+actions = [&quot;Calculator&quot;, &quot;multiply&quot;, &quot;power&quot;, &quot;getResult&quot;], 
+values = [2, 5, 2]
 <strong>Output:</strong> 100
 <strong>Explanation:</strong> 
 new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
@@ -41,7 +45,9 @@ new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
 <p><strong class="example">Example 3:</strong></p>
 
 <pre>
-<strong>Input:</strong> actions = [&quot;Calculator&quot;, &quot;divide&quot;, &quot;getResult&quot;], values = [20, 0]
+<strong>Input:</strong> 
+actions = [&quot;Calculator&quot;, &quot;divide&quot;, &quot;getResult&quot;], 
+values = [20, 0]
 <strong>Output:</strong> &quot;Division by zero is not allowed&quot;
 <strong>Explanation:</strong> 
 new Calculator(20).divide(0).getResult() // 20 / 0 
@@ -53,11 +59,13 @@ The error should be thrown because we cannot divide by zero.
 <p><strong>Constraints:</strong></p>
 
 <ul>
+	<li><code>actions</code> is a valid JSON array of strings</li>
+	<li><code>values</code>&nbsp;is a valid JSON array of numbers</li>
 	<li><code>2 &lt;= actions.length &lt;= 2 * 10<sup>4</sup></code></li>
 	<li><code>1 &lt;= values.length &lt;= 2 * 10<sup>4</sup>&nbsp;- 1</code></li>
-	<li><code>actions[i] is one of &quot;Calculator&quot;, &quot;add&quot;, &quot;subtract&quot;, &quot;multiply&quot;, &quot;divide&quot;, &quot;power&quot;, and&nbsp;&quot;getResult&quot;</code></li>
-	<li><code><font face="monospace">Last action is always &quot;getResult&quot;</font></code></li>
-	<li><code><font face="monospace">values is a JSON array of numbers</font></code></li>
+	<li><code>actions[i]</code> is one of &quot;Calculator&quot;, &quot;add&quot;, &quot;subtract&quot;, &quot;multiply&quot;, &quot;divide&quot;, &quot;power&quot;, and&nbsp;&quot;getResult&quot;</li>
+	<li>First action is always &quot;Calculator&quot;</li>
+	<li>Last action is always &quot;getResult&quot;</li>
 </ul>
 
 ## Solutions
diff --git a/solution/2700-2799/2738.Count Occurrences in Text/README.md b/solution/2700-2799/2738.Count Occurrences in Text/README.md
index b6850506dfe59..b89f28f80e2e6 100644
--- a/solution/2700-2799/2738.Count Occurrences in Text/README.md	
+++ b/solution/2700-2799/2738.Count Occurrences in Text/README.md	
@@ -15,15 +15,17 @@
 | file_name   | varchar |
 | content     | text    |
 +-------------+---------+
-file_name 为该表的主键。
+file_name 为该表的主键（具有唯一值的列）。
 每行包含 file_name 和该文件的内容。
 </pre>
 
-<p>编写一个 SQL 查询来查找出单词 <strong>'bull' </strong>和 <strong>'bear'</strong> 作为 <strong>独立词</strong> 出现的次数，不考虑任何它出现在两侧没有空格的情况（例如，'bullet',&nbsp;'bears', 'bull.'，或者 'bear'&nbsp;在句首或句尾&nbsp;<strong>不会</strong> 被考虑）。</p>
+<p>&nbsp;</p>
+
+<p>编写解决方案，找出单词 <strong>'bull' </strong>和 <strong>'bear'</strong> 作为 <strong>独立词</strong> 出现的次数，不考虑任何它出现在两侧没有空格的情况（例如，'bullet',&nbsp;'bears', 'bull.'，或者 'bear'&nbsp;在句首或句尾&nbsp;<strong>不会</strong> 被考虑）。</p>
 
 <p>返回单词 'bull' 和 'bear' 以及它们对应的出现次数，<strong>顺序没有限制</strong>&nbsp;。</p>
 
-<p>查询结果的格式如下所示：</p>
+<p>结果的格式如下所示：</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2700-2799/2748.Number of Beautiful Pairs/README.md b/solution/2700-2799/2748.Number of Beautiful Pairs/README.md
index 86cd2aabe43a0..36f21bb85dd96 100644
--- a/solution/2700-2799/2748.Number of Beautiful Pairs/README.md	
+++ b/solution/2700-2799/2748.Number of Beautiful Pairs/README.md	
@@ -21,10 +21,10 @@
 <strong>输出：</strong>5
 <strong>解释：</strong>nums 中共有 5 组美丽下标对：
 i = 0 和 j = 1 ：nums[0] 的第一个数字是 2 ，nums[1] 的最后一个数字是 5 。2 和 5 互质，因此 gcd(2,5) == 1 。
-i = 0 和 j = 2 ：nums[0] 的第一个数字是 2 ，nums[1] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(2,1) == 1 。
-i = 1 和 j = 2 ：nums[0] 的第一个数字是 5 ，nums[1] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(5,1) == 1 。
-i = 1 和 j = 3 ：nums[0] 的第一个数字是 5 ，nums[1] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(5,4) == 1 。
-i = 2 和 j = 3 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(1,4) == 1 。
+i = 0 和 j = 2 ：nums[0] 的第一个数字是 2 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(2,1) == 1 。
+i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(5,1) == 1 。
+i = 1 和 j = 3 ：nums[1] 的第一个数字是 5 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(5,4) == 1 。
+i = 2 和 j = 3 ：nums[2] 的第一个数字是 1 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(1,4) == 1 。
 因此，返回 5 。
 </pre>
 
@@ -35,7 +35,7 @@ i = 2 和 j = 3 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数
 <strong>输出：</strong>2
 <strong>解释：</strong>共有 2 组美丽下标对：
 i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1 。gcd(1,1) == 1 。
-i = 0 和 j = 2 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 2 。gcd(1,2) == 1 。
+i = 0 和 j = 2 ：nums[0] 的第一个数字是 1 ，nums[2] 的最后一个数字是 2 。gcd(1,2) == 1 。
 因此，返回 2 。</pre>
 
 <p>&nbsp;</p>
diff --git a/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README.md b/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README.md
index 00647f4ba50f3..bf8a54cc6f108 100644
--- a/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README.md	
+++ b/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README.md	
@@ -17,15 +17,15 @@
 | transaction_date | date |
 | amount           | int  |
 +------------------+------+
-transaction_id 是这个表的主键。 
+transaction_id 是这个表的具有唯一值的列。 
 每行包含有关交易的信息，包括唯一的（customer_id，transaction_date）以及相应的 customer_id 和 amount。
 </pre>
 
-<p>编写一个 SQL 查询，找到连续天数上进行了最多交易的所有 <code>customer_id</code> 。</p>
+<p>编写一个解决方案，找到连续天数上进行了最多交易的所有 <code>customer_id</code> 。</p>
 
 <p>返回所有具有最大连续交易次数的 <code>customer_id</code> 。结果表按 <code>customer_id</code> 的 <strong>升序</strong> 排序。</p>
 
-<p>查询结果的格式如下所示。</p>
+<p>结果的格式如下所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README_EN.md b/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README_EN.md
index 0aa47586d3908..d2ab16d2ccc2c 100644
--- a/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README_EN.md	
+++ b/solution/2700-2799/2752.Customers with Maximum Number of Transactions on Consecutive Days/README_EN.md	
@@ -15,15 +15,15 @@
 | transaction_date | date |
 | amount           | int  |
 +------------------+------+
-transaction_id is the primary key of this table.
+transaction_id is the column with unique values of this table.
 Each row contains information about transactions that includes unique (customer_id, transaction_date) along with the corresponding customer_id and amount.   
 </pre>
 
-<p>Write an SQL query to find all&nbsp;<code>customer_id</code>&nbsp;who made the maximum number of transactions on consecutive days.</p>
+<p>Write a solution to find all&nbsp;<code>customer_id</code>&nbsp;who made the maximum number of transactions on consecutive days.</p>
 
-<p>Return <em>all</em> <code>customer_id</code>&nbsp;<em>with the maximum number of consecutive transactions.&nbsp;</em><em>Order the result table by</em>&nbsp;<code>customer_id</code> <em>in <strong>ascending</strong> order.</em></p>
+<p>Return all <code>customer_id</code>&nbsp;with the maximum number of consecutive transactions.&nbsp;Order the result table by&nbsp;<code>customer_id</code> in <strong>ascending</strong> order.</p>
 
-<p>The query result format is in the following example.</p>
+<p>The&nbsp;result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/2700-2799/2781.Length of the Longest Valid Substring/README.md b/solution/2700-2799/2781.Length of the Longest Valid Substring/README.md
index a1ad26b7ceba8..93fc59945fda6 100644
--- a/solution/2700-2799/2781.Length of the Longest Valid Substring/README.md	
+++ b/solution/2700-2799/2781.Length of the Longest Valid Substring/README.md	
@@ -18,14 +18,16 @@
 
 <p><strong>示例 1：</strong></p>
 
-<pre><b>输入：</b>word = "cbaaaabc", forbidden = ["aaa","cb"]
+<pre>
+<b>输入：</b>word = "cbaaaabc", forbidden = ["aaa","cb"]
 <b>输出：</b>4
-<b>解释：</b>总共有 9 个合法子字符串："c" ，"b" ，"a" ，"ba" ，"aa" ，"bc" ，"baa" ，"aab" 和 "aabc" 。最长合法子字符串的长度为 4 。
+<b>解释：</b>总共有 11 个合法子字符串："c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" 和 "aabc"。最长合法子字符串的长度为 4 。
 其他子字符串都要么包含 "aaa" ，要么包含 "cb" 。</pre>
 
 <p><strong>示例 2：</strong></p>
 
-<pre><b>输入：</b>word = "leetcode", forbidden = ["de","le","e"]
+<pre>
+<b>输入：</b>word = "leetcode", forbidden = ["de","le","e"]
 <strong>输出：</strong>4
 <b>解释：</b>总共有 11 个合法子字符串："l" ，"t" ，"c" ，"o" ，"d" ，"tc" ，"co" ，"od" ，"tco" ，"cod" 和 "tcod" 。最长合法子字符串的长度为 4 。
 所有其他子字符串都至少包含 "de" ，"le" 和 "e" 之一。
diff --git a/solution/2700-2799/2781.Length of the Longest Valid Substring/README_EN.md b/solution/2700-2799/2781.Length of the Longest Valid Substring/README_EN.md
index 8d8b46fc2acee..fe8fe3a470e73 100644
--- a/solution/2700-2799/2781.Length of the Longest Valid Substring/README_EN.md	
+++ b/solution/2700-2799/2781.Length of the Longest Valid Substring/README_EN.md	
@@ -18,7 +18,7 @@
 <pre>
 <strong>Input:</strong> word = &quot;cbaaaabc&quot;, forbidden = [&quot;aaa&quot;,&quot;cb&quot;]
 <strong>Output:</strong> 4
-<strong>Explanation:</strong> There are 11 valid substrings in word: &quot;c&quot;, &quot;b&quot;, &quot;a&quot;, &quot;ba&quot;, &quot;aa&quot;, &quot;bc&quot;, &quot;baa&quot;, &quot;aab&quot;, &quot;ab&quot;, &quot;abc&quot;and &quot;aabc&quot;. The length of the longest valid substring is 4. 
+<strong>Explanation:</strong> There are 11 valid substrings in word: &quot;c&quot;, &quot;b&quot;, &quot;a&quot;, &quot;ba&quot;, &quot;aa&quot;, &quot;bc&quot;, &quot;baa&quot;, &quot;aab&quot;, &quot;ab&quot;, &quot;abc&quot; and &quot;aabc&quot;. The length of the longest valid substring is 4. 
 It can be shown that all other substrings contain either &quot;aaa&quot; or &quot;cb&quot; as a substring. </pre>
 
 <p><strong class="example">Example 2:</strong></p>
diff --git a/solution/2700-2799/2783.Flight Occupancy and Waitlist Analysis/README.md b/solution/2700-2799/2783.Flight Occupancy and Waitlist Analysis/README.md
index 4e52dc95de7eb..29be9268cc412 100644
--- a/solution/2700-2799/2783.Flight Occupancy and Waitlist Analysis/README.md	
+++ b/solution/2700-2799/2783.Flight Occupancy and Waitlist Analysis/README.md	
@@ -15,7 +15,7 @@
 | flight_id   | int  |
 | capacity    | int  |
 +-------------+------+
-flight_id 是该表的主键。 
+flight_id 是该表中具有唯一值的列。 
 该表的每一行包含航班ID和它的座位容量。
 </pre>
 
@@ -28,17 +28,17 @@ flight_id 是该表的主键。
 | passenger_id | int  |
 | flight_id    | int  |
 +--------------+------+
-passenger_id 是该表的主键列。 
+passenger_id 是该表中具有唯一值的列。
 该表的每一行包含乘客ID和航班ID。
 </pre>
 
 <p>乘客提前预订航班机票。如果乘客预订了某个航班的机票，并且该航班还有空座位，乘客的机票将会得到 <strong>确认</strong> 。然而，如果航班已经满员，乘客将会进入 <strong>等待名单</strong> 。</p>
 
-<p>编写一条 SQL 查询，报告每个航班已成功预订（获得座位）的乘客数以及处于等待名单上的乘客数。</p>
+<p>编写解决方案，报告每个航班已成功预订（获得座位）的乘客数以及处于等待名单上的乘客数。</p>
 
-<p>按照航班 id 升序排序返回结果表。</p>
+<p>按照 <code>flight_id</code> <strong>升序排序&nbsp;</strong>返回结果表。</p>
 
-<p>查询结果格式如下例所示。</p>
+<p>结果格式如下例所示。</p>
 
 <p>&nbsp;</p>
 
diff --git a/solution/2700-2799/2793.Status of Flight Tickets/README.md b/solution/2700-2799/2793.Status of Flight Tickets/README.md
index 021038219c3c9..28312b2e02a67 100644
--- a/solution/2700-2799/2793.Status of Flight Tickets/README.md	
+++ b/solution/2700-2799/2793.Status of Flight Tickets/README.md	
@@ -15,7 +15,7 @@
 | flight_id   | int  |
 | capacity    | int  |
 +-------------+------+
-flight_id 是该表的主键列。 
+flight_id 列包含不同的值。
 每行包含航班 id 和座位容量。
 </pre>
 
@@ -29,14 +29,14 @@ flight_id 是该表的主键列。
 | flight_id    | int      |
 | booking_time | datetime |
 +--------------+----------+
-passenger_id 是该表的主键。 
+passenger_id 包含不同的值。
 booking_time 包含不同的值。
 每行包含乘客 id、预订时间和所预订的航班 id。
 </pre>
 
 <p>乘客提前预订航班机票。如果乘客预订了一张航班机票，并且航班上还有空座位，则乘客的机票将 <strong>得到确认</strong> 。然而，如果航班已经满员，乘客将被列入 <strong>等候名单</strong> 。</p>
 
-<p>编写一个 SQL 查询来确定每个乘客航班机票的当前状态。</p>
+<p>编写解决方案来确定每个乘客航班机票的当前状态。</p>
 
 <p>按 <code>passenger_id</code> <strong>升序排序&nbsp;</strong>返回结果表。</p>
 
diff --git a/solution/2700-2799/2793.Status of Flight Tickets/README_EN.md b/solution/2700-2799/2793.Status of Flight Tickets/README_EN.md
index 8d6d83dda557b..66ba7717460f2 100644
--- a/solution/2700-2799/2793.Status of Flight Tickets/README_EN.md	
+++ b/solution/2700-2799/2793.Status of Flight Tickets/README_EN.md	
@@ -13,7 +13,7 @@
 | flight_id   | int  |
 | capacity    | int  |
 +-------------+------+
-<code>flight_id</code> is the primary key column for this table.
+<code>flight_id</code> column contains distinct values.
 Each row of this table contains flight id and capacity.
 </pre>
 
@@ -27,18 +27,18 @@ Each row of this table contains flight id and capacity.
 | flight_id    | int      |
 | booking_time | datetime |
 +--------------+----------+
-passenger_id is the primary key column for this table.
+passenger_id column contains distinct values.
 booking_time column contains distinct values.
 Each row of this table contains passenger id, booking time, and their flight id.
 </pre>
 
 <p>Passengers book tickets for flights in advance. If a passenger books a ticket for a flight and there are still empty seats available on the flight, the passenger&#39;s ticket will be <strong>confirmed</strong>. However, the passenger will be on a <strong>waitlist</strong> if the flight is already at full capacity.</p>
 
-<p>Write an SQL query to determine the current status of flight tickets for each passenger.</p>
+<p>Write a solution to determine the current status of flight tickets for each passenger.</p>
 
-<p>Return <em>the result table ordered by</em> <code>passenger_id</code> <em>in <strong>ascending order</strong>.</em></p>
+<p>Return the result table ordered by <code>passenger_id</code> <em>in <strong>ascending order</strong>.</em></p>
 
-<p>The query result format is in the following example.</p>
+<p>The result format is in the following example.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README.md b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README.md
new file mode 100644
index 0000000000000..59eb79dbcff1a
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README.md	
@@ -0,0 +1,246 @@
+# [2832. Maximal Range That Each Element Is Maximum in It](https://leetcode.cn/problems/maximal-range-that-each-element-is-maximum-in-it)
+
+[English Version](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of <b>distinct </b>integers.</p>
+
+<p>Let us define a <strong>0-indexed </strong>array <code>ans</code> of the same length as <code>nums</code> in the following way:</p>
+
+<ul>
+	<li><code>ans[i]</code> is the <strong>maximum</strong> length of a subarray <code>nums[l..r]</code>, such that the maximum element in that subarray is equal to <code>nums[i]</code>.</li>
+</ul>
+
+<p>Return<em> the array </em><code>ans</code>.</p>
+
+<p><strong>Note</strong> that a <strong>subarray</strong> is a contiguous part of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,5,4,3,6]
+<strong>Output:</strong> [1,4,2,1,5]
+<strong>Explanation:</strong> For nums[0] the longest subarray in which 1 is the maximum is nums[0..0] so ans[0] = 1.
+For nums[1] the longest subarray in which 5 is the maximum is nums[0..3] so ans[1] = 4.
+For nums[2] the longest subarray in which 4 is the maximum is nums[2..3] so ans[2] = 2.
+For nums[3] the longest subarray in which 3 is the maximum is nums[3..3] so ans[3] = 1.
+For nums[4] the longest subarray in which 6 is the maximum is nums[0..4] so ans[4] = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> [1,2,3,4,5]
+<strong>Explanation:</strong> For nums[i] the longest subarray in which it&#39;s the maximum is nums[0..i] so ans[i] = i + 1.
+</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>5</sup></code></li>
+	<li>All elements in <code>nums</code> are distinct.</li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+**方法一：单调栈**
+
+本题属于单调栈的模板题，我们只需要利用单调栈，求出每个元素 $nums[i]$ 左边和右边第一个比它大的元素的位置，分别记为 $left[i]$ 和 $right[i]$，那么 $nums[i]$ 作为最大值的区间长度就是 $right[i] - left[i] - 1$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+class Solution:
+    def maximumLengthOfRanges(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        left = [-1] * n
+        right = [n] * n
+        stk = []
+        for i, x in enumerate(nums):
+            while stk and nums[stk[-1]] <= x:
+                stk.pop()
+            if stk:
+                left[i] = stk[-1]
+            stk.append(i)
+        stk = []
+        for i in range(n - 1, -1, -1):
+            while stk and nums[stk[-1]] <= nums[i]:
+                stk.pop()
+            if stk:
+                right[i] = stk[-1]
+            stk.append(i)
+        return [r - l - 1 for l, r in zip(left, right)]
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+class Solution {
+    public int[] maximumLengthOfRanges(int[] nums) {
+        int n = nums.length;
+        int[] left = new int[n];
+        int[] right = new int[n];
+        Arrays.fill(left, -1);
+        Arrays.fill(right, n);
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                left[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        stk.clear();
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                right[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> maximumLengthOfRanges(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> left(n, -1);
+        vector<int> right(n, n);
+        stack<int> stk;
+        for (int i = 0; i < n; ++i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                left[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        stk = stack<int>();
+        for (int i = n - 1; ~i; --i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                right[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        vector<int> ans(n);
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func maximumLengthOfRanges(nums []int) []int {
+	n := len(nums)
+	left := make([]int, n)
+	right := make([]int, n)
+	for i := range left {
+		left[i] = -1
+		right[i] = n
+	}
+	stk := []int{}
+	for i, x := range nums {
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			left[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	stk = []int{}
+	for i := n - 1; i >= 0; i-- {
+		x := nums[i]
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			right[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	ans := make([]int, n)
+	for i := range ans {
+		ans[i] = right[i] - left[i] - 1
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function maximumLengthOfRanges(nums: number[]): number[] {
+    const n = nums.length;
+    const left: number[] = Array(n).fill(-1);
+    const right: number[] = Array(n).fill(n);
+    const stk: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            left[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    stk.length = 0;
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            right[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    return left.map((l, i) => right[i] - l - 1);
+}
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README_EN.md b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README_EN.md
new file mode 100644
index 0000000000000..03fb6810d4ce0
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/README_EN.md	
@@ -0,0 +1,232 @@
+# [2832. Maximal Range That Each Element Is Maximum in It](https://leetcode.com/problems/maximal-range-that-each-element-is-maximum-in-it)
+
+[中文文档](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README.md)
+
+## Description
+
+<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of <b>distinct </b>integers.</p>
+
+<p>Let us define a <strong>0-indexed </strong>array <code>ans</code> of the same length as <code>nums</code> in the following way:</p>
+
+<ul>
+	<li><code>ans[i]</code> is the <strong>maximum</strong> length of a subarray <code>nums[l..r]</code>, such that the maximum element in that subarray is equal to <code>nums[i]</code>.</li>
+</ul>
+
+<p>Return<em> the array </em><code>ans</code>.</p>
+
+<p><strong>Note</strong> that a <strong>subarray</strong> is a contiguous part of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,5,4,3,6]
+<strong>Output:</strong> [1,4,2,1,5]
+<strong>Explanation:</strong> For nums[0] the longest subarray in which 1 is the maximum is nums[0..0] so ans[0] = 1.
+For nums[1] the longest subarray in which 5 is the maximum is nums[0..3] so ans[1] = 4.
+For nums[2] the longest subarray in which 4 is the maximum is nums[2..3] so ans[2] = 2.
+For nums[3] the longest subarray in which 3 is the maximum is nums[3..3] so ans[3] = 1.
+For nums[4] the longest subarray in which 6 is the maximum is nums[0..4] so ans[4] = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> [1,2,3,4,5]
+<strong>Explanation:</strong> For nums[i] the longest subarray in which it&#39;s the maximum is nums[0..i] so ans[i] = i + 1.
+</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>5</sup></code></li>
+	<li>All elements in <code>nums</code> are distinct.</li>
+</ul>
+
+## Solutions
+
+<!-- tabs:start -->
+
+### **Python3**
+
+```python
+class Solution:
+    def maximumLengthOfRanges(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        left = [-1] * n
+        right = [n] * n
+        stk = []
+        for i, x in enumerate(nums):
+            while stk and nums[stk[-1]] <= x:
+                stk.pop()
+            if stk:
+                left[i] = stk[-1]
+            stk.append(i)
+        stk = []
+        for i in range(n - 1, -1, -1):
+            while stk and nums[stk[-1]] <= nums[i]:
+                stk.pop()
+            if stk:
+                right[i] = stk[-1]
+            stk.append(i)
+        return [r - l - 1 for l, r in zip(left, right)]
+```
+
+### **Java**
+
+```java
+class Solution {
+    public int[] maximumLengthOfRanges(int[] nums) {
+        int n = nums.length;
+        int[] left = new int[n];
+        int[] right = new int[n];
+        Arrays.fill(left, -1);
+        Arrays.fill(right, n);
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                left[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        stk.clear();
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                right[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> maximumLengthOfRanges(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> left(n, -1);
+        vector<int> right(n, n);
+        stack<int> stk;
+        for (int i = 0; i < n; ++i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                left[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        stk = stack<int>();
+        for (int i = n - 1; ~i; --i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                right[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        vector<int> ans(n);
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func maximumLengthOfRanges(nums []int) []int {
+	n := len(nums)
+	left := make([]int, n)
+	right := make([]int, n)
+	for i := range left {
+		left[i] = -1
+		right[i] = n
+	}
+	stk := []int{}
+	for i, x := range nums {
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			left[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	stk = []int{}
+	for i := n - 1; i >= 0; i-- {
+		x := nums[i]
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			right[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	ans := make([]int, n)
+	for i := range ans {
+		ans[i] = right[i] - left[i] - 1
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function maximumLengthOfRanges(nums: number[]): number[] {
+    const n = nums.length;
+    const left: number[] = Array(n).fill(-1);
+    const right: number[] = Array(n).fill(n);
+    const stk: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            left[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    stk.length = 0;
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            right[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    return left.map((l, i) => right[i] - l - 1);
+}
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.cpp b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.cpp
new file mode 100644
index 0000000000000..ad58daac8969b
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.cpp	
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    vector<int> maximumLengthOfRanges(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> left(n, -1);
+        vector<int> right(n, n);
+        stack<int> stk;
+        for (int i = 0; i < n; ++i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                left[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        stk = stack<int>();
+        for (int i = n - 1; ~i; --i) {
+            while (!stk.empty() && nums[stk.top()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                right[i] = stk.top();
+            }
+            stk.push(i);
+        }
+        vector<int> ans(n);
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.go b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.go
new file mode 100644
index 0000000000000..8ed2778108edb
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.go	
@@ -0,0 +1,35 @@
+func maximumLengthOfRanges(nums []int) []int {
+	n := len(nums)
+	left := make([]int, n)
+	right := make([]int, n)
+	for i := range left {
+		left[i] = -1
+		right[i] = n
+	}
+	stk := []int{}
+	for i, x := range nums {
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			left[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	stk = []int{}
+	for i := n - 1; i >= 0; i-- {
+		x := nums[i]
+		for len(stk) > 0 && nums[stk[len(stk)-1]] <= x {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			right[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	ans := make([]int, n)
+	for i := range ans {
+		ans[i] = right[i] - left[i] - 1
+	}
+	return ans
+}
\ No newline at end of file
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.java b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.java
new file mode 100644
index 0000000000000..81f7235c0fc5b
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.java	
@@ -0,0 +1,34 @@
+class Solution {
+    public int[] maximumLengthOfRanges(int[] nums) {
+        int n = nums.length;
+        int[] left = new int[n];
+        int[] right = new int[n];
+        Arrays.fill(left, -1);
+        Arrays.fill(right, n);
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                left[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        stk.clear();
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && nums[stk.peek()] <= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                right[i] = stk.peek();
+            }
+            stk.push(i);
+        }
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = right[i] - left[i] - 1;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.py b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.py
new file mode 100644
index 0000000000000..51c69e539cb20
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.py	
@@ -0,0 +1,20 @@
+class Solution:
+    def maximumLengthOfRanges(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        left = [-1] * n
+        right = [n] * n
+        stk = []
+        for i, x in enumerate(nums):
+            while stk and nums[stk[-1]] <= x:
+                stk.pop()
+            if stk:
+                left[i] = stk[-1]
+            stk.append(i)
+        stk = []
+        for i in range(n - 1, -1, -1):
+            while stk and nums[stk[-1]] <= nums[i]:
+                stk.pop()
+            if stk:
+                right[i] = stk[-1]
+            stk.append(i)
+        return [r - l - 1 for l, r in zip(left, right)]
diff --git a/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.ts b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.ts
new file mode 100644
index 0000000000000..002cdb187e2e0
--- /dev/null
+++ b/solution/2800-2899/2832.Maximal Range That Each Element Is Maximum in It/Solution.ts	
@@ -0,0 +1,26 @@
+function maximumLengthOfRanges(nums: number[]): number[] {
+    const n = nums.length;
+    const left: number[] = Array(n).fill(-1);
+    const right: number[] = Array(n).fill(n);
+    const stk: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            left[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    stk.length = 0;
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && nums[stk.at(-1)] <= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            right[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+    return left.map((l, i) => right[i] - l - 1);
+}
diff --git a/solution/CONTEST_README.md b/solution/CONTEST_README.md
index 52906c21d5dc9..6533ae47c9344 100644
--- a/solution/CONTEST_README.md
+++ b/solution/CONTEST_README.md
@@ -22,7 +22,7 @@
 
 ## 往期竞赛
 
-#### 第 359 场周赛(2023-08-20 10:30, 90 分钟) 参赛人数 4097
+#### 第 359 场周赛(2023-08-20 10:30, 90 分钟) 参赛人数 4101
 
 - [2828. 判别首字母缩略词](/solution/2800-2899/2828.Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words/README.md)
 - [2829. k-avoiding 数组的最小总和](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README.md)
diff --git a/solution/README.md b/solution/README.md
index c05510b08b492..1625d3ee2275b 100644
--- a/solution/README.md
+++ b/solution/README.md
@@ -2647,7 +2647,7 @@
 |  2634  |  [过滤数组中的元素](/solution/2600-2699/2634.Filter%20Elements%20from%20Array/README.md)  |    |  简单  |    |
 |  2635  |  [转换数组中的每个元素](/solution/2600-2699/2635.Apply%20Transform%20Over%20Each%20Element%20in%20Array/README.md)  |    |  简单  |    |
 |  2636  |  [Promise 对象池](/solution/2600-2699/2636.Promise%20Pool/README.md)  |    |  中等  |  🔒  |
-|  2637  |  [有时间限制的 Promise 对象](/solution/2600-2699/2637.Promise%20Time%20Limit/README.md)  |    |  简单  |    |
+|  2637  |  [有时间限制的 Promise 对象](/solution/2600-2699/2637.Promise%20Time%20Limit/README.md)  |    |  中等  |    |
 |  2638  |  [统计 K-Free 子集的总数](/solution/2600-2699/2638.Count%20the%20Number%20of%20K-Free%20Subsets/README.md)  |  `数组`,`动态规划`,`排序`  |  中等  |  🔒  |
 |  2639  |  [查询网格图中每一列的宽度](/solution/2600-2699/2639.Find%20the%20Width%20of%20Columns%20of%20a%20Grid/README.md)  |  `数组`,`矩阵`  |  简单  |  第 102 场双周赛  |
 |  2640  |  [一个数组所有前缀的分数](/solution/2600-2699/2640.Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array/README.md)  |  `数组`,`前缀和`  |  中等  |  第 102 场双周赛  |
@@ -2834,14 +2834,15 @@
 |  2821  |  [延迟每个 Promise 对象的解析](/solution/2800-2899/2821.Delay%20the%20Resolution%20of%20Each%20Promise/README.md)  |    |  简单  |  🔒  |
 |  2822  |  [对象反转](/solution/2800-2899/2822.Inversion%20of%20Object/README.md)  |    |  简单  |  🔒  |
 |  2823  |  [深度对象筛选](/solution/2800-2899/2823.Deep%20Object%20Filter/README.md)  |    |  中等  |  🔒  |
-|  2824  |  [统计和小于目标的下标对数目](/solution/2800-2899/2824.Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target/README.md)  |    |  简单  |  第 111 场双周赛  |
-|  2825  |  [循环增长使字符串子序列等于另一个字符串](/solution/2800-2899/2825.Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments/README.md)  |    |  中等  |  第 111 场双周赛  |
-|  2826  |  [将三个组排序](/solution/2800-2899/2826.Sorting%20Three%20Groups/README.md)  |    |  中等  |  第 111 场双周赛  |
-|  2827  |  [范围中美丽整数的数目](/solution/2800-2899/2827.Number%20of%20Beautiful%20Integers%20in%20the%20Range/README.md)  |    |  困难  |  第 111 场双周赛  |
-|  2828  |  [判别首字母缩略词](/solution/2800-2899/2828.Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words/README.md)  |    |  简单  |  第 359 场周赛  |
-|  2829  |  [k-avoiding 数组的最小总和](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README.md)  |    |  中等  |  第 359 场周赛  |
-|  2830  |  [销售利润最大化](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README.md)  |    |  中等  |  第 359 场周赛  |
-|  2831  |  [找出最长等值子数组](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README.md)  |    |  中等  |  第 359 场周赛  |
+|  2824  |  [统计和小于目标的下标对数目](/solution/2800-2899/2824.Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target/README.md)  |  `数组`,`双指针`,`排序`  |  简单  |  第 111 场双周赛  |
+|  2825  |  [循环增长使字符串子序列等于另一个字符串](/solution/2800-2899/2825.Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments/README.md)  |  `双指针`,`字符串`  |  中等  |  第 111 场双周赛  |
+|  2826  |  [将三个组排序](/solution/2800-2899/2826.Sorting%20Three%20Groups/README.md)  |  `数组`,`动态规划`  |  中等  |  第 111 场双周赛  |
+|  2827  |  [范围中美丽整数的数目](/solution/2800-2899/2827.Number%20of%20Beautiful%20Integers%20in%20the%20Range/README.md)  |  `数学`,`动态规划`  |  困难  |  第 111 场双周赛  |
+|  2828  |  [判别首字母缩略词](/solution/2800-2899/2828.Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words/README.md)  |  `数组`,`字符串`  |  简单  |  第 359 场周赛  |
+|  2829  |  [k-avoiding 数组的最小总和](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README.md)  |  `贪心`,`数学`  |  中等  |  第 359 场周赛  |
+|  2830  |  [销售利润最大化](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README.md)  |  `数组`,`二分查找`,`动态规划`,`排序`  |  中等  |  第 359 场周赛  |
+|  2831  |  [找出最长等值子数组](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README.md)  |  `数组`,`哈希表`,`二分查找`,`滑动窗口`  |  中等  |  第 359 场周赛  |
+|  2832  |  [Maximal Range That Each Element Is Maximum in It](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README.md)  |    |  中等  |  🔒  |
 
 ## 版权
 
diff --git a/solution/README_EN.md b/solution/README_EN.md
index 753e85c734714..c8350cfa6b441 100644
--- a/solution/README_EN.md
+++ b/solution/README_EN.md
@@ -2645,7 +2645,7 @@ Press <kbd>Control</kbd>+<kbd>F</kbd>(or <kbd>Command</kbd>+<kbd>F</kbd> on the
 |  2634  |  [Filter Elements from Array](/solution/2600-2699/2634.Filter%20Elements%20from%20Array/README_EN.md)  |    |  Easy  |    |
 |  2635  |  [Apply Transform Over Each Element in Array](/solution/2600-2699/2635.Apply%20Transform%20Over%20Each%20Element%20in%20Array/README_EN.md)  |    |  Easy  |    |
 |  2636  |  [Promise Pool](/solution/2600-2699/2636.Promise%20Pool/README_EN.md)  |    |  Medium  |  🔒  |
-|  2637  |  [Promise Time Limit](/solution/2600-2699/2637.Promise%20Time%20Limit/README_EN.md)  |    |  Easy  |    |
+|  2637  |  [Promise Time Limit](/solution/2600-2699/2637.Promise%20Time%20Limit/README_EN.md)  |    |  Medium  |    |
 |  2638  |  [Count the Number of K-Free Subsets](/solution/2600-2699/2638.Count%20the%20Number%20of%20K-Free%20Subsets/README_EN.md)  |  `Array`,`Dynamic Programming`,`Sorting`  |  Medium  |  🔒  |
 |  2639  |  [Find the Width of Columns of a Grid](/solution/2600-2699/2639.Find%20the%20Width%20of%20Columns%20of%20a%20Grid/README_EN.md)  |  `Array`,`Matrix`  |  Easy  |  Biweekly Contest 102  |
 |  2640  |  [Find the Score of All Prefixes of an Array](/solution/2600-2699/2640.Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array/README_EN.md)  |  `Array`,`Prefix Sum`  |  Medium  |  Biweekly Contest 102  |
@@ -2832,14 +2832,15 @@ Press <kbd>Control</kbd>+<kbd>F</kbd>(or <kbd>Command</kbd>+<kbd>F</kbd> on the
 |  2821  |  [Delay the Resolution of Each Promise](/solution/2800-2899/2821.Delay%20the%20Resolution%20of%20Each%20Promise/README_EN.md)  |    |  Easy  |  🔒  |
 |  2822  |  [Inversion of Object](/solution/2800-2899/2822.Inversion%20of%20Object/README_EN.md)  |    |  Easy  |  🔒  |
 |  2823  |  [Deep Object Filter](/solution/2800-2899/2823.Deep%20Object%20Filter/README_EN.md)  |    |  Medium  |  🔒  |
-|  2824  |  [Count Pairs Whose Sum is Less than Target](/solution/2800-2899/2824.Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target/README_EN.md)  |    |  Easy  |  Biweekly Contest 111  |
-|  2825  |  [Make String a Subsequence Using Cyclic Increments](/solution/2800-2899/2825.Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments/README_EN.md)  |    |  Medium  |  Biweekly Contest 111  |
-|  2826  |  [Sorting Three Groups](/solution/2800-2899/2826.Sorting%20Three%20Groups/README_EN.md)  |    |  Medium  |  Biweekly Contest 111  |
-|  2827  |  [Number of Beautiful Integers in the Range](/solution/2800-2899/2827.Number%20of%20Beautiful%20Integers%20in%20the%20Range/README_EN.md)  |    |  Hard  |  Biweekly Contest 111  |
-|  2828  |  [Check if a String Is an Acronym of Words](/solution/2800-2899/2828.Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words/README_EN.md)  |    |  Easy  |  Weekly Contest 359  |
-|  2829  |  [Determine the Minimum Sum of a k-avoiding Array](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README_EN.md)  |    |  Medium  |  Weekly Contest 359  |
-|  2830  |  [Maximize the Profit as the Salesman](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README_EN.md)  |    |  Medium  |  Weekly Contest 359  |
-|  2831  |  [Find the Longest Equal Subarray](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README_EN.md)  |    |  Medium  |  Weekly Contest 359  |
+|  2824  |  [Count Pairs Whose Sum is Less than Target](/solution/2800-2899/2824.Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target/README_EN.md)  |  `Array`,`Two Pointers`,`Sorting`  |  Easy  |  Biweekly Contest 111  |
+|  2825  |  [Make String a Subsequence Using Cyclic Increments](/solution/2800-2899/2825.Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments/README_EN.md)  |  `Two Pointers`,`String`  |  Medium  |  Biweekly Contest 111  |
+|  2826  |  [Sorting Three Groups](/solution/2800-2899/2826.Sorting%20Three%20Groups/README_EN.md)  |  `Array`,`Dynamic Programming`  |  Medium  |  Biweekly Contest 111  |
+|  2827  |  [Number of Beautiful Integers in the Range](/solution/2800-2899/2827.Number%20of%20Beautiful%20Integers%20in%20the%20Range/README_EN.md)  |  `Math`,`Dynamic Programming`  |  Hard  |  Biweekly Contest 111  |
+|  2828  |  [Check if a String Is an Acronym of Words](/solution/2800-2899/2828.Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words/README_EN.md)  |  `Array`,`String`  |  Easy  |  Weekly Contest 359  |
+|  2829  |  [Determine the Minimum Sum of a k-avoiding Array](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README_EN.md)  |  `Greedy`,`Math`  |  Medium  |  Weekly Contest 359  |
+|  2830  |  [Maximize the Profit as the Salesman](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README_EN.md)  |  `Array`,`Binary Search`,`Dynamic Programming`,`Sorting`  |  Medium  |  Weekly Contest 359  |
+|  2831  |  [Find the Longest Equal Subarray](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README_EN.md)  |  `Array`,`Hash Table`,`Binary Search`,`Sliding Window`  |  Medium  |  Weekly Contest 359  |
+|  2832  |  [Maximal Range That Each Element Is Maximum in It](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README_EN.md)  |    |  Medium  |  🔒  |
 
 ## Copyright
 
diff --git a/solution/config.py b/solution/config.py
index fe686be74bc4d..14bfa34b18747 100644
--- a/solution/config.py
+++ b/solution/config.py
@@ -69,7 +69,7 @@
     2111,
     2117,
     2140,
-    2144,
+    2145,
     2178,
     2241,
     2288,
diff --git a/solution/summary.md b/solution/summary.md
index cbd37684d52a3..9996316344983 100644
--- a/solution/summary.md
+++ b/solution/summary.md
@@ -2887,3 +2887,4 @@
   - [2829.k-avoiding 数组的最小总和](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README.md)
   - [2830.销售利润最大化](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README.md)
   - [2831.找出最长等值子数组](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README.md)
+  - [2832.Maximal Range That Each Element Is Maximum in It](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README.md)
diff --git a/solution/summary_en.md b/solution/summary_en.md
index a5010b0ffed77..0f4820998cd0d 100644
--- a/solution/summary_en.md
+++ b/solution/summary_en.md
@@ -2887,3 +2887,4 @@
   - [2829.Determine the Minimum Sum of a k-avoiding Array](/solution/2800-2899/2829.Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array/README_EN.md)
   - [2830.Maximize the Profit as the Salesman](/solution/2800-2899/2830.Maximize%20the%20Profit%20as%20the%20Salesman/README_EN.md)
   - [2831.Find the Longest Equal Subarray](/solution/2800-2899/2831.Find%20the%20Longest%20Equal%20Subarray/README_EN.md)
+  - [2832.Maximal Range That Each Element Is Maximum in It](/solution/2800-2899/2832.Maximal%20Range%20That%20Each%20Element%20Is%20Maximum%20in%20It/README_EN.md)