2020-07-05 17:01:12

docs/array/10.md

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

docs/array/101.md

@@ -27,7 +27,7 @@ generated is 10 10 10 15 15 90 90
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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)
 
 **方法 1**： 这是解决上述问题的简单方法。
 

docs/array/102.md

@@ -36,7 +36,7 @@ index 6, so the distance is 1
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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)算法。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/longest-increasing-subsequence/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/longest-increasing-subsequence/0)
 
 暂时，无需考虑递归和 DP 解决方案。 让我们抽取少量样本并将解决方案扩展到大型实例。 尽管乍一看可能很复杂，但是一旦我们理解了逻辑，编码就很简单。
 

docs/array/106.md

@@ -18,7 +18,7 @@
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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）。
 

docs/array/107.md

@@ -4,7 +4,7 @@
 
 给定大小为 *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）*。 允许对数组进行修改。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-repeating-number/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/maximum-repeating-number/0)
 
 **朴素的方法**是运行两个循环，外循环一个接一个地拾取一个元素，内循环计算被拾取元素的出现次数。 最后返回具有最大计数的元素。 该方法的时间复杂度为 *O（n ^ 2）*。
 

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。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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")
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **算法**：
 

docs/array/110.md

@@ -35,7 +35,7 @@ Explanation: 122 is sum of 1, 5, 7, 8, 10, 12, 15, 30, 34
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-path-in-two-arrays/1)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-path-in-two-arrays/1)
 
 **有效方法**： 的想法是做类似于[合并排序](http://geeksquiz.com/merge-sort/)的合并过程的操作。 这涉及计算两个数组的所有公共点之间的元素之和。 只要有一个共同点，就比较两个和并将两个的最大值相加。
 

docs/array/112.md

@@ -7,7 +7,7 @@
 难度等级：新秀
 预期时间复杂度：O（n）[仅允许遍历数组一次]
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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)
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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）。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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}
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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],
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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）
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 ## C++ 
 

docs/array/122.md

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

docs/array/123.md

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

docs/array/125.md

-# MO 的算法（查询平方根分解）| 设置 1（简介）
+# MO 的算法（查询平方根分解）| 系列 1（简介）
 
 > 原文： [https://www.geeksforgeeks.org/mos-algorithm-query-square-root-decomposition-set-1-introduction/](https://www.geeksforgeeks.org/mos-algorithm-query-square-root-decomposition-set-1-introduction/)
 
@@ -17,7 +17,7 @@ Output: Sum of arr[] elements in range [0, 4] is 8
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/interesting-queries/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/interesting-queries/0)
 
 **朴素的解决方案**将运行从 L 到 R 的循环，并为每个查询[L，R]计算给定范围内的元素总数。
 

docs/array/126.md

-# Sqrt（或平方根）分解技术 设置 1（简介）
+# Sqrt（或平方根）分解技术 系列 1（简介）
 
 > 原文： [https://www.geeksforgeeks.org/sqrt-square-root-decomposition-technique-set-1-introduction/](https://www.geeksforgeeks.org/sqrt-square-root-decomposition-technique-set-1-introduction/)
 

docs/array/128.md

@@ -20,7 +20,7 @@ Note : array is 0 based indexed
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/search-in-a-rotated-array/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/search-in-a-rotated-array/0)
 
 **此处提供的所有解决方案均假定数组中的所有元素都是不同的。**
 

docs/array/131.md

@@ -18,7 +18,7 @@ Which is the final updated array.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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,
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（简单）**
 

docs/array/134.md

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

docs/array/136.md

@@ -31,7 +31,7 @@ and similarly other queries are answered
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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/)
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **简单方法**将运行 for 循环，以检查每个元素是否在给定范围内并保持其计数。 运行每个查询的时间复杂度为 O（n）。
 

docs/array/138.md

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

docs/array/14.md

@@ -21,7 +21,7 @@ There is no pair with sum 45.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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。 这给了我们想要的结果
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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 发生三次
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **方法 1（蛮力）**
 计算每个查询下子数组中每个元素的频率。 如果在每个查询覆盖的子数组中任何数字 x 的频率为 x，我们将增加计数器。

docs/array/146.md

@@ -27,7 +27,7 @@ Output : 2
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **朴素的方法**是从 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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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}.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 让我们观察 **arr []**
 

docs/array/151.md

@@ -28,7 +28,7 @@ so subarray is not in the form above stated
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mountain-subarray-problem/1)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/mountain-subarray-problem/1)
 
 **解决方案：**
 

docs/array/152.md

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

docs/array/154.md

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

docs/array/156.md

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

docs/array/157.md

@@ -24,7 +24,7 @@ Third command: Add 1 from index 2 to 5
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **蛮力**
 

docs/array/16.md

@@ -24,7 +24,7 @@ Explanation: Lets look at all the rotations,
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-in-the-configuration/1)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/max-sum-in-the-configuration/1)
 
 **方法 1 **：此方法讨论**朴素溶液**，该过程花费`O(n^2)`的时间。
 解决方案涉及找到每次旋转中数组所有元素的总和，然后确定最大总和值。

docs/array/160.md

@@ -19,7 +19,7 @@ For the second query, answer is 2 {5, 7}.
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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,7 +23,7 @@ Output : Resultant array = {1, 1, 1, 1, 1}
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **朴素的方法**：对于给定的 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}
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/overlapping-intervals/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/overlapping-intervals/0)
 
 编写一个函数，该函数为给定间隔集生成合并间隔集。
 

docs/array/164.md

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

docs/array/165.md

@@ -33,7 +33,7 @@ previously modified array.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 **朴素的方法**：对于每个查询，遍历**开始**到**结束**范围内的数组，并将该范围内的值增加给定值 **d** 。
 

docs/array/166.md

@@ -21,7 +21,7 @@ Output : 1
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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)
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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)
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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.
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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

@@ -41,9 +41,9 @@ arr[] = {3, 4, 5}
 
 ```
 
-来源： [Adob​​e 面试体验| 设置 24（MTS 校园内）](https://www.geeksforgeeks.org/adobe-interview-experience-set-24-on-campus-for-mts/)
+来源： [Adob​​e 面试体验| 系列 24（MTS 校园内）](https://www.geeksforgeeks.org/adobe-interview-experience-set-24-on-campus-for-mts/)
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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,7 +24,7 @@ is needed so the count of jumps is 10.
 
 第一个元素是 1，因此只能转到 3。第二个元素是 3，因此最多可以执行 3 个步骤，例如到 5 或 8 或 9。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-number-of-jumps/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-number-of-jumps/0)
 
  **方法 1** ：幼稚递归方法。
 **方法**：朴素的方法是从第一个元素开始，然后递归调用从第一个元素可到达的所有元素。 可以使用从第一个可到达元素开始到达终点所需的最小跳数来计算从第一个到达终点的最小跳数。

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
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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.
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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

@@ -23,7 +23,7 @@ Output : 9 1 3 5 7
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/quick-left-rotation/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/quick-left-rotation/0)
 
 **简单方法**：我们已经在下面的文章中讨论了不同的方法。
 

docs/array/180.md

@@ -34,7 +34,7 @@ Then apply the doubling operation four times.
 Total number of operations is 3+4 = 7
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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}.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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,7 +19,7 @@ Input: {2, 1}
 Output: 1
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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)`中进行操作。 如果我们仔细看一下上面的示例，我们可以很容易地找出以下模式：

docs/array/190.md

@@ -17,7 +17,7 @@ Output : arr[] = {4, 7, 8, 9, 10, 50, 60, 70}
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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}
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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 @@
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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")
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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]
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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

@@ -14,7 +14,7 @@ Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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

-# 计算数组中的反转 设置 1（使用合并排序）
+# 计算数组中的反转 系列 1（使用合并排序）
 
 > 原文： [https://www.geeksforgeeks.org/counting-inversions/](https://www.geeksforgeeks.org/counting-inversions/)
 
@@ -22,7 +22,7 @@ Explanation: Given array has two inversions:
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/inversion-of-array/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/inversion-of-array/0)
 
 **方法 1（简单）**
 

docs/array/199.md

@@ -6,7 +6,7 @@
 
 对于以下数组，程序应打印-80 和 85。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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

@@ -3,8 +3,11 @@
 > 原文： [https://www.geeksforgeeks.org/reversal-algorithm-right-rotation-array/](https://www.geeksforgeeks.org/reversal-algorithm-right-rotation-array/)
 
 给定一个数组，将其右旋转 k 个元素。
+
 ![](img/b754fc0e3ccfcef7c392803d8a2b0aee.png)
-在 K = 3 旋转后
+
+在`K = 3`旋转后
+
 ![](img/ac62c9abc5e2cff356e1adf44883f9b9.png)
 
 **示例**：
@@ -21,9 +24,9 @@ Output: 43 5 121 232 33
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](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.
 
 ```
 
-## [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
 这个想法基于以下事实：最短子数组的大小可以为 0 或 3。我们必须检查数组元素是增加还是减少，如果所有数组元素都在增加或减少，则最短子数组的长度为 0， 而且，如果数组元素中的任何一个都不跟随递增或递减，则其最短长度为 3。
 

docs/array/201.md

@@ -17,7 +17,7 @@ Output : 2
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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,7 +9,7 @@ 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}。 请注意，并集和相交的元素可以按任何顺序打印。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/intersection-of-two-arrays/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/intersection-of-two-arrays/0)
 
 **方法 1（朴素）**
 ***联合**：*

docs/array/204.md

@@ -15,7 +15,7 @@ Output: {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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/)）中讨论了一种简单的解决方案。
 

docs/array/205.md

@@ -8,7 +8,7 @@
 
 2）如果输入数组为[0、1、15、25、6、7、30、40、50]，则程序应该能够找到子数组位于索引 2 和 5 之间。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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* 元素输出的任何算法都称为 ***在线算法*** 。 让我们讨论上述问题的三种解决方案。
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](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,7 +22,7 @@ Explanation: There can be 6 possible triangles:
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-possible-triangles/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-possible-triangles/0)
 
 **方法 1（蛮力）**
 

docs/array/208.md

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

docs/array/209.md

@@ -18,7 +18,7 @@ There are 5 pairs with difference 4, the pairs are {0, 4}, {4, 8},
 
 ```
 
-## [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-distinct-pairs-with-difference-k/0)
+> [推荐：请先在“ ***实践*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/count-distinct-pairs-with-difference-k/0)
 
 **方法 1（简单）**
 一个简单的解决方案是逐一考虑所有对，并检查每对之间的差异。 以下程序实现简单的解决方案。 我们运行两个循环：外部循环选择对的第一个元素，内部循环寻找另一个元素。 如果数组中有重复项，则此解决方案将不起作用，因为要求仅计算不重复的对。

docs/array/21.md

@@ -28,10 +28,10 @@ Other solutions can be 8 0 2 4, 4 0 2 8 etc.
 
 ```
 
-## [推荐：在继续进行解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
+> [推荐：在继续进行解决之前，请先在 ***{IDE}*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-创建另一个数组，该数组的大小是原始数组的两倍，以使此新数组（复制数组）的元素只是原始数组的元素，并按相同顺序重复两次。 例如，如果原始数组为 1 4 1，则副本数组为 1 4 1 1 41。
-现在，遍历副本数组并查找每次移位（或旋转）的汉明距离。 因此，我们检查 4 1 1、1 1 4、1 4 1，选择汉明距离最大的输出。
+创建另一个数组，该数组的大小是原始数组的两倍，以使此新数组（复制数组）的元素只是原始数组的元素，并按相同顺序重复两次。 例如，如果原始数组为`1 4 1`，则副本数组为`1 4 1 1 4 1`。
+现在，遍历副本数组并查找每次移位（或旋转）的汉明距离。 因此，我们检查`4 1 1, 1 1 4, 1 4 1`，选择汉明距离最大的输出。
 
 下面是上述方法的实现：