mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-05 23:41:41 +08:00
update
This commit is contained in:
zhangbk1
@@ -0,0 +1,51 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> having length <code>n</code>.</p>
|
||||
|
||||
<p>You are allowed to perform a special move <strong>any</strong> number of times (<strong>including zero</strong>) on <code>nums</code>. In one <strong>special</strong> <strong>move</strong> you perform the following steps <strong>in order</strong>:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose an index <code>i</code> in the range <code>[0, n - 1]</code>, and a <strong>positive</strong> integer <code>x</code>.</li>
|
||||
<li>Add <code>|nums[i] - x|</code> to the total cost.</li>
|
||||
<li>Change the value of <code>nums[i]</code> to <code>x</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>palindromic number</strong> is a positive integer that remains the same when its digits are reversed. For example, <code>121</code>, <code>2552</code> and <code>65756</code> are palindromic numbers whereas <code>24</code>, <code>46</code>, <code>235</code> are not palindromic numbers.</p>
|
||||
|
||||
<p>An array is considered <strong>equalindromic</strong> if all the elements in the array are equal to an integer <code>y</code>, where <code>y</code> is a <strong>palindromic number</strong> less than <code>10<sup>9</sup></code>.</p>
|
||||
|
||||
<p>Return <em>an integer denoting the <strong>minimum</strong> possible total cost to make </em><code>nums</code><em> <strong>equalindromic</strong> by performing any number of special moves.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 3 which is a palindromic number. The cost of changing the array to [3,3,3,3,3] using 4 special moves is given by |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
|
||||
It can be shown that changing all elements to any palindromic number other than 3 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,12,13,14,15]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 11 which is a palindromic number. The cost of changing the array to [11,11,11,11,11] using 5 special moves is given by |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
|
||||
It can be shown that changing all elements to any palindromic number other than 11 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [22,33,22,33,22]
|
||||
<strong>Output:</strong> 22
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 22 which is a palindromic number. The cost of changing the array to [22,22,22,22,22] using 2 special moves is given by |33 - 22| + |33 - 22| = 22.
|
||||
It can be shown that changing all elements to any palindromic number other than 22 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,69 @@
|
||||
<p>There is a company with <code>n</code> branches across the country, some of which are connected by roads. Initially, all branches are reachable from each other by traveling some roads.</p>
|
||||
|
||||
<p>The company has realized that they are spending an excessive amount of time traveling between their branches. As a result, they have decided to close down some of these branches (<strong>possibly none</strong>). However, they want to ensure that the remaining branches have a distance of at most <code>maxDistance</code> from each other.</p>
|
||||
|
||||
<p>The <strong>distance</strong> between two branches is the <strong>minimum</strong> total traveled length needed to reach one branch from another.</p>
|
||||
|
||||
<p>You are given integers <code>n</code>, <code>maxDistance</code>, and a <strong>0-indexed</strong> 2D array <code>roads</code>, where <code>roads[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> represents the <strong>undirected</strong> road between branches <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with length <code>w<sub>i</sub></code>.</p>
|
||||
|
||||
<p>Return <em>the number of possible sets of closing branches, so that any branch has a distance of at most </em><code>maxDistance</code><em> from any other</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that, after closing a branch, the company will no longer have access to any roads connected to it.</p>
|
||||
|
||||
<p><strong>Note</strong> that, multiple roads are allowed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/08/example11.png" style="width: 221px; height: 191px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, maxDistance = 5, roads = [[0,1,2],[1,2,10],[0,2,10]]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [2], after closing, active branches are [0,1] and they are reachable to each other within distance 2.
|
||||
- The set [0,1], after closing, the active branch is [2].
|
||||
- The set [1,2], after closing, the active branch is [0].
|
||||
- The set [0,2], after closing, the active branch is [1].
|
||||
- The set [0,1,2], after closing, there are no active branches.
|
||||
It can be proven, that there are only 5 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/08/example22.png" style="width: 221px; height: 241px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, maxDistance = 5, roads = [[0,1,20],[0,1,10],[1,2,2],[0,2,2]]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [], after closing, active branches are [0,1,2] and they are reachable to each other within distance 4.
|
||||
- The set [0], after closing, active branches are [1,2] and they are reachable to each other within distance 2.
|
||||
- The set [1], after closing, active branches are [0,2] and they are reachable to each other within distance 2.
|
||||
- The set [0,1], after closing, the active branch is [2].
|
||||
- The set [1,2], after closing, the active branch is [0].
|
||||
- The set [0,2], after closing, the active branch is [1].
|
||||
- The set [0,1,2], after closing, there are no active branches.
|
||||
It can be proven, that there are only 7 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1, maxDistance = 10, roads = []
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [], after closing, the active branch is [0].
|
||||
- The set [0], after closing, there are no active branches.
|
||||
It can be proven, that there are only 2 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10</code></li>
|
||||
<li><code>1 <= maxDistance <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= roads.length <= 1000</code></li>
|
||||
<li><code>roads[i].length == 3</code></li>
|
||||
<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
|
||||
<li><code>1 <= w<sub>i</sub> <= 1000</code></li>
|
||||
<li>All branches are reachable from each other by traveling some roads.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given an integer array <code>nums</code> of size <code>n</code> and a positive integer <code>k</code>.</p>
|
||||
|
||||
<p>Divide the array into one or more arrays of size <code>3</code> satisfying the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Each</strong> element of <code>nums</code> should be in <strong>exactly</strong> one array.</li>
|
||||
<li>The difference between <strong>any</strong> two elements in one array is less than or equal to <code>k</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>a </em><strong>2D</strong><em> array containing all the arrays. If it is impossible to satisfy the conditions, return an empty array. And if there are multiple answers, return <strong>any</strong> of them.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,4,8,7,9,3,5,1], k = 2
|
||||
<strong>Output:</strong> [[1,1,3],[3,4,5],[7,8,9]]
|
||||
<strong>Explanation:</strong> We can divide the array into the following arrays: [1,1,3], [3,4,5] and [7,8,9].
|
||||
The difference between any two elements in each array is less than or equal to 2.
|
||||
Note that the order of elements is not important.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,3,2,7,3], k = 3
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> It is not possible to divide the array satisfying all the conditions.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>n</code> is a multiple of <code>3</code>.</li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D array <code>variables</code> where <code>variables[i] = [a<sub>i</sub>, b<sub>i</sub>, c<sub>i,</sub> m<sub>i</sub>]</code>, and an integer <code>target</code>.</p>
|
||||
|
||||
<p>An index <code>i</code> is <strong>good</strong> if the following formula holds:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= i < variables.length</code></li>
|
||||
<li><code>((a<sub>i</sub><sup>b<sub>i</sub></sup> % 10)<sup>c<sub>i</sub></sup>) % m<sub>i</sub> == target</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array consisting of <strong>good</strong> indices in <strong>any order</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
|
||||
<strong>Output:</strong> [0,2]
|
||||
<strong>Explanation:</strong> For each index i in the variables array:
|
||||
1) For the index 0, variables[0] = [2,3,3,10], (2<sup>3</sup> % 10)<sup>3</sup> % 10 = 2.
|
||||
2) For the index 1, variables[1] = [3,3,3,1], (3<sup>3</sup> % 10)<sup>3</sup> % 1 = 0.
|
||||
3) For the index 2, variables[2] = [6,1,1,4], (6<sup>1</sup> % 10)<sup>1</sup> % 4 = 2.
|
||||
Therefore we return [0,2] as the answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> variables = [[39,3,1000,1000]], target = 17
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> For each index i in the variables array:
|
||||
1) For the index 0, variables[0] = [39,3,1000,1000], (39<sup>3</sup> % 10)<sup>1000</sup> % 1000 = 1.
|
||||
Therefore we return [] as the answer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= variables.length <= 100</code></li>
|
||||
<li><code>variables[i] == [a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub>, m<sub>i</sub>]</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub>, m<sub>i</sub> <= 10<sup>3</sup></code></li>
|
||||
<li><code><font face="monospace">0 <= target <= 10<sup>3</sup></font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>You can perform the following operation on the array <strong>at most</strong> <code>k</code> times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose any index <code>i</code> from the array and <strong>increase</strong> or <strong>decrease</strong> <code>nums[i]</code> by <code>1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The score of the final array is the <strong>frequency</strong> of the most frequent element in the array.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> score you can achieve</em>.</p>
|
||||
|
||||
<p>The frequency of an element is the number of occurences of that element in the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,6,4], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can do the following operations on the array:
|
||||
- Choose i = 0, and increase the value of nums[0] by 1. The resulting array is [2,2,6,4].
|
||||
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,3].
|
||||
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,2].
|
||||
The element 2 is the most frequent in the final array so our score is 3.
|
||||
It can be shown that we cannot achieve a better score.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,4,2,4], k = 0
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We cannot apply any operations so our score will be the frequency of the most frequent element in the original array, which is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>14</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D integer matrix <code><font face="monospace">grid</font></code> of size <code>n * n</code> with values in the range <code>[1, n<sup>2</sup>]</code>. Each integer appears <strong>exactly once</strong> except <code>a</code> which appears <strong>twice</strong> and <code>b</code> which is <strong>missing</strong>. The task is to find the repeating and missing numbers <code>a</code> and <code>b</code>.</p>
|
||||
|
||||
<p>Return <em>a <strong>0-indexed </strong>integer array </em><code>ans</code><em> of size </em><code>2</code><em> where </em><code>ans[0]</code><em> equals to </em><code>a</code><em> and </em><code>ans[1]</code><em> equals to </em><code>b</code><em>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,3],[2,2]]
|
||||
<strong>Output:</strong> [2,4]
|
||||
<strong>Explanation:</strong> Number 2 is repeated and number 4 is missing so the answer is [2,4].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[9,1,7],[8,9,2],[3,4,6]]
|
||||
<strong>Output:</strong> [9,5]
|
||||
<strong>Explanation:</strong> Number 9 is repeated and number 5 is missing so the answer is [9,5].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n == grid.length == grid[i].length <= 50</code></li>
|
||||
<li><code>1 <= grid[i][j] <= n * n</code></li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> there is exactly one <code>x</code> that is not equal to any of the grid members.</li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> there is exactly one <code>x</code> that is equal to exactly two of the grid members.</li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> except two of them there is exatly one pair of <code>i, j</code> that <code>0 <= i, j <= n - 1</code> and <code>grid[i][j] == x</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code> of sizes <code>n</code> and <code>m</code>, respectively.</p>
|
||||
|
||||
<p>Consider calculating the following values:</p>
|
||||
|
||||
<ul>
|
||||
<li>The number of indices <code>i</code> such that <code>0 <= i < n</code> and <code>nums1[i]</code> occurs <strong>at least</strong> once in <code>nums2</code>.</li>
|
||||
<li>The number of indices <code>i</code> such that <code>0 <= i < m</code> and <code>nums2[i]</code> occurs <strong>at least</strong> once in <code>nums1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array </em><code>answer</code><em> of size </em><code>2</code><em> containing the two values <strong>in the above order</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
|
||||
<strong>Output:</strong> [3,4]
|
||||
<strong>Explanation:</strong> We calculate the values as follows:
|
||||
- The elements at indices 1, 2, and 3 in nums1 occur at least once in nums2. So the first value is 3.
|
||||
- The elements at indices 0, 1, 3, and 4 in nums2 occur at least once in nums1. So the second value is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [3,4,2,3], nums2 = [1,5]
|
||||
<strong>Output:</strong> [0,0]
|
||||
<strong>Explanation:</strong> There are no common elements between the two arrays, so the two values will be 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums1.length</code></li>
|
||||
<li><code>m == nums2.length</code></li>
|
||||
<li><code>1 <= n, m <= 100</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given an integer array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>The <strong>frequency</strong> of an element <code>x</code> is the number of times it occurs in an array.</p>
|
||||
|
||||
<p>An array is called <strong>good</strong> if the frequency of each element in this array is <strong>less than or equal</strong> to <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>the length of the <strong>longest</strong> <strong>good</strong> subarray of</em> <code>nums</code><em>.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,1,2,3,1,2], k = 2
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [1,2,3,1,2,3] since the values 1, 2, and 3 occur at most twice in this subarray. Note that the subarrays [2,3,1,2,3,1] and [3,1,2,3,1,2] are also good.
|
||||
It can be shown that there are no good subarrays with length more than 6.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,2,1,2,1,2], k = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [1,2] since the values 1 and 2 occur at most once in this subarray. Note that the subarray [2,1] is also good.
|
||||
It can be shown that there are no good subarrays with length more than 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,5,5,5,5,5], k = 4
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [5,5,5,5] since the value 5 occurs 4 times in this subarray.
|
||||
It can be shown that there are no good subarrays with length more than 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>word</code>.</p>
|
||||
|
||||
<p>In one operation, you can pick any index <code>i</code> of <code>word</code> and change <code>word[i]</code> to any lowercase English letter.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of operations needed to remove all adjacent <strong>almost-equal</strong> characters from</em> <code>word</code>.</p>
|
||||
|
||||
<p>Two characters <code>a</code> and <code>b</code> are <strong>almost-equal</strong> if <code>a == b</code> or <code>a</code> and <code>b</code> are adjacent in the alphabet.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "aaaaa"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can change word into "a<strong><u>c</u></strong>a<u><strong>c</strong></u>a" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "abddez"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can change word into "<strong><u>y</u></strong>bd<u><strong>o</strong></u>ez" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "zyxyxyz"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can change word into "z<u><strong>a</strong></u>x<u><strong>a</strong></u>x<strong><u>a</u></strong>z" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 100</code></li>
|
||||
<li><code>word</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> consisting of <strong>positive</strong> integers.</p>
|
||||
|
||||
<p>A partition of an array into one or more <strong>contiguous</strong> subarrays is called <strong>good</strong> if no two subarrays contain the same number.</p>
|
||||
|
||||
<p>Return <em>the <strong>total number</strong> of good partitions of </em><code>nums</code>.</p>
|
||||
|
||||
<p>Since the answer may be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> 8
|
||||
<strong>Explanation:</strong> The 8 possible good partitions are: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), and ([1,2,3,4]).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1,1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The only possible good partition is: ([1,1,1,1]).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,3]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The 2 possible good partitions are: ([1,2,1], [3]) and ([1,2,1,3]).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>batteryPercentages</code> having length <code>n</code>, denoting the battery percentages of <code>n</code> <strong>0-indexed</strong> devices.</p>
|
||||
|
||||
<p>Your task is to test each device <code>i</code> <strong>in order</strong> from <code>0</code> to <code>n - 1</code>, by performing the following test operations:</p>
|
||||
|
||||
<ul>
|
||||
<li>If <code>batteryPercentages[i]</code> is <strong>greater</strong> than <code>0</code>:
|
||||
|
||||
<ul>
|
||||
<li><strong>Increment</strong> the count of tested devices.</li>
|
||||
<li><strong>Decrease</strong> the battery percentage of all devices with indices <code>j</code> in the range <code>[i + 1, n - 1]</code> by <code>1</code>, ensuring their battery percentage <strong>never goes below</strong> <code>0</code>, i.e, <code>batteryPercentages[j] = max(0, batteryPercentages[j] - 1)</code>.</li>
|
||||
<li>Move to the next device.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Otherwise, move to the next device without performing any test.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer denoting the number of devices that will be tested after performing the test operations in order.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> batteryPercentages = [1,1,2,1,3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation: </strong>Performing the test operations in order starting from device 0:
|
||||
At device 0, batteryPercentages[0] > 0, so there is now 1 tested device, and batteryPercentages becomes [1,0,1,0,2].
|
||||
At device 1, batteryPercentages[1] == 0, so we move to the next device without testing.
|
||||
At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages becomes [1,0,1,0,1].
|
||||
At device 3, batteryPercentages[3] == 0, so we move to the next device without testing.
|
||||
At device 4, batteryPercentages[4] > 0, so there are now 3 tested devices, and batteryPercentages stays the same.
|
||||
So, the answer is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> batteryPercentages = [0,1,2]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Performing the test operations in order starting from device 0:
|
||||
At device 0, batteryPercentages[0] == 0, so we move to the next device without testing.
|
||||
At device 1, batteryPercentages[1] > 0, so there is now 1 tested device, and batteryPercentages becomes [0,1,1].
|
||||
At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages stays the same.
|
||||
So, the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == batteryPercentages.length <= 100 </code></li>
|
||||
<li><code>0 <= batteryPercentages[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>You are given an integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>the number of subarrays where the <strong>maximum</strong> element of </em><code>nums</code><em> appears <strong>at least</strong> </em><code>k</code><em> times in that subarray.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,2,3,3], k = 2
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The subarrays that contain the element 3 at least 2 times are: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] and [3,3].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,2,1], k = 3
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> No subarray contains the element 4 at least 3 times.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user