2020-07-05 16:31:08

docs/array/10.md

@@ -19,7 +19,7 @@ Output : arr[] = [3, 4, 5, 6, 7, 1, 2]
 
 ![ArrayRotation1](img/a0ca29059e52fd48e525698f91766984.png "ArrayRotation1")
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/reversal-algorithm/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/reversal-algorithm/0)
 
 在[这里](https://www.geeksforgeeks.org/array-rotation/)中讨论了通过`d`个元素旋转数组的前 3 种方法。
 

docs/array/100.md

@@ -20,7 +20,7 @@
   Output: -1 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-index/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-index/0)
 
 **方法 1（简单但效率低下）**
 运行两个循环。 在外循环中，从左开始一个接一个地选择元素。 在内部循环中，将拾取的元素与从右侧开始的元素进行比较。 当您看到一个大于选取的元素的元素时，请停止内部循环，并保持当前的最大 j-i 更新。

docs/array/101.md

@@ -27,9 +27,9 @@ generated is 10 10 10 15 15 90 90
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-of-all-subarrays-of-size-k/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-of-all-subarrays-of-size-k/0)
 
-<u>**方法 1**：</u> 这是解决上述问题的简单方法。
+**方法 1**： 这是解决上述问题的简单方法。
 
 *   **方法**：
     这个想法非常基本，它运行一个嵌套循环，外部循环将标记长度为 k 的子数组的起始点，内部循环将从起始索引运行到 index + k ，从起始索引开始，将 k 个元素打印出来，并在这 k 个元素中显示最大元素。
@@ -276,7 +276,7 @@ generated is 10 10 10 15 15 90 90
     *   **空间复杂度**： O（1）。
         不需要多余的空间。
 
-<u>**方法 2**：</u> 此方法使用自平衡 BST 解决给定的问题。
+**方法 2**： 此方法使用自平衡 BST 解决给定的问题。
 
 *   **方法**：
     为了在子数组的 k 个元素中找到最大值，先前的方法使用遍历元素的循环。 为了减少该时间，我们的想法是使用 [AVL 树](https://www.geeksforgeeks.org/avl-tree-set-1-insertion/)，该树返回 log n 时间中的最大元素。 因此，遍历数组并将 k 个元素保留在 BST 中，并在每次迭代中打印最大值。 **AVL 树**是一种合适的数据结构，因为在平均和最坏情况下查找，插入和删除都需要 O（log n）时间，其中 n 是操作之前树中的节点数 。
@@ -652,7 +652,7 @@ generated is 10 10 10 15 15 90 90
     *   **空间复杂度**： O（k）。
         在 BST 中存储 k 个元素所需的空间为 O（k）。
 
-**<u>方法 3：</u>** 此方法使用 Deque 解决上述问题。
+**方法 3：** 此方法使用 Deque 解决上述问题。
 
 *   **方法**：
     创建容量为 k 的[双端队列](https://www.geeksforgeeks.org/deque-set-1-introduction-applications/)， *Qi* ，该存储仅存储 k 个元素的当前窗口的有用元素。 如果一个元素在当前窗口中并且比当前窗口左侧其他元素大，则该元素很有用。 逐一处理所有数组元素，并保持 *Qi* 包含当前窗口的有用元素，并且这些有用元素将按排序的顺序进行维护。 *Qi* 前面的元素是最大的，而 *Qi* 后面的元素是当前窗口的最小元素。 感谢 [Aashish](https://www.geeksforgeeks.org/maximum-of-all-subarrays-of-size-k/#comment-10874) 提出了此方法。
@@ -974,7 +974,7 @@ generated is 10 10 10 15 15 90 90
 *   下面是此问题的扩展：
     [所有大小为 k 的子数组的最小和最大元素的总和。](https://www.geeksforgeeks.org/sum-minimum-maximum-elements-subarrays-size-k/)
 
-<u>**方法 4**：</u> 该方法使用 Max-Heap 解决上述问题。
+**方法 4**： 该方法使用 Max-Heap 解决上述问题。
 
 *   **方法**：
     在上述方法中，其中之一是使用 AVL 树。 该方法与该方法非常相似。 区别在于，此方法将使用 Max-Heap 而不是使用 AVL 树。 当前窗口的元素将存储在“最大堆”中，并且最大元素或根将在每次迭代中打印。

docs/array/102.md

@@ -36,7 +36,7 @@ index 6, so the distance is 1
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-distance-between-two-numbers/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-distance-between-two-numbers/1)
 
 **方法 1**：
 

docs/array/103.md

@@ -22,7 +22,7 @@ Output: 120
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/finding-number/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/finding-number/0)
 
 **方法 1（线性搜索）**
 我们可以遍历数组并跟踪最大值和元素。 最后返回最大元素。

docs/array/105.md

@@ -4,7 +4,7 @@
 
 给定一个随机数数组。 在数组中找到*增长最长的[子序列](http://en.wikipedia.org/wiki/Substring)* （LIS）。 我知道你们中许多人可能已经阅读[递归和动态编程](https://www.geeksforgeeks.org/longest-increasing-subsequence-dp-3/)（DP）解决方案。 论坛帖子中很少有人要求 [O（N log N）](http://en.wikipedia.org/wiki/Longest_increasing_subsequence#Efficient_algorithms)算法。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/longest-increasing-subsequence/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/longest-increasing-subsequence/0)
 
 暂时，无需考虑递归和 DP 解决方案。 让我们抽取少量样本并将解决方案扩展到大型实例。 尽管乍一看可能很复杂，但是一旦我们理解了逻辑，编码就很简单。
 

docs/array/106.md

-# 查找未排序数组中缺失的最小正数| 套装 1
+# 查找未排序数组中缺失的最小正数| 系列 1
 
 > 原文： [https://www.geeksforgeeks.org/find-the-smallest-positive-number-missing-from-an-unsorted-array/](https://www.geeksforgeeks.org/find-the-smallest-positive-number-missing-from-an-unsorted-array/)
 
@@ -18,20 +18,20 @@
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-positive-missing-number/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-positive-missing-number/0)
 
-解决此问题的**天真的方法**是搜索给定数组中从 1 开始的所有正整数。 我们可能必须在给定数组中搜索最多 n + 1 个数字。 因此，在最坏的情况下，此解决方案需要 O（n ^ 2）。
+解决此问题的**朴素的方法**是搜索给定数组中从 1 开始的所有正整数。 我们可能必须在给定数组中搜索最多 n + 1 个数字。 因此，在最坏的情况下，此解决方案需要 O（n ^ 2）。
 
 我们可以使用**排序**来解决，时间复杂度更低。 我们可以在 O（nLogn）时间对数组进行排序。 数组排序后，我们要做的就是对数组进行线性扫描。 因此，此方法需要 O（nLogn + n）时间，即 O（nLogn）。
 
 我们还可以**使用哈希**。 我们可以建立给定数组中所有正元素的哈希表。 一旦建立哈希表。 我们可以在哈希表中查找从 1 开始的所有正整数。一旦我们发现哈希表中不存在的数字，我们就将其返回。 这种方法平均可能需要 O（n）时间，但需要 O（n）额外空间。
 
 **O（n）时间和 O（1）额外空间解决方案**：
-这个想法类似于这个帖子。 我们使用数组元素作为索引。 <u>要标记元素 x 的存在，我们将索引 x 处的值更改为负</u>。 但是，如果存在非正数（-ve 和 0），则此方法无效。 因此，我们首先将正数与负数分开，然后应用该方法。
+这个想法类似于这个帖子。 我们使用数组元素作为索引。 要标记元素 x 的存在，我们将索引 x 处的值更改为负。 但是，如果存在非正数（-ve 和 0），则此方法无效。 因此，我们首先将正数与负数分开，然后应用该方法。
 
 以下是两步算法。
 1）将正数与其他正数分开，即，将所有非正数移到左侧。 在下面的代码中，segregate（）函数完成了这一部分。
-2）现在我们可以忽略非正元素，而只考虑包含所有正元素的数组部分。 我们遍历包含所有正数的数组，并标记元素 x 的存在，我们将索引 x 处的值符号更改为负数。 我们再次遍历数组，然后<u>打印具有正值</u>的第一个索引。 在下面的代码中，findMissingPositive（）函数完成了这一部分。 请注意，在 findMissingPositive 中，由于 C 中的索引从 0 开始，所以我们从值中减去了 1。
+2）现在我们可以忽略非正元素，而只考虑包含所有正元素的数组部分。 我们遍历包含所有正数的数组，并标记元素 x 的存在，我们将索引 x 处的值符号更改为负数。 我们再次遍历数组，然后打印具有正值的第一个索引。 在下面的代码中，findMissingPositive（）函数完成了这一部分。 请注意，在 findMissingPositive 中，由于 C 中的索引从 0 开始，所以我们从值中减去了 1。
 
 ## C++ 
 

docs/array/107.md

@@ -4,21 +4,21 @@
 
 给定大小为 *n* 的数组，该数组包含从 0 到 *k-1* 范围内的数字，其中 *k* 是正整数， *k < = n。* 在此数组中找到最大重复数。 例如，假设 *k* 为 10，则给定数组为 *arr []* = {1,2,2,2,0,2,0,2,3,8 ，0、9、2、3}，最大重复数将为 2。期望的时间复杂度为 *O（n）*，允许的额外空间为 *O（1）*。 允许对数组进行修改。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-repeating-number/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-repeating-number/0)
 
-**天真的方法**是运行两个循环，外循环一个接一个地拾取一个元素，内循环计算被拾取元素的出现次数。 最后返回具有最大计数的元素。 该方法的时间复杂度为 *O（n ^ 2）*。
+**朴素的方法**是运行两个循环，外循环一个接一个地拾取一个元素，内循环计算被拾取元素的出现次数。 最后返回具有最大计数的元素。 该方法的时间复杂度为 *O（n ^ 2）*。
 
 **更好的方法**是创建一个大小为 k 的计数数组，并将 *count []* 的所有元素初始化为 0。对输入数组的所有元素以及每个元素*进行迭代。 arr [i]* ，增量 *count [arr [i]]* 。 最后，迭代 *count []* 并返回具有最大值的索引。 这种方法花费 O（n）时间，但需要 O（k）空间。
 
 以下是 ***O（n）*时间和 *O（1）*额外空间**方法。 让我们用一个简单的例子来理解该方法，其中 *arr []* = {2，3，3，5，3，4，1，1，7}， *k* = 8， *n* = 8（arr []中的元素数）。
 
-**1）**迭代输入数组 *arr []* ，对于每个元素 *arr [i]* ，递增 *arr [arr [i]％k] [ *k* 的*（ *arr []* 变成{2，11，11，29，11，12，1，15}）
+**1）**迭代输入数组 *arr []* ，对于每个元素 *arr [i]* ，递增 *arr [arr [i]% k] [ *k* 的*（ *arr []* 变成{2，11，11，29，11，12，1，15}）
 
 **2）**在修改后的数组中找到最大值（最大值为 29）。 最大值的索引是最大重复元素（索引 29 是 3）。
 
-**3）**如果我们想找回原始数组，可以再遍历该数组一次，并执行 *arr [i] = arr [i]％k* 其中 *i* 从 0 到 *n-1* 变化。
+**3）**如果我们想找回原始数组，可以再遍历该数组一次，并执行 *arr [i] = arr [i]% k* 其中 *i* 从 0 到 *n-1* 变化。
 
-*以上算法如何工作？* 由于我们使用 *arr [i]％k* 作为索引，并在索引 *arr [i]％k* 处添加值 *k* ，因此该索引为 等于最大重复元素最后将具有最大值。 注意， *k* 在等于最大重复元素的索引处被添加最大次数，并且所有数组元素都小于 *k。*
+*以上算法如何工作？* 由于我们使用 *arr [i]% k* 作为索引，并在索引 *arr [i]% k* 处添加值 *k* ，因此该索引为 等于最大重复元素最后将具有最大值。 注意， *k* 在等于最大重复元素的索引处被添加最大次数，并且所有数组元素都小于 *k。*
 
 以下是上述算法的 C++ 实现。
 

docs/array/108.md

@@ -4,7 +4,7 @@
 
 给定大小为 n 的数组，找到数组中出现 n / k 次以上的所有元素。 例如，如果输入数组为{3，1，2，2，1，2，2，3，3}，k 为 4，则输出应为[2，3]。 请注意，数组的大小为 8（或 n = 8），因此我们需要查找所有出现超过 2（或 8/4）次的元素。 有两个元素出现两次以上，即 2 和 3。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-element-occurences/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-element-occurences/1)
 
 **简单方法**是一个接一个地选择所有元素。 对于每个拾取的元素，通过遍历数组来计数它的出现，如果 count 大于 n / k，则打印该元素。 该方法的时间复杂度为 O（n <sup>2</sup> ）。
 

docs/array/11.md

@@ -10,7 +10,7 @@
 
 ![ArrayRotation1](img/a0ca29059e52fd48e525698f91766984.png "ArrayRotation1")
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **算法**：
 

docs/array/110.md

@@ -35,11 +35,11 @@ Explanation: 122 is sum of 1, 5, 7, 8, 10, 12, 15, 30, 34
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-path-in-two-arrays/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-path-in-two-arrays/1)
 
-<u>**有效方法**：</u> 的想法是做类似于[合并排序](http://geeksquiz.com/merge-sort/)的合并过程的操作。 这涉及计算两个数组的所有公共点之间的元素之和。 只要有一个共同点，就比较两个和并将两个的最大值相加。
+**有效方法**： 的想法是做类似于[合并排序](http://geeksquiz.com/merge-sort/)的合并过程的操作。 这涉及计算两个数组的所有公共点之间的元素之和。 只要有一个共同点，就比较两个和并将两个的最大值相加。
 
-<u>**算法**</u> ：
+**算法** ：
 
 1.  创建一些变量，*结果*， *sum1* ， *sum2* 。 将结果初始化为 0。还将两个变量 sum1 和 sum2 初始化为 0。此处，sum1 和 sum2 用于分别将元素的和存储在 ar1 []和 ar2 []中。 这些总和在两个共同点之间。
 2.  现在运行一个循环以遍历两个数组的元素。 遍历时，按以下顺序比较数组 1 和数组 2 的当前元素。
@@ -47,7 +47,7 @@ Explanation: 122 is sum of 1, 5, 7, 8, 10, 12, 15, 30, 34
     2.  如果*数组 1* 和*数组 2* 的当前元素相同，则取 sum1 和 sum2 的最大值，并将其加到结果中。 还将公共元素添加到结果中。
     3.  可以将此步骤与合并两个*排序的*数组进行比较，如果处理了两个当前数组索引中的最小元素，则可以保证如果有任何公共元素，则将它们一起处理。 可以处理两个公共元素之间的元素总和。
 
-**<u>实现</u>**：
+**实现**：
 
 ## C++ 
 

docs/array/112.md

@@ -7,7 +7,7 @@
 难度等级：新秀
 预期时间复杂度：O（n）[仅允许遍历数组一次]
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个问题主要归结为找到数组中最大和第二大元素。 通过遍历数组一次，我们可以找到 O（n）时间中最大和第二大的值。
 

docs/array/113.md

@@ -26,7 +26,7 @@ at index 0 we fill '_'.
 
 询问：Zoho
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-greater-elements-in-whole-array/0/)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-greater-elements-in-whole-array/0/)
 
 **简单解决方案**是使用两个嵌套的循环。 外循环一个接一个地选择所有元素，内循环通过从头到尾线性搜索找到下一个更大的元素。
 

docs/array/114.md

@@ -29,7 +29,7 @@ Explanation : We delete 23, 45 and 11 as they follow
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法**： [堆栈](https://www.geeksforgeeks.org/stack-data-structure-introduction-program/)用于解决此问题。 首先，我们将 arr [0]推入堆栈 S，然后将 count 初始化为 0，然后从 1 遍历到 n，然后检查 s.top（）< arr [i]是否为 true，然后弹出 堆栈中的元素，如果 count == k，则增加计数，然后我们停止循环，然后将堆栈的值存储在另一个数组中，然后打印该数组。
 

docs/array/116.md

@@ -29,7 +29,7 @@ Explanation : We delete 23, 45 and 11 as they follow
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法**： [堆栈](https://www.geeksforgeeks.org/stack-data-structure-introduction-program/)用于解决此问题。 首先，我们将 arr [0]推入堆栈 S，然后将 count 初始化为 0，然后从 1 遍历到 n，然后检查 s.top（）< arr [i]是否为 true，然后弹出 堆栈中的元素，如果 count == k，则增加计数，然后我们停止循环，然后将堆栈的值存储在另一个数组中，然后打印该数组。
 

docs/array/117.md

@@ -31,7 +31,7 @@ all zeroes.
 
 来源： [http://www.careercup.com/question?id=5106425965576192](http://www.careercup.com/question?id=5106425965576192)
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximize-number-of-1s/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximize-number-of-1s/0)
 
 **简单解决方案**是通过运行两个循环来考虑每个子数组。 对于每个子数组，计数其中的零个数。 返回具有 m 个或更少零个的最大大小子数组。 该解决方案的时间复杂度为 O（n <sup>2</sup> ）。
 

docs/array/119.md

@@ -16,7 +16,7 @@ Output:    {_,   _, 10, 11, 20, 40, 50,  50, ...}
 
 允许的额外空间为 O（k）。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/kth-largest-element-in-a-stream/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/kth-largest-element-in-a-stream/0)
 
 在以下文章中，我们讨论了在数组中找到第 k 个最大元素的不同方法。
 [未排序数组中第 K 个最小/最大元素| 集合 1](https://www.geeksforgeeks.org/kth-smallestlargest-element-unsorted-array/)

docs/array/12.md

@@ -12,7 +12,7 @@ Output: arr[] = {5, 1, 2, 3, 4}
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one/0)
 
 以下是步骤。
 1）将最后一个元素存储在变量`x`中。

docs/array/120.md

@@ -20,7 +20,7 @@ from the sequence [1, 2], [1, 4], [1, 6],
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（简单）**
 

docs/array/121.md

@@ -31,7 +31,7 @@ Explanation : group1 = -1-2-3 , group2 = 1+3
 
 *   列印最大值（difference1，difference2）
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 ## C++ 
 

docs/array/122.md

@@ -24,7 +24,7 @@ equal to 4.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **第一种方法：-**该方法是向数组中再添加一个数字 x，直到数组的中位数等于 x。 下面是上述方法的实现：
 

docs/array/123.md

@@ -30,7 +30,7 @@ Element       NGE
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/next-larger-element/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/next-larger-element/0)
 
 **方法 1（简单）**
 使用两个循环：外循环一个接一个地选取所有元素。 内循环为外循环选取的元素寻找第一个更大的元素。 如果找到更大的元素，则该元素将作为下一个被打印，否则将打印-1。

docs/array/125.md

@@ -17,9 +17,9 @@ Output: Sum of arr[] elements in range [0, 4] is 8
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/interesting-queries/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/interesting-queries/0)
 
-**天真的解决方案**将运行从 L 到 R 的循环，并为每个查询[L，R]计算给定范围内的元素总数。
+**朴素的解决方案**将运行从 L 到 R 的循环，并为每个查询[L，R]计算给定范围内的元素总数。
 
 ## C
 

docs/array/126.md

@@ -10,7 +10,7 @@ Sqrt（或平方根）分解技术是竞争程序员使用的最常见的[通用
 
 让我们将这些块或块视为一个单独的数组，每个数组包含 sqrt（n）元素，并且您已经针对所有块分别计算了所需的答案（根据您的问题）。 现在，您需要回答某些查询，询问原始 n 大小数组中范围为 l 到 r（l 和 r 是数组的开始和结束索引）的元素的答案。
 
-**天真的方法**只是简单地遍历范围 l 到 r 中的每个元素，并计算其相应的答案。 因此，每个查询的时间复杂度将为 O（n）。
+**朴素的方法**只是简单地遍历范围 l 到 r 中的每个元素，并计算其相应的答案。 因此，每个查询的时间复杂度将为 O（n）。
 
 **Sqrt 分解技巧**：由于我们已经预先计算了所有单个数据块的答案，现在我们需要回答范围 l 到 r 的查询。 现在，我们可以简单地组合原始数组中介于 l 到 r 之间的块的答案。 因此，如果我们在这里仔细观察，我们将一次跳过 sqrt（n）步，而不是像幼稚的方法那样一次跳过 1 步。 让我们考虑以下问题来分析其时间复杂度和实施：-
 

docs/array/128.md

@@ -20,7 +20,7 @@ Note : array is 0 based indexed
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 由于没有更新/修改，因此我们使用[稀疏表](http://www.geeksforgeeks.org/sparse-table/)有效地回答查询。 在稀疏表中，我们以 2 的幂来分解查询。
 

docs/array/13.md

@@ -21,7 +21,7 @@ Output : Found at index 3
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/search-in-a-rotated-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/search-in-a-rotated-array/0)
 
 **此处提供的所有解决方案均假定数组中的所有元素都是不同的。**
 

docs/array/130.md

@@ -16,7 +16,7 @@ The element 6 appears 1 time in arr[left-1..right-1]
 
 ```
 
-**天真的方法**：是从左到右遍历并在找到元素时更新计数变量。
+**朴素的方法**：是从左到右遍历并在找到元素时更新计数变量。
 
 以下是朴素方法的代码：-
 

docs/array/131.md

@@ -18,7 +18,7 @@ Which is the final updated array.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 可以使用[段树并在每个查询的 O（log N）时间中使用](https://www.geeksforgeeks.org/lazy-propagation-in-segment-tree/)延迟更新来解决此问题，但是由于没有给出更新操作，因此我们可以在这里做得更好。 我们可以使用此逻辑在恒定时间内处理每个查询，当在范围[a，b]中给出添加 V 的查询时，如果需要，我们现在将 V 添加到 arr [a]，将–V 添加到 arr [b + 1] 为了获得数组的实际值，我们将上面的数组转换为前缀和数组。 请参阅以下示例以了解，
 

docs/array/132.md

@@ -26,7 +26,7 @@ Explanation : In the first query LCM(5, 2, 10, 12) = 60,
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/range-lcm-queries/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/range-lcm-queries/1)
 
 一个简单的解决方案是遍历每个查询的数组，并使用
 LCM（a，b）=（a * b）/ GCD（a，b）计算答案

docs/array/133.md

@@ -13,7 +13,7 @@ Output: GCDs of given ranges are 3, 10, 1
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（简单）**
 

docs/array/134.md

@@ -21,7 +21,7 @@ equal to first element = 2
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **注意**：在下面的说明中，我们使用基于 1 的索引
 

docs/array/135.md

@@ -21,7 +21,7 @@ Number of elements less than or equal to
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **朴素方法**每个查询的朴素方法遍历子数组并计算给定范围内的元素数。
 

docs/array/136.md

@@ -31,7 +31,7 @@ and similarly other queries are answered
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 我们在下面的文章中讨论了仅处理 count（）查询的解决方案。 [在给定子数组](https://www.geeksforgeeks.org/number-elements-less-equal-given-number-given-subarray/)中小于或等于给定数目的元素数
 

docs/array/137.md

@@ -19,7 +19,7 @@ The numbers are: 9 10 for second query
 
 **来源**： [亚马逊面试体验](https://www.geeksforgeeks.org/amazon-interview-experience-set-359-on-campus/)
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单方法**将运行 for 循环，以检查每个元素是否在给定范围内并保持其计数。 运行每个查询的时间复杂度为 O（n）。
 

docs/array/138.md

@@ -23,7 +23,7 @@ Output : 7
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单解决方案**使用简单的二进制到十进制转换为每个给定范围计算十进制值。 这里每个查询花费 O（len）时间，其中 len 是范围的长度。
 

docs/array/139.md

@@ -30,7 +30,7 @@ Output: 1
 
 ```
 
-**天真的方法**：针对每个查询从范围 L-R 进行迭代，并检查索引 i 处的给定元素是否将范围中的所有数字相除。 我们对所有元素进行计数，将所有数字相除。 在最坏情况下，每个查询的复杂度将为 **O（n <sup>2</sup> ）**。
+**朴素的方法**：针对每个查询从范围 L-R 进行迭代，并检查索引 i 处的给定元素是否将范围中的所有数字相除。 我们对所有元素进行计数，将所有数字相除。 在最坏情况下，每个查询的复杂度将为 **O（n <sup>2</sup> ）**。
 
 **以下是朴素方法的实现**：
 

docs/array/14.md

@@ -21,7 +21,7 @@ There is no pair with sum 45.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 我们已经讨论了用于排序数组的[`O(n)`解（请参见方法 1 的步骤 2、3 和 4）](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)。 我们也可以将此解决方案扩展到旋转数组。 这个想法是首先找到数组中最大的元素，它也是枢轴点，紧随其后的元素是最小的元素。 一旦我们有了最大和最小元素的索引，就可以在中间算法（如方法 1 中的[此处](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)讨论的）中使用类似的 Meet 来查找是否存在一对。 唯一的新变化是使用模块化算法以循环方式递增和递减索引。
 

docs/array/140.md

@@ -18,7 +18,7 @@ Output : 2147483629
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法**：每个元素和 X 的二进制表示，我们可以观察到每个位都是独立的，并且可以通过迭代每个位来解决问题。 现在基本上，对于每个位，我们都需要计算给定范围内的 1 和 0 的数量，如果 1 的数量更多，则必须将 X 的该位设置为 0，以便在 x 或 x 之后用 x 取最大，否则 0 的数量更多，那么您必须将 X 的该位设置为 1。如果 1 和 0 的数量相等，那么我们可以将 X 的该位设置为 1 或 0 中的任何一个，因为这不会影响总和，但是 我们必须最小化 X 的值，因此我们将使用该位 0。
 

docs/array/142.md

@@ -49,7 +49,7 @@ Output : 2
 1.  查询 1 的类型为 1：如上所述，在给定索引为 1 和 1 的情况下，我们将简单地将数组索引加 1，因此在执行第一个数组后，我们的数组将变为 1。
 2.  查询 2 的类型为 1：如上所述，在给定索引为 1 和 1 的情况下，我们将简单地将数组索引增加 1，因此在执行第一个数组后，我们的数组将变为 2。 这给了我们想要的结果
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1**：
 此方法是蛮力方法，其中对 2 类查询应用简单递归，对 1 类查询执行简单的数组索引增量。

docs/array/144.md

@@ -29,7 +29,7 @@ subarray from start to end
 > 在查询 5 中，元素 3 在子数组[3、3、3]中发生三次。
 > 在查询 6 中，元素 1 在子数组[1、2、2、3、3、3]中发生一次，2 发生两次，3 发生三次
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（蛮力）**
 计算每个查询下子数组中每个元素的频率。 如果在每个查询覆盖的子数组中任何数字 x 的频率为 x，我们将增加计数器。

docs/array/146.md

@@ -27,9 +27,9 @@ Output : 2
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-**天真的方法**是从 L 遍历到 R（不包括 R）并计算满足条件 A <sub>i</sub> = A <sub>i + 1</sub> 的索引 i 的数量 分别针对每个查询。
+**朴素的方法**是从 L 遍历到 R（不包括 R）并计算满足条件 A <sub>i</sub> = A <sub>i + 1</sub> 的索引 i 的数量 分别针对每个查询。
 
 以下是幼稚方法的实现：
 

docs/array/147.md

@@ -28,7 +28,7 @@ smallest number in the range
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 关键思想是构建一个[分段树](https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/)，每个节点上都有一个向量，并且该向量按排序顺序包含子范围的所有元素。 而且，如果我们观察到这种段树结构，则该结构与[合并排序算法](https://www.geeksforgeeks.org/merge-sort/)期间形成的树类似（这就是为什么将其称为合并排序树的原因）
 

docs/array/148.md

@@ -23,7 +23,7 @@ Output : 90
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **蛮力**
 

docs/array/149.md

@@ -29,7 +29,7 @@ After update, A[] becomes {20, 35, 70, 60}.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 一个**简单解决方案**要执行以下操作：
 

docs/array/150.md

@@ -25,7 +25,7 @@ For q3, 1 ⊕ 7 ⊕ 0 ⊕ 8 ⊕ 1 = 15
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 让我们观察 **arr []**
 

docs/array/151.md

@@ -28,9 +28,9 @@ so subarray is not in the form above stated
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mountain-subarray-problem/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mountain-subarray-problem/1)
 
-**<u>解决方案：</u>**
+**解决方案：**
 
 *   **方法**：该问题有多个查询，因此对于每个查询，应以尽可能少的时间复杂性来计算解决方案。 因此，请为原始数组增加两个额外的空格。 对于每个元素，找到左侧的最后一个索引，该索引增加（即大于前一个元素），找到右侧的元素，将在右侧存储第一个索引，该索引递减（即大于其下一个元素）。 如果可以在恒定时间内为每个索引计算这些值，那么对于每个给定范围，可以在恒定时间内给出答案。
 *   **算法**：

docs/array/152.md

@@ -21,7 +21,7 @@ Output : 15
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单解决方案**是为每个查询计算总和。
 

docs/array/153.md

@@ -27,7 +27,7 @@ In Query 3, the subarray [0...4]
 has 4 primes viz. {2, 3, 7}
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（蛮力）**
 在此处可以找到类似的问题。 这里没有更新，我们可以对其进行修改以处理更新，但是为此，我们总是在执行更新时需要构建前缀数组，这会使这种方法的时间复杂度为 O（Q * N）

docs/array/154.md

@@ -20,7 +20,7 @@ Output : odd
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这里要注意的重要一点是，二进制形式的所有奇数均以 1 作为其最右边的位，所有偶数均以 0 作为其最右边的位。
 原因很简单，除了最右边的位以外，所有其他位都具有偶数，偶数之和始终为偶数。现在，最右边的位可以具有 1 或 0 的值，因为我们知道偶数+奇数=奇数，因此当最右边的位 为 1 时，数字为奇数；为 0 时，数字为偶数。

docs/array/156.md

@@ -26,9 +26,9 @@ Output : 7
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mean-of-range-in-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mean-of-range-in-array/0)
 
-**天真的方法**：我们可以为每个查询 l 到 r 运行循环，并找到范围内元素的总和和数量。 此后，我们可以为每个查询打印均值下限。
+**朴素的方法**：我们可以为每个查询 l 到 r 运行循环，并找到范围内元素的总和和数量。 此后，我们可以为每个查询打印均值下限。
 
 ## C++ 
 

docs/array/157.md

@@ -24,7 +24,7 @@ Third command: Add 1 from index 2 to 5
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单方法**是通过从左索引（l）到右索引（r）进行迭代来执行每个命令，并根据给定命令更新每个索引。 该方法的时间复杂度为 O（n * m）
 

docs/array/158.md

@@ -33,7 +33,7 @@ which is 1/2.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个想法是要维护两个数组，即 even []和 odd []，以保持偶数或奇数元素的数目直到索引 i。 现在，为了回答每个查询，我们可以通过查找给定查询范围内的元素数来计算结果分母 q。 为了找到结果分子，我们从直到 r 的元素中删除了直到 l – 1 的元素数。
 要以最小形式输出答案，我们找到 p 和 q 的 GCD 并输出 p / gcd 和 q / gcd。 对于答案 0 和 1，我们将明确指定条件。

docs/array/159.md

@@ -16,7 +16,7 @@ Output : 7
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **蛮力**
 

docs/array/16.md

-# 给定数组所有旋转中 i * arr [i]的最大和
+# 给定数组所有旋转中`i * arr [i]`的最大和
 
 > 原文： [https://www.geeksforgeeks.org/maximum-sum-iarri-among-rotations-given-array/](https://www.geeksforgeeks.org/maximum-sum-iarri-among-rotations-given-array/)
 
-给定 n 个整数的数组 arr []，找到使 i * arr [i]的值的总和最大化的最大值，其中 i 从 0 到 n-1 变化。
+给定`n`个整数的数组`arr[]`，找到使`i * arr [i]`的值的总和最大化的最大值，其中`i`从 0 到`n-1`变化。
 
 **示例**：
 
@@ -24,12 +24,12 @@ Explanation: Lets look at all the rotations,
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-in-the-configuration/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-in-the-configuration/1)
 
-**<u>方法 1</u> **：此方法讨论**天真溶液**，该过程花费 O（n <sup>2</sup> ）的时间。
+**方法 1 **：此方法讨论**朴素溶液**，该过程花费`O(n^2)`的时间。
 解决方案涉及找到每次旋转中数组所有元素的总和，然后确定最大总和值。
 
-*   **方法**：一个简单的解决方案是尝试所有可能的旋转。 计算每次旋转的 i * arr [i]之和，并返回最大和。
+*   **方法**：一个简单的解决方案是尝试所有可能的旋转。 计算每次旋转的`i * arr[i]`之和，并返回最大和。
 *   **算法**：
     1.  将所有值从 0 旋转到 n 的数组。
     2.  计算每次旋转的总和。
@@ -301,14 +301,14 @@ Explanation: Lets look at all the rotations,
     ```
 
 *   **复杂度分析**：
-    *   **时间复杂度**： O（n <sup>2</sup> ）
-    *   **辅助空间**： O（1）
+    *   **时间复杂度**： `O(n^2)`
+    *   **辅助空间**： `O(1)`
 
-**<u>方法 2</u> **：此方法讨论了解决**有效解决方案**的问题，该解决方案可解决 O（n）时间问题。 在天真的解决方案中，将为每个旋转计算值。 因此，如果可以在恒定时间内完成操作，那么复杂度将降低。
+**方法 2 **：此方法讨论了解决**有效解决方案**的问题，该解决方案可解决`O(n)`时间问题。 在朴素的解决方案中，将为每个旋转计算值。 因此，如果可以在恒定时间内完成操作，那么复杂度将降低。
 
 *   **方法**：基本方法是从以前的旋转中计算新旋转的总和。 这样就产生了相似性，其中只有第一个元素和最后一个元素的乘数急剧变化，而其他元素的乘数则增加或减少 1。因此，可以从当前旋转的总和中计算出下一个旋转的总和。
 *   **算法**：
-    这个想法是使用先前旋转的值来计算旋转的值。 当数组旋转 1 时，i * arr [i]之和发生以下变化。
+    这个想法是使用先前旋转的值来计算旋转的值。 当数组旋转 1 时，`i * arr[i]`之和发生以下变化。
 
     ```
     next_val = curr_val - (cum_sum - arr[i-1]) + arr[i-1] * (n-1);
@@ -323,9 +323,9 @@ Explanation: Lets look at all the rotations,
 
     ```
 
-    1.  arr [i-1]的乘数从 0 变为 n-1，即 arr [i-1] *（n-1）被加到当前值。
-    2.  其他项的乘数减 1。即，从 cum_sum 是所有数字之和的当前值减去（cum_sum – arr [i-1]）。
-*   **<u>实现</u>**：
+    1.  `arr[i-1]`的乘数从 0 变为`n-1`，即`arr[i-1] * (n-1)`被加到当前值。
+    2.  其他项的乘数减 1。即，从`cum_sum`是所有数字之和的当前值减去（`cum_sum – arr[i-1]`）。
+*   **实现**：
 
     ## C++ 
 
@@ -613,16 +613,16 @@ Explanation: Lets look at all the rotations,
     ```
 
 *   **复杂度分析**：
-    *   **时间复杂度**： O（n）。
-        由于需要从 0 到 n 的一个循环来检查所有旋转，并且当前旋转的总和是根据 *O（1）*时间中的先前旋转计算得出的）。
-    *   **辅助空间**： O（1）。
-        由于不需要额外的空间，因此空间复杂度将为 *O（1）*
+    *   **时间复杂度**： `O(n)`。
+        由于需要从 0 到 n 的一个循环来检查所有旋转，并且当前旋转的总和是根据`O(1)`时间中的先前旋转计算得出的）。
+    *   **辅助空间**： `O(1)`。
+        由于不需要额外的空间，因此空间复杂度将为`O(1)`
 
-**<u>方法 3</u> **：该方法讨论使用 O（n）时间中的枢轴的解决方案。 透视方法只能在排序数组或旋转排序数组的情况下使用。 例如：{1、2、3、4}或{2、3、4、1}，{3、4、1、2}等。
+**方法 3 **：该方法讨论使用`O(n)`时间中的枢轴的解决方案。 透视方法只能在排序数组或旋转排序数组的情况下使用。 例如：`{1, 2, 3, 4}`或`{2, 3, 4, 1}`，`{3, 4, 1, 2}`等。
 
 *   **方法**：假设是排序数组的情况。 如我们所知，对于数组，最大和是将数组按升序排序。 在旋转数组排序的情况下，我们可以旋转数组以使其升序排列。 因此，在这种情况下，需要找到枢轴元素，然后才能计算出最大和。
 *   **算法**：
-    1.  **查找数组**的枢轴：如果 arr [i] > arr [（i + 1）％n]，则它是枢轴元素。 （i + 1）％n 用于检查最后一个和第一个元素。
+    1.  **查找数组**的枢轴：如果`arr[i] > arr[(i + 1) % n]`，则它是枢轴元素。`(i + 1) % n`用于检查最后一个和第一个元素。
     2.  获得枢轴后，可以通过找到与枢轴的差（即乘数）并将其与当前元素相乘，同时计算总和来计算总和
 *   **实现**：
 
@@ -956,10 +956,10 @@ Explanation: Lets look at all the rotations,
     ```
 
 *   **复杂度分析**：
-    *   **时间复杂度**： O（n）
-        因为只需要一个循环就可以从 0 遍历到 n，从而找到枢轴。 为了找到总和，需要另一个循环，因此复杂度保持为 **O（n）**。
-    *   **辅助空间**： O（1）。
-        我们不需要额外的空间，因此辅助空间为 *O（1）*
+    *   **时间复杂度**： `O(n)`
+        因为只需要一个循环就可以从 0 遍历到 n，从而找到枢轴。 为了找到总和，需要另一个循环，因此复杂度保持为`O(n)`。
+    *   **辅助空间**：`O(1)`。
+        我们不需要额外的空间，因此辅助空间为`O(1)`
 
 本文由 **Shubham Joshi** 提供。 如果您喜欢 GeeksforGeeks 并希望做出贡献，则还可以使用 [tribution.geeksforgeeks.org](http://www.contribute.geeksforgeeks.org) 撰写文章，或将您的文章邮寄至 tribution@geeksforgeeks.org。 查看您的文章出现在 GeeksforGeeks 主页上，并帮助其他 Geeks。
 

docs/array/160.md

@@ -19,7 +19,7 @@ For the second query, answer is 2 {5, 7}.
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-primes-in-range/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-primes-in-range/0)
 
 一个**简单解决方案**是为每个查询[L，R]执行以下操作。 从 L 遍历到 R，[检查当前数字是否为素数](https://www.geeksforgeeks.org/prime-numbers/)。 如果是，则增加计数。 最后返回计数。
 

docs/array/161.md

@@ -23,9 +23,9 @@ Output : Resultant array = {1, 1, 1, 1, 1}
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-**天真的方法**：对于给定的 N，我们应该创建一个 n + 1 个元素的布尔数组，对于 M 个命令中的每一个，我们都必须从 a 迭代到 b，并借助 a 来切换 a 到 b 范围内的所有元素 XOR。
+**朴素的方法**：对于给定的 N，我们应该创建一个 n + 1 个元素的布尔数组，对于 M 个命令中的每一个，我们都必须从 a 迭代到 b，并借助 a 来切换 a 到 b 范围内的所有元素 XOR。
 此方法的复杂度为 O（n ^ 2）。
 
 ```

docs/array/162.md

@@ -5,7 +5,7 @@
 给定一组任意时间间隔的时间，将所有重叠的时间间隔合并为一个，并输出仅具有互斥时间间隔的结果。 为了简单起见，将间隔表示为整数对。
 例如，让给定的间隔集为{{1,3}，{2,4}，{5,7}，{6,8}}。 间隔{1,3}和{2,4}彼此重叠，因此应将它们合并并成为{1，4}。 同样，{5，7}和{6，8}应该合并并成为{5，8}
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/overlapping-intervals/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/overlapping-intervals/0)
 
 编写一个函数，该函数为给定间隔集生成合并间隔集。
 
@@ -203,7 +203,7 @@ Output:
 
 该方法的时间复杂度是 O（nLogn），用于排序。 对间隔数组进行排序后，合并将花费线性时间。
 
-<u>**O（n Log n）和 O（1）额外空间解决方案**</u>
+**O（n Log n）和 O（1）额外空间解决方案**
 上述解决方案需要 O（n）额外的堆栈空间。 通过就地进行合并操作，我们可以避免使用额外的空间。 以下是详细步骤。
 
 ```

docs/array/164.md

@@ -29,9 +29,9 @@ Output : 30
 是更新操作，因此 A <sub>3</sub> 将保持为 1，A <sub>4</sub> 将变为 4。 A <sub>5</sub> 将变为 2。
 第四个查询将得出 A <sub>4</sub> = 4。
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-**天真的方法**：
+**朴素的方法**：
 一个简单的解决方案是运行一个从 l 到 r 的循环，并计算给定范围内的元素之和。 要更新值，请预先计算每个数字的除数的值，然后简单地做 arr [i] = divisors [arr [i]]。
 
 **高效方法**：

docs/array/165.md

@@ -33,9 +33,9 @@ previously modified array.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-**天真的方法**：对于每个查询，遍历**开始**到**结束**范围内的数组，并将该范围内的值增加给定值 **d** 。
+**朴素的方法**：对于每个查询，遍历**开始**到**结束**范围内的数组，并将该范围内的值增加给定值 **d** 。
 
 **有效方法**：创建大小为 **n** 的数组 **sum []** 并将其所有索引初始化为 0。现在，对于每个**（开始， end）**索引对在 **sum []** 数组上应用给定的运算。 仅当存在索引**（end + 1）**时，操作才是 **sum [start] + = d** 和 **sum [end + 1]-= d** 。 现在，从索引 **i** = 1 到 n-1，将 **sum []** 数组中的值累加为： **sum [i] + = sum [i-1 ]** 。 最后，对于索引 **i** = 0 到 n-1，执行以下操作： **arr [i] + = sum [i]** 。
 

docs/array/166.md

@@ -21,7 +21,7 @@ Output : 1
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个想法是预先计算数组的最大奇数除数，并将其存储在数组中，例如 preXOR []。 现在，预先计算并存储数组 preXOR []的前缀 XOR。 要回答每个查询，请返回（preXOR [r] xor preXOR [l-1]）。
 

docs/array/167.md

@@ -24,7 +24,7 @@ in a[2..4] is 3 (1, 2, 3)
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个想法是使用[二叉索引树](https://www.geeksforgeeks.org/binary-indexed-tree-or-fenwick-tree-2/)
 

docs/array/168.md

@@ -19,7 +19,7 @@ Output : Total number of 1's in range 2 to 3 is = 1
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 针对此问题的一种**简单解决方案**是遍历“切换”查询的完整范围，当您获得“计数”查询时，然后为给定范围计算所有 1。 但是这种方法的时间复杂度将是 O（q * n），其中 q =查询总数。
 

docs/array/169.md

@@ -22,7 +22,7 @@ Output: Minimum = 1 and Maximum = 9
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单解决方案**：我们为每个查询使用[竞赛方法](https://www.geeksforgeeks.org/maximum-and-minimum-in-an-array/)解决了此问题。 此方法的复杂度将为 O（查询* n）。
 

docs/array/17.md

@@ -21,7 +21,7 @@ Output: 0
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/rotation/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/rotation/0)
 
 **方法 1（使用[线性搜索](http://quiz.geeksforgeeks.org/linear-search/)）**
 

docs/array/171.md

@@ -6,7 +6,7 @@
 
 ![kadane-algorithm](img/b18443fe347f743a54fda310276891fb.png)
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/kadanes-algorithm/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/kadanes-algorithm/0)
 
 **Kadane 的算法**：
 

docs/array/172.md

@@ -26,7 +26,7 @@ Output:  0
 Not possible to earn.
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单解决方案**是考虑每个索引“ i”，然后执行以下操作
 

docs/array/174.md

@@ -36,7 +36,7 @@ index 6, so the distance is 1
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-distance-between-two-numbers/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-distance-between-two-numbers/1)
 
 **方法 1**：
 

docs/array/175.md

@@ -43,7 +43,7 @@ arr[] = {3, 4, 5}
 
 来源： [Adob​​e 面试体验| 设置 24（MTS 校园内）](https://www.geeksforgeeks.org/adobe-interview-experience-set-24-on-campus-for-mts/)
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimize-the-heights/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimize-the-heights/0)
 
 想法是对所有元素按升序进行排序。 对于所有元素，请检查减（element-k）和加（element + k）是否进行任何更改。
 

docs/array/176.md

@@ -24,10 +24,10 @@ is needed so the count of jumps is 10.
 
 第一个元素是 1，因此只能转到 3。第二个元素是 3，因此最多可以执行 3 个步骤，例如到 5 或 8 或 9。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-number-of-jumps/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-number-of-jumps/0)
 
- <u>**方法 1**</u> ：幼稚递归方法。
-**方法**：天真的方法是从第一个元素开始，然后递归调用从第一个元素可到达的所有元素。 可以使用从第一个可到达元素开始到达终点所需的最小跳数来计算从第一个到达终点的最小跳数。
+ **方法 1** ：幼稚递归方法。
+**方法**：朴素的方法是从第一个元素开始，然后递归调用从第一个元素可到达的所有元素。 可以使用从第一个可到达元素开始到达终点所需的最小跳数来计算从第一个到达终点的最小跳数。
 *minJumps（开始，结束）= Min（minJumps（k，结束）），从开始就可以到达所有 k*
 
 ## C++ 

docs/array/177.md

@@ -4,7 +4,7 @@
 
 给定 n 个正整数数组。 编写程序以查找给定数组的最大和子序列的总和，以使子序列中的整数按升序排序。 例如，如果输入为{1、101、2、3、100、4、5}，那么如果输入数组为{3、4，则输出应为 106（1 + 2 + 3 + 100）。 5，10}，则输出应为 22​​（3 + 4 + 5 + 10），如果输入数组为{10，5，4，3}，则输出应为 10
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-sum-increasing-subsequence/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-sum-increasing-subsequence/0)
 
 **解决方案**
 此问题是标准[最长子序列（LIS）问题](https://www.geeksforgeeks.org/longest-increasing-subsequence-dp-3/)的变体。 我们需要对 [LIS 问题](https://www.geeksforgeeks.org/longest-increasing-subsequence-dp-3/)的动态编程解决方案进行一些更改。 我们需要更改的只是使用总和作为标准，而不是增加子序列的长度。

docs/array/178.md

@@ -28,7 +28,7 @@ Whole array sum is smaller than 8.
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-subarray-with-sum-greater-than-x/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-subarray-with-sum-greater-than-x/0)
 
 **简单解决方案**是使用两个嵌套循环。 外循环选择一个开始元素，内循环将所有元素（在当前开始的右侧）视为结束元素。 只要当前开始和结束之间的元素总数超过给定数目，如果当前长度小于到目前为止的最小长度，则更新结果。
 以下是简单方法的实现。

docs/array/179.md

@@ -14,7 +14,7 @@ Maximum average is (12 - 5 - 6 + 50)/4 = 51/4
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-average-subarray/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-average-subarray/0)
 
 一个**简单解决方案**是运行两个循环。 外循环选择起始点，内循环从起始点开始直到长度“ k”，然后计算元素的平均值。 该解决方案的时间复杂度为 O（n * k）。
 

docs/array/18.md

-# 快速找到数组的多个左旋转| 套装 1
+# 快速找到数组的多个左旋转| 系列 1
 
 > 原文： [https://www.geeksforgeeks.org/quickly-find-multiple-left-rotations-of-an-array/](https://www.geeksforgeeks.org/quickly-find-multiple-left-rotations-of-an-array/)
 
@@ -23,7 +23,7 @@ Output : 9 1 3 5 7
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/quick-left-rotation/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/quick-left-rotation/0)
 
 **简单方法**：我们已经在下面的文章中讨论了不同的方法。
 
@@ -31,14 +31,14 @@ Output : 9 1 3 5 7
 2.  [数组旋转的块交换算法](https://www.geeksforgeeks.org/block-swap-algorithm-for-array-rotation/)
 3.  [数组旋转的逆向算法](https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/)
 
-上述方法中的最佳方法需要 O（n）时间和 O（1）额外空间。
+上述方法中的最佳方法需要`O(n)`时间和`O(1)`额外空间。
 
 **高效方法**：
 当需要单次旋转时，上述方法效果很好。 这些方法还修改了原始数组。 为了处理数组旋转的多个查询，我们使用大小为 2n 的临时数组并快速处理旋转。
 
-步骤 1：将整个数组复制到 temp [0..2n-1]数组中两次。
-步骤 2：在 temp []中旋转 k 次后，数组的起始位置将为 k％n。 我们执行 k
-步骤 3：从 k％n 到 k％n + n 打印 temp []数组。
+步骤 1：将整个数组复制到`temp[0..2n-1]`数组中两次。
+步骤 2：在`temp[]`中旋转 k 次后，数组的起始位置将为`k % n`。 我们执行 k
+步骤 3：从`k % n`到`k % n + n`打印`temp []`数组。
 
 ## C++ 
 
@@ -320,7 +320,7 @@ leftRotate($arr, $n, $k, $temp);
 
 ```
 
-注意，查找旋转起始地址的任务需要 **O（1）时间**。 它正在打印需要 O（n）时间的元素。
+注意，查找旋转起始地址的任务需要**`O(1)`时间**。 它正在打印需要`O(n)`时间的元素。
 
 **优化空间的方法**：上述方法需要额外的空间。 下面给出的是空间优化的解决方案。 感谢 **frenzy77** 提出了这种方法。
 

docs/array/180.md

@@ -34,7 +34,7 @@ Then apply the doubling operation four times.
 Total number of operations is 3+4 = 7
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-steps-to-get-desired-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-steps-to-get-desired-array/0)
 
 需要注意的重要一件事是任务是计算获得给定目标数组的步骤数（而不是将零数组转换为目标数组）。
 

docs/array/181.md

@@ -20,7 +20,7 @@ that product of elements is less than 1
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法**：如果我们通过基本方法来解决此问题，则必须生成所有可能的 2 <sup>n</sup> 子集，然后对于每个子集，我们必须计算子集元素的乘积 并比较给定的产品价值。 但是这种方法的缺点是其时间复杂度太高，即 O（n * 2 <sup>n</sup> ）。 现在，我们可以看到它将是指数时间复杂性，在竞争性编码的情况下应避免这种情况。
 **进阶方法**：我们将在中间使用[开会的概念。](https://www.geeksforgeeks.org/meet-in-the-middle/) 通过使用这个概念，我们可以降低我们求解 O（n * 2 <sup>n / 2</sup> ）的复杂性。

docs/array/183.md

@@ -25,7 +25,7 @@ Output: 22
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-number-subset/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/smallest-number-subset/0)
 
 **简单解决方案**是从值 1 开始，并逐一检查所有值是否可以求和到给定数组中的值。 该解决方案效率很低，因为它简化为[子集和问题](https://www.geeksforgeeks.org/dynamic-programming-subset-sum-problem/)，这是众所周知的 [NP 完全问题](https://www.geeksforgeeks.org/np-completeness-set-1/)。
 

docs/array/184.md

@@ -19,7 +19,7 @@ and maximum sum will be {4, -1, -2, 1, 5}.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 此问题主要是[最大和连续子数组问题](https://www.geeksforgeeks.org/largest-sum-contiguous-subarray/)的变体。
 

docs/array/185.md

@@ -21,7 +21,7 @@ Minimum difference is between 1 and -4
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-difference-pair/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-difference-pair/0)
 
 **方法 1（简单：O（n <sup>2</sup> ）**
 一个简单的解决方案是使用两个循环。

docs/array/186.md

@@ -20,7 +20,7 @@ Output: 60 62 64 65 66 68 70 72 74 75 76 78
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（简单）**：
 将数组中的索引从 a 散列到 b，并将每个索引标记为 1 或 0。

docs/array/189.md

@@ -15,7 +15,7 @@ Output : 9 1 8 2 7 3 6 4
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/alternative-sorting/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/alternative-sorting/0)
 
 一个**简单解决方案**是先打印最大元素，然后再打印最小值，然后再打印第二个最大值，依此类推。 该方法的时间复杂度为 O（n <sup>2</sup> ）。
 

docs/array/19.md

@@ -19,13 +19,13 @@ Input: {2, 1}
 Output: 1
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-element-in-a-sorted-and-rotated-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-element-in-a-sorted-and-rotated-array/0)
 
-一个简单的解决方案是遍历整个数组并找到最小值。 该解决方案需要 O（n）时间。
-我们可以使用二分搜索在 O（Logn）中进行操作。 如果我们仔细看一下上面的示例，我们可以很容易地找出以下模式：
+一个简单的解决方案是遍历整个数组并找到最小值。 该解决方案需要`O(n)`时间。
+我们可以使用二分搜索在`O(Logn)`中进行操作。 如果我们仔细看一下上面的示例，我们可以很容易地找出以下模式：
 
-*   最小元素是前一个大于它的唯一元素。 如果没有先前的元素元素，则不会旋转（第一个元素最少）。 我们通过将此条件与第（mid-1）个和第（mid + 1）个元素进行比较来检查此条件。
-*   如果最小元素不在中间（既不是中也不是中+1），则最小元素位于左半部分或右半部分。
+*   最小元素是前一个大于它的唯一元素。 如果没有先前的元素元素，则不会旋转（第一个元素最少）。 我们通过将此条件与第（`mid-1`）个和第（`mid + 1`）个元素进行比较来检查此条件。
+*   如果最小元素不在中间（既不是`mid`也不是`mid+1`），则最小元素位于左半部分或右半部分。
     1.  如果中间元素小于最后一个元素，则最小元素位于左半部分
     2.  其他最小元素位于右半部分。
 

docs/array/190.md

@@ -17,7 +17,7 @@ Output : arr[] = {4, 7, 8, 9, 10, 50, 60, 70}
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/nearly-sorted-algorithm/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/nearly-sorted-algorithm/0)
 
 我们可以**使用插入排序**对元素进行有效排序。 以下是标准插入排序的 C 代码。
 

docs/array/191.md

@@ -27,7 +27,7 @@ Output :  arr[] = {6, 3, 2, 8}
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sort-by-absolute-difference/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sort-by-absolute-difference/0)
 
 想法是使用自平衡二分搜索树。 我们遍历输入数组，对于每个元素，我们找到它与 x 的差异，并将差异作为键存储，并将元素存储为自平衡二叉搜索树中的值。 最后，我们遍历树并打印其顺序遍历，这是必需的输出。
 

docs/array/192.md

@@ -27,7 +27,7 @@
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/wave-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/wave-array/0)
 
 **简单解决方案**将使用排序。 首先对输入数组进行排序，然后交换所有相邻元素。
 

docs/array/193.md

@@ -13,7 +13,7 @@
 输出：N []合并为 mPlusN []（已修改的 mPlusN []）
 ![MergemPlusN_Res](img/949d60042109809467e7ea11f92eb5b8.png "MergemPlusN_Res")
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **算法**：
 

docs/array/194.md

@@ -13,7 +13,7 @@ Output : 1 2 3 4 5 6 7 8 9 10
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **本机方法**：
 使用任何类型的排序方法对该数组进行排序。 最少需要 O（nlogn）时间。

docs/array/195.md

@@ -20,7 +20,7 @@ We can not sort A by swapping elements as 1 can never be swapped with A[0]=2.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 在这里，我们只能将 A [i]与 A [i + 1]交换。 因此要查找数组是否可以排序。 使用布尔数组 B，我们可以对 B 的连续序列 1 进行数组排序。最后，我们可以检查 A 是否排序。
 

docs/array/196.md

@@ -15,7 +15,7 @@ Output : arr[] = [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 我们已经讨论了解决方案[将数组 0 和 1 分离为](https://www.geeksforgeeks.org/segregate-0s-and-1s-in-an-array-by-traversing-array-once)
 

docs/array/197.md

-# 按频率对元素排序| 套装 1
+# 按频率对元素排序| 系列 1
 
 > 原文： [https://www.geeksforgeeks.org/sort-elements-by-frequency/](https://www.geeksforgeeks.org/sort-elements-by-frequency/)
 
@@ -14,7 +14,7 @@ Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sorting-elements-of-an-array-by-frequency/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sorting-elements-of-an-array-by-frequency/0)
 
 **方法 1（使用排序）**
 

docs/array/198.md

@@ -22,9 +22,9 @@ Explanation: Given array has two inversions:
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/inversion-of-array/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/inversion-of-array/0)
 
-<u>**方法 1（简单）**</u>
+**方法 1（简单）**
 
 *   **方法**：遍历数组，并为每个索引找到数组右侧的较小元素的数量。 这可以使用嵌套循环来完成。 对数组中所有索引的计数求和，然后打印总和。
 *   **算法**：
@@ -233,7 +233,7 @@ Explanation: Given array has two inversions:
     *   **时间复杂度**： O（n ^ 2），需要两个嵌套循环才能从头到尾遍历数组，因此时间复杂度为 O（n ^ 2）
     *   **空间复杂度**： O（1），不需要额外的空间。
 
-<u>**方法 2（增强合并排序）**</u>
+**方法 2（增强合并排序）**
 
 *   **Approach:**
     Suppose the number of inversions in the left half and right half of the array (let be inv1 and inv2), what kinds of inversions are not accounted for in Inv1 + Inv2? The answer is – the inversions that need to be counted during the merge step. Therefore, to get a number of inversions, that needs to be added a number of inversions in the left subarray, right subarray and merge().

docs/array/199.md

@@ -6,7 +6,7 @@
 
 对于以下数组，程序应打印-80 和 85。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/two-numbers-with-sum-closest-to-zero/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/two-numbers-with-sum-closest-to-zero/0)
 
 **方法 1（简单）**
 对于每个元素，找到它与数组中每个其他元素的总和，并比较总和。 最后，返回最小值。

docs/array/20.md

@@ -21,9 +21,9 @@ Output: 43 5 121 232 33
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
- **注意**：在下面的解决方案中，假定 k 小于或等于 n。 我们可以通过修改 k = k％n 来轻松修改解决方案以处理更大的 k 值
+ **注意**：在下面的解决方案中，假定 k 小于或等于 n。 我们可以通过修改 k = k% n 来轻松修改解决方案以处理更大的 k 值
 
 **算法**：
 

docs/array/200.md

@@ -19,7 +19,7 @@ Explanation :  Array is in increasing order.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个想法基于以下事实：最短子数组的大小可以为 0 或 3。我们必须检查数组元素是增加还是减少，如果所有数组元素都在增加或减少，则最短子数组的长度为 0， 而且，如果数组元素中的任何一个都不跟随递增或递减，则其最短长度为 3。
 

docs/array/201.md

@@ -17,7 +17,7 @@ Output : 2
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-swaps/1)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-swaps/1)
 
 通过将问题可视化为图形，可以轻松完成此操作。 如果第 i 个索引的元素必须存在于第 j 个索引中，则我们将有 **n 个**节点和一条从节点 **i** 指向节点 **j** 的边。 排序后的数组。
 

docs/array/203.md

@@ -9,9 +9,9 @@ arr1 [] = {7，1，5，2，3，6}
 arr2 [] = {3，8，6，20，7}
 然后，您的程序应将 Union 打印为{1,2,3,5,6,7,8,20}，并将 Intersection 打印为{3,6,7}。 请注意，并集和相交的元素可以按任何顺序打印。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/intersection-of-two-arrays/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/intersection-of-two-arrays/0)
 
-<u>**方法 1（朴素）**</u>
+**方法 1（朴素）**
 ***联合**：*
 1）将联合 U 初始化为空。
 2）将第一个数组的所有元素复制到 U。
@@ -27,7 +27,7 @@ arr2 [] = {3，8，6，20，7}
 
 对于两种操作，此方法的时间复杂度均为 O（mn）。 其中，m 和 n 分别是 arr1 []和 arr2 []中的元素数。
 
-<u>**方法 2（使用排序）**</u>
+**方法 2（使用排序）**
 1）对 arr1 []和 arr2 []进行排序。 此步骤需要 O（mLogm + nLogn）时间。
 2）使用 [O（m + n）算法找到两个排序数组](https://www.geeksforgeeks.org/union-and-intersection-of-two-sorted-arrays-2/)的并集和交集。
 
@@ -881,7 +881,7 @@ intersection($a, $b, $n, $m);
 
 感谢 Sanny Kumar 建议使用上述方法。
 
-<u>**方法 4（使用散列）**</u>
+**方法 4（使用散列）**
 ***联合**：*
 **联合**
 1。 初始化一个空哈希集 **hs** 。
@@ -1127,7 +1127,7 @@ Intersection of two arrays is :
 3 6 7 
 ```
 
-<u>**方法 5（不使用任何预定义 Java 集合的哈希技术的种类）**</u>
+**方法 5（不使用任何预定义 Java 集合的哈希技术的种类）**
 1.初始化大小为 m + n 的数组
 2.在结果中填充第一个数组值 通过进行哈希处理（找到合适的位置）来排列数组
 3.对第二个数组重复

docs/array/204.md

@@ -15,11 +15,11 @@ Output: {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s/0)
 
 在这篇文章（[对 0、1、2 和 2s 的数组进行排序（简单计数）](https://www.geeksforgeeks.org/sort-array-0s-1s-2s-simple-counting/)）中讨论了一种简单的解决方案。
 
-**<u>方法 1</u>**
+**方法 1**
 
 *   **Approach:**The problem is similar to our old post [Segregate 0s and 1s in an array](https://www.geeksforgeeks.org/segregate-0s-and-1s-in-an-array-by-traversing-array-once/), and both of these problems are variation of famous [Dutch national flag problem](http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/).
 
@@ -456,7 +456,7 @@ Output: {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}
 
 *感谢 Ankur Roy 建议进行此优化。*
 
-**<u>方法 2</u>**
+**方法 2**
 
 *   **方法**：计算给定数组中的 0、1 和 2 的数量。 然后在开始时存储所有 0，然后存储所有 1，然后存储所有 2。
 *   **算法**：

docs/array/205.md

@@ -8,7 +8,7 @@
 
 2）如果输入数组为[0、1、15、25、6、7、30、40、50]，则程序应该能够找到子数组位于索引 2 和 5 之间。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/length-unsorted-subarray/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/length-unsorted-subarray/0)
 
 **解决方案**：
 **1）找到候选未排序子数组**

docs/array/206.md

@@ -15,7 +15,7 @@ After reading 4th element of stream - 5, 15, 1, 3 -> median - 4, so on...
 
 请注意，输出是到目前为止从流中读取的整数的*有效中位数*。 这种算法称为在线算法。 在处理完第 *i* 个元素之后，可以保证 *i* 元素输出的任何算法都称为 ***在线算法*** 。 让我们讨论上述问题的三种解决方案。
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/find-median-in-a-stream/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/find-median-in-a-stream/0)
 
 **方法 1**：插入排序
 

docs/array/207.md

@@ -22,9 +22,9 @@ Explanation: There can be 6 possible triangles:
 
 ```
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-possible-triangles/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-possible-triangles/0)
 
-**<u>方法 1（蛮力）</u>**
+**方法 1（蛮力）**
 
 *   **方法**：蛮力方法是运行三个循环并跟踪到目前为止可能出现的三角形数量。 三个循环从数组中选择三个不同的值。 最内层的循环检查是否有三角形属性，该属性指定任意两个边的和必须大于第三边的值。
 *   **算法**：
@@ -250,7 +250,7 @@ Explanation: There can be 6 possible triangles:
     *   **时间复杂度**： O（N ^ 3），其中 N 是输入数组的大小。
     *   **空间复杂度**： O（1）
 
-<u>**方法 2**</u> ：这是一种复杂而有效的方法，可以将时间复杂度从 **O（n ^ 3）**降低到 **O（n ^ 2）** ，三角形的两个边固定，并且可以使用这两个边找到计数。
+**方法 2** ：这是一种复杂而有效的方法，可以将时间复杂度从 **O（n ^ 3）**降低到 **O（n ^ 2）** ，三角形的两个边固定，并且可以使用这两个边找到计数。
 
 *   **方法**：首先以升序对数组进行排序。 然后使用两个循环。 固定第一个侧面的外环和固定第二个侧面的内环，然后找到长度小于其他两个侧面的第三侧面的最远索引（大于两个侧面的索引）。 因此，可以找到一系列值的第三边，可以保证其长度大于其他各个边但小于两个边的总和。
 *   **Algorithm:** Let a, b and c be three sides. The below condition must hold for a triangle (sum of two sides is greater than the third side)
@@ -730,7 +730,7 @@ Explanation: There can be 6 possible triangles:
     *   **空间复杂度**： O（1）。
         不需要多余的空间。 所以空间复杂度是恒定的
 
-<u>**方法 3**：</u> 仅在两个嵌套循环中使用**两个指针方法**，可以大大降低时间复杂度。
+**方法 3**： 仅在两个嵌套循环中使用**两个指针方法**，可以大大降低时间复杂度。
 
 *   **方法**：首先对数组进行排序，然后运行一个嵌套循环，修复一个索引，然后尝试修复一个上下索引，在其中我们可以使用所有长度来与该固定索引形成一个三角形。
 *   **算法**：

docs/array/208.md

@@ -16,7 +16,7 @@
 > **说明 **：总共有 2 对，其中 pow（x，y）比 pow（y，x）大
 > 对是（10，11）和（10，15）
 
-## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/number-of-pairs/0)
+## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/number-of-pairs/0)
 
 **蛮力解**将考虑 X []和 Y []的每个元素，并检查给定条件是否满足。