mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,41 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>The <strong>low</strong> score of <code><font face="monospace">nums</font></code> is the minimum value of <code>|nums[i] - nums[j]|</code> over all <code>0 <= i < j < nums.length</code>.</li>
|
||||
<li>The <strong>high</strong> score of <code><font face="monospace">nums</font></code> is the maximum value of <code>|nums[i] - nums[j]|</code> over all <code>0 <= i < j < nums.length</code>.</li>
|
||||
<li>The <strong>score</strong> of <code>nums</code> is the sum of the <strong>high</strong> and <strong>low</strong> scores of nums.</li>
|
||||
</ul>
|
||||
|
||||
<p>To minimize the score of <code>nums</code>, we can change the value of <strong>at most two</strong> elements of <code>nums</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> possible <strong>score</strong> after changing the value of <strong>at most two</strong> elements o</em>f <code>nums</code>.</p>
|
||||
|
||||
<p>Note that <code>|x|</code> denotes the absolute value of <code>x</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,3]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Change value of nums[1] and nums[2] to 1 so that nums becomes [1,1,1]. Now, the value of <code>|nums[i] - nums[j]|</code> is always equal to 0, so we return 0 + 0 = 0.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,7,8,5]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Change nums[0] and nums[1] to be 6. Now nums becomes [6,6,7,8,5].
|
||||
Our low score is achieved when i = 0 and j = 1, in which case |<code>nums[i] - nums[j]</code>| = |6 - 6| = 0.
|
||||
Our high score is achieved when i = 3 and j = 4, in which case |<code>nums[i] - nums[j]</code>| = |8 - 5| = 3.
|
||||
The sum of our high and low score is 3, which we can prove to be minimal.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>You are given two <strong>2D</strong> integer arrays <code>nums1</code> and <code>nums2.</code></p>
|
||||
|
||||
<ul>
|
||||
<li><code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code> indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
|
||||
<li><code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code> indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Each array contains <strong>unique</strong> ids and is sorted in <strong>ascending</strong> order by id.</p>
|
||||
|
||||
<p>Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li>Only ids that appear in at least one of the two arrays should be included in the resulting array.</li>
|
||||
<li>Each id should be included <strong>only once</strong> and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays then its value in that array is considered to be <code>0</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the resulting array</em>. The returned array must be sorted in ascending order by id.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
|
||||
<strong>Output:</strong> [[1,6],[2,3],[3,2],[4,6]]
|
||||
<strong>Explanation:</strong> The resulting array contains the following:
|
||||
- id = 1, the value of this id is 2 + 4 = 6.
|
||||
- id = 2, the value of this id is 3.
|
||||
- id = 3, the value of this id is 2.
|
||||
- id = 4, the value of this id is 5 + 1 = 6.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
|
||||
<strong>Output:</strong> [[1,3],[2,4],[3,6],[4,3],[5,5]]
|
||||
<strong>Explanation:</strong> There are no common ids, so we just include each id with its value in the resulting list.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 200</code></li>
|
||||
<li><code>nums1[i].length == nums2[j].length == 2</code></li>
|
||||
<li><code>1 <= id<sub>i</sub>, val<sub>i</sub> <= 1000</code></li>
|
||||
<li>Both arrays contain unique ids.</li>
|
||||
<li>Both arrays are in strictly ascending order by id.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>You are given a <code>m x n</code> matrix <code>grid</code> consisting of <b>non-negative</b> integers where <code>grid[row][col]</code> represents the <strong>minimum</strong> time required to be able to visit the cell <code>(row, col)</code>, which means you can visit the cell <code>(row, col)</code> only when the time you visit it is greater than or equal to <code>grid[row][col]</code>.</p>
|
||||
|
||||
<p>You are standing in the <strong>top-left</strong> cell of the matrix in the <code>0<sup>th</sup></code> second, and you must move to <strong>any</strong> adjacent cell in the four directions: up, down, left, and right. Each move you make takes 1 second.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> time required in which you can visit the bottom-right cell of the matrix</em>. If you cannot visit the bottom-right cell, then return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> One of the paths that we can take is the following:
|
||||
- at t = 0, we are on the cell (0,0).
|
||||
- at t = 1, we move to the cell (0,1). It is possible because grid[0][1] <= 1.
|
||||
- at t = 2, we move to the cell (1,1). It is possible because grid[1][1] <= 2.
|
||||
- at t = 3, we move to the cell (1,2). It is possible because grid[1][2] <= 3.
|
||||
- at t = 4, we move to the cell (1,1). It is possible because grid[1][1] <= 4.
|
||||
- at t = 5, we move to the cell (1,2). It is possible because grid[1][2] <= 5.
|
||||
- at t = 6, we move to the cell (1,3). It is possible because grid[1][3] <= 6.
|
||||
- at t = 7, we move to the cell (2,3). It is possible because grid[1][3] <= 7.
|
||||
The final time is 7. It can be shown that it is the minimum time possible.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png" style="width: 151px; height: 151px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,2,4],[3,2,1],[1,0,4]]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> There is no path from the top left to the bottom-right cell.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>2 <= m, n <= 1000</code></li>
|
||||
<li><code>4 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= grid[i][j] <= 10<sup>5</sup></code></li>
|
||||
<li><code>grid[0][0] == 0</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0;
|
||||
}
|
||||
.spoiler {overflow:hidden;}
|
||||
.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
|
||||
.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
|
||||
.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
|
||||
</style>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a <strong>binary string</strong> <code>s</code>, and a <strong>2D</strong> integer array <code>queries</code> where <code>queries[i] = [first<sub>i</sub>, second<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>For the <code>i<sup>th</sup></code> query, find the <strong>shortest substring</strong> of <code>s</code> whose <strong>decimal value</strong>, <code>val</code>, yields <code>second<sub>i</sub></code> when <strong>bitwise XORed</strong> with <code>first<sub>i</sub></code>. In other words, <code>val ^ first<sub>i</sub> == second<sub>i</sub></code>.</p>
|
||||
|
||||
<p>The answer to the <code>i<sup>th</sup></code> query is the endpoints (<strong>0-indexed</strong>) of the substring <code>[left<sub>i</sub>, right<sub>i</sub>]</code> or <code>[-1, -1]</code> if no such substring exists. If there are multiple answers, choose the one with the <strong>minimum</strong> <code>left<sub>i</sub></code>.</p>
|
||||
|
||||
<p><em>Return an array</em> <code>ans</code> <em>where</em> <code>ans[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> <em>is the answer to the</em> <code>i<sup>th</sup></code> <em>query.</em></p>
|
||||
|
||||
<p>A <strong>substring</strong> is a contiguous non-empty sequence of characters within a string.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "101101", queries = [[0,5],[1,2]]
|
||||
<strong>Output:</strong> [[0,2],[2,3]]
|
||||
<strong>Explanation:</strong> For the first query the substring in range <code>[0,2]</code> is <strong>"101"</strong> which has a decimal value of <strong><code>5</code></strong>, and <strong><code>5 ^ 0 = 5</code></strong>, hence the answer to the first query is <code>[0,2]</code>. In the second query, the substring in range <code>[2,3]</code> is <strong>"11",</strong> and has a decimal value of <strong>3</strong>, and <strong>3<code> ^ 1 = 2</code></strong>. So, <code>[2,3]</code> is returned for the second query.
|
||||
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "0101", queries = [[12,8]]
|
||||
<strong>Output:</strong> [[-1,-1]]
|
||||
<strong>Explanation:</strong> In this example there is no substring that answers the query, hence <code>[-1,-1] is returned</code>.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "1", queries = [[4,5]]
|
||||
<strong>Output:</strong> [[0,0]]
|
||||
<strong>Explanation:</strong> For this example, the substring in range <code>[0,0]</code> has a decimal value of <strong><code>1</code></strong>, and <strong><code>1 ^ 4 = 5</code></strong>. So, the answer is <code>[0,0]</code>.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= first<sub>i</sub>, second<sub>i</sub> <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given a positive integer <code>n</code>, you can do the following operation <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Add or subtract a <strong>power</strong> of <code>2</code> from <code>n</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of operations to make </em><code>n</code><em> equal to </em><code>0</code>.</p>
|
||||
|
||||
<p>A number <code>x</code> is power of <code>2</code> if <code>x == 2<sup>i</sup></code> where <code>i >= 0</code><em>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 39
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can do the following operations:
|
||||
- Add 2<sup>0</sup> = 1 to n, so now n = 40.
|
||||
- Subtract 2<sup>3</sup> = 8 from n, so now n = 32.
|
||||
- Subtract 2<sup>5</sup> = 32 from n, so now n = 0.
|
||||
It can be shown that 3 is the minimum number of operations we need to make n equal to 0.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 54
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can do the following operations:
|
||||
- Add 2<sup>1</sup> = 2 to n, so now n = 56.
|
||||
- Add 2<sup>3</sup> = 8 to n, so now n = 64.
|
||||
- Subtract 2<sup>6</sup> = 64 from n, so now n = 0.
|
||||
So the minimum number of operations is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, find a <strong>0-indexed </strong>integer array <code>answer</code> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>answer.length == nums.length</code>.</li>
|
||||
<li><code>answer[i] = |leftSum[i] - rightSum[i]|</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>leftSum[i]</code> is the sum of elements to the left of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>leftSum[i] = 0</code>.</li>
|
||||
<li><code>rightSum[i]</code> is the sum of elements to the right of the index <code>i</code> in the array <code>nums</code>. If there is no such element, <code>rightSum[i] = 0</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the array</em> <code>answer</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,4,8,3]
|
||||
<strong>Output:</strong> [15,1,11,22]
|
||||
<strong>Explanation:</strong> The array leftSum is [0,10,14,22] and the array rightSum is [15,11,3,0].
|
||||
The array answer is [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1]
|
||||
<strong>Output:</strong> [0]
|
||||
<strong>Explanation:</strong> The array leftSum is [0] and the array rightSum is [0].
|
||||
The array answer is [|0 - 0|] = [0].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>word</code> of length <code>n</code> consisting of digits, and a positive integer <code>m</code>.</p>
|
||||
|
||||
<p>The <strong>divisibility array</strong> <code>div</code> of <code>word</code> is an integer array of length <code>n</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>div[i] = 1</code> if the <strong>numeric value</strong> of <code>word[0,...,i]</code> is divisible by <code>m</code>, or</li>
|
||||
<li><code>div[i] = 0</code> otherwise.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return<em> the divisibility array of</em><em> </em><code>word</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "998244353", m = 3
|
||||
<strong>Output:</strong> [1,1,0,0,0,1,1,0,0]
|
||||
<strong>Explanation:</strong> There are only 4 prefixes that are divisible by 3: "9", "99", "998244", and "9982443".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "1010", m = 10
|
||||
<strong>Output:</strong> [0,1,0,1]
|
||||
<strong>Explanation:</strong> There are only 2 prefixes that are divisible by 10: "10", and "1010".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code><font face="monospace">word.length == n</font></code></li>
|
||||
<li><code><font face="monospace">word</font></code><font face="monospace"> consists of digits from <code>0</code> to <code>9</code></font></li>
|
||||
<li><code><font face="monospace">1 <= m <= 10<sup>9</sup></font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>We define the <code>lcp</code> matrix of any <strong>0-indexed</strong> string <code>word</code> of <code>n</code> lowercase English letters as an <code>n x n</code> grid such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>lcp[i][j]</code> is equal to the length of the <strong>longest common prefix</strong> between the substrings <code>word[i,n-1]</code> and <code>word[j,n-1]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an <code>n x n</code> matrix <code>lcp</code>, return the alphabetically smallest string <code>word</code> that corresponds to <code>lcp</code>. If there is no such string, return an empty string.</p>
|
||||
|
||||
<p>A string <code>a</code> is lexicographically smaller than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears earlier in the alphabet than the corresponding letter in <code>b</code>. For example, <code>"aabd"</code> is lexicographically smaller than <code>"aaca"</code> because the first position they differ is at the third letter, and <code>'b'</code> comes before <code>'c'</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]
|
||||
<strong>Output:</strong> "abab"
|
||||
<strong>Explanation:</strong> lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is "abab".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]
|
||||
<strong>Output:</strong> "aaaa"
|
||||
<strong>Explanation:</strong> lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is "aaaa".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]
|
||||
<strong>Output:</strong> ""
|
||||
<strong>Explanation:</strong> lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == </code><code>lcp.length == </code><code>lcp[i].length</code> <code><= 1000</code></li>
|
||||
<li><code><font face="monospace">0 <= lcp[i][j] <= n</font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,71 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>The <strong>concatenation</strong> of two numbers is the number formed by concatenating their numerals.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the concatenation of <code>15</code>, <code>49</code> is <code>1549</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>concatenation value</strong> of <code>nums</code> is initially equal to <code>0</code>. Perform this operation until <code>nums</code> becomes empty:</p>
|
||||
|
||||
<ul>
|
||||
<li>If there exists more than one number in <code>nums</code>, pick the first element and last element in <code>nums</code> respectively and add the value of their concatenation to the <strong>concatenation value</strong> of <code>nums</code>, then delete the first and last element from <code>nums</code>.</li>
|
||||
<li>If one element exists, add its value to the <strong>concatenation value</strong> of <code>nums</code>, then delete it.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return<em> the concatenation value of the <code>nums</code></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [7,52,2,4]
|
||||
<strong>Output:</strong> 596
|
||||
<strong>Explanation:</strong> Before performing any operation, nums is [7,52,2,4] and concatenation value is 0.
|
||||
- In the first operation:
|
||||
We pick the first element, 7, and the last element, 4.
|
||||
Their concatenation is 74, and we add it to the concatenation value, so it becomes equal to 74.
|
||||
Then we delete them from nums, so nums becomes equal to [52,2].
|
||||
- In the second operation:
|
||||
We pick the first element, 52, and the last element, 2.
|
||||
Their concatenation is 522, and we add it to the concatenation value, so it becomes equal to 596.
|
||||
Then we delete them from the nums, so nums becomes empty.
|
||||
Since the concatenation value is 596 so the answer is 596.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,14,13,8,12]
|
||||
<strong>Output:</strong> 673
|
||||
<strong>Explanation:</strong> Before performing any operation, nums is [5,14,13,8,12] and concatenation value is 0.
|
||||
- In the first operation:
|
||||
We pick the first element, 5, and the last element, 12.
|
||||
Their concatenation is 512, and we add it to the concatenation value, so it becomes equal to 512.
|
||||
Then we delete them from the nums, so nums becomes equal to [14,13,8].
|
||||
- In the second operation:
|
||||
We pick the first element, 14, and the last element, 8.
|
||||
Their concatenation is 148, and we add it to the concatenation value, so it becomes equal to 660.
|
||||
Then we delete them from the nums, so nums becomes equal to [13].
|
||||
- In the third operation:
|
||||
nums has only one element, so we pick 13 and add it to the concatenation value, so it becomes equal to 673.
|
||||
Then we delete it from nums, so nums become empty.
|
||||
Since the concatenation value is 673 so the answer is 673.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0;
|
||||
}
|
||||
.spoiler {overflow:hidden;}
|
||||
.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
|
||||
.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
|
||||
.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
|
||||
</style>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given a positive integer <strong>0-indexed</strong> array <code>nums</code>.</p>
|
||||
|
||||
<p>A subset of the array <code>nums</code> is <strong>square-free</strong> if the product of its elements is a <strong>square-free integer</strong>.</p>
|
||||
|
||||
<p>A <strong>square-free integer</strong> is an integer that is divisible by no square number other than <code>1</code>.</p>
|
||||
|
||||
<p>Return <em>the number of square-free non-empty subsets of the array</em> <strong>nums</strong>. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p>A <strong>non-empty</strong> <strong>subset</strong> of <code>nums</code> is an array that can be obtained by deleting some (possibly none but not all) elements from <code>nums</code>. Two subsets are different if and only if the chosen indices to delete are different.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,4,4,5]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> There are 3 square-free subsets in this example:
|
||||
- The subset consisting of the 0<sup>th</sup> element [3]. The product of its elements is 3, which is a square-free integer.
|
||||
- The subset consisting of the 3<sup>rd</sup> element [5]. The product of its elements is 5, which is a square-free integer.
|
||||
- The subset consisting of 0<sup>th</sup> and 3<sup>rd</sup> elements [3,5]. The product of its elements is 15, which is a square-free integer.
|
||||
It can be proven that there are no more than 3 square-free subsets in the given array.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> There is 1 square-free subset in this example:
|
||||
- The subset consisting of the 0<sup>th</sup> element [1]. The product of its elements is 1, which is a square-free integer.
|
||||
It can be proven that there is no more than 1 square-free subset in the given array.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 30</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given two <strong>0-indexed</strong> arrays <code>nums1</code> and <code>nums2</code> and a 2D array <code>queries</code> of queries. There are three types of queries:</p>
|
||||
|
||||
<ol>
|
||||
<li>For a query of type 1, <code>queries[i] = [1, l, r]</code>. Flip the values from <code>0</code> to <code>1</code> and from <code>1</code> to <code>0</code> in <code>nums1 </code>from index <code>l</code> to index <code>r</code>. Both <code>l</code> and <code>r</code> are <strong>0-indexed</strong>.</li>
|
||||
<li>For a query of type 2, <code>queries[i] = [2, p, 0]</code>. For every index <code>0 <= i < n</code>, set <code>nums2[i] = nums2[i] + nums1[i] * p</code>.</li>
|
||||
<li>For a query of type 3, <code>queries[i] = [3, 0, 0]</code>. Find the sum of the elements in <code>nums2</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>an array containing all the answers to the third type queries.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,0,1], nums2 = [0,0,0], queries = [[1,1,1],[2,1,0],[3,0,0]]
|
||||
<strong>Output:</strong> [3]
|
||||
<strong>Explanation:</strong> After the first query nums1 becomes [1,1,1]. After the second query, nums2 becomes [1,1,1], so the answer to the third query is 3. Thus, [3] is returned.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1], nums2 = [5], queries = [[2,0,0],[3,0,0]]
|
||||
<strong>Output:</strong> [5]
|
||||
<strong>Explanation:</strong> After the first query, nums2 remains [5], so the answer to the second query is 5. Thus, [5] is returned.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length,nums2.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>nums1.length = nums2.length</code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code><font face="monospace">queries[i].length = 3</font></code></li>
|
||||
<li><code><font face="monospace">0 <= l <= r <= nums1.length - 1</font></code></li>
|
||||
<li><code><font face="monospace">0 <= p <= 10<sup>6</sup></font></code></li>
|
||||
<li><code>0 <= nums1[i] <= 1</code></li>
|
||||
<li><code>0 <= nums2[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given an integer <code>num</code>. You know that Danny Mittal will sneakily <strong>remap</strong> one of the <code>10</code> possible digits (<code>0</code> to <code>9</code>) to another digit.</p>
|
||||
|
||||
<p>Return <em>the difference between the maximum and minimum</em><em> values Danny can make by remapping <strong>exactly</strong> <strong>one</strong> digit</em><em> in </em><code>num</code>.</p>
|
||||
|
||||
<p><strong>Notes:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>When Danny remaps a digit <font face="monospace">d1</font> to another digit <font face="monospace">d2</font>, Danny replaces all occurrences of <code>d1</code> in <code>num</code> with <code>d2</code>.</li>
|
||||
<li>Danny can remap a digit to itself, in which case <code>num</code> does not change.</li>
|
||||
<li>Danny can remap different digits for obtaining minimum and maximum values respectively.</li>
|
||||
<li>The resulting number after remapping can contain leading zeroes.</li>
|
||||
<li>We mentioned "Danny Mittal" to congratulate him on being in the top 10 in Weekly Contest 326.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 11891
|
||||
<strong>Output:</strong> 99009
|
||||
<strong>Explanation:</strong>
|
||||
To achieve the maximum value, Danny can remap the digit 1 to the digit 9 to yield 99899.
|
||||
To achieve the minimum value, Danny can remap the digit 1 to the digit 0, yielding 890.
|
||||
The difference between these two numbers is 99009.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 90
|
||||
<strong>Output:</strong> 99
|
||||
<strong>Explanation:</strong>
|
||||
The maximum value that can be returned by the function is 99 (if 0 is replaced by 9) and the minimum value that can be returned by the function is 0 (if 9 is replaced by 0).
|
||||
Thus, we return 99.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num <= 10<sup>8</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>We say that an integer x is <strong>expressible</strong> from <code>nums</code> if there exist some integers <code>0 <= index<sub>1</sub> < index<sub>2</sub> < ... < index<sub>k</sub> < nums.length</code> for which <code>nums[index<sub>1</sub>] | nums[index<sub>2</sub>] | ... | nums[index<sub>k</sub>] = x</code>. In other words, an integer is expressible if it can be written as the bitwise OR of some subsequence of <code>nums</code>.</p>
|
||||
|
||||
<p>Return <em>the minimum <strong>positive non-zero integer</strong> that is not </em><em>expressible from </em><code>nums</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> 1 and 2 are already present in the array. We know that 3 is expressible, since nums[0] | nums[1] = 2 | 1 = 3. Since 4 is not expressible, we return 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,3,2]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> We can show that 1 is the smallest number that is not expressible.
|
||||
</pre>
|
||||
|
||||
<p> </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,45 @@
|
||||
<p>You are given two strings <code>s</code> and <code>t</code>.</p>
|
||||
|
||||
<p>You are allowed to remove any number of characters from the string <code>t</code>.</p>
|
||||
|
||||
<p>The score of the string is <code>0</code> if no characters are removed from the string <code>t</code>, otherwise:</p>
|
||||
|
||||
<ul>
|
||||
<li>Let <code>left</code> be the minimum index among all removed characters.</li>
|
||||
<li>Let <code>right</code> be the maximum index among all removed characters.</li>
|
||||
</ul>
|
||||
|
||||
<p>Then the score of the string is <code>right - left + 1</code>.</p>
|
||||
|
||||
<p>Return <em>the minimum possible score to make </em><code>t</code><em> a subsequence of </em><code>s</code><em>.</em></p>
|
||||
|
||||
<p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>"ace"</code> is a subsequence of <code>"<u>a</u>b<u>c</u>d<u>e</u>"</code> while <code>"aec"</code> is not).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abacaba", t = "bzaa"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> In this example, we remove the character "z" at index 1 (0-indexed).
|
||||
The string t becomes "baa" which is a subsequence of the string "abacaba" and the score is 1 - 1 + 1 = 1.
|
||||
It can be proven that 1 is the minimum score that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "cde", t = "xyz"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> In this example, we remove characters "x", "y" and "z" at indices 0, 1, and 2 (0-indexed).
|
||||
The string t becomes "" which is a subsequence of the string "cde" and the score is 2 - 0 + 1 = 3.
|
||||
It can be proven that 3 is the minimum score that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length, t.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> and <code>t</code> consist of only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,55 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Pick two <strong>different unmarked</strong> indices <code>i</code> and <code>j</code> such that <code>2 * nums[i] <= nums[j]</code>, then mark <code>i</code> and <code>j</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the maximum possible number of marked indices in <code>nums</code> using the above operation any number of times</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,5,2,4]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation: </strong>In the first operation: pick i = 2 and j = 1, the operation is allowed because 2 * nums[2] <= nums[1]. Then mark index 2 and 1.
|
||||
It can be shown that there's no other valid operation so the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [9,2,5,4]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation: </strong>In the first operation: pick i = 3 and j = 0, the operation is allowed because 2 * nums[3] <= nums[0]. Then mark index 3 and 0.
|
||||
In the second operation: pick i = 1 and j = 2, the operation is allowed because 2 * nums[1] <= nums[2]. Then mark index 1 and 2.
|
||||
Since there is no other operation, the answer is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [7,6,8]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation: </strong>There is no valid operation to do, so the answer is 0.
|
||||
|
||||
</pre>
|
||||
|
||||
<p> </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>
|
||||
|
||||
<p> </p>
|
||||
<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0;
|
||||
}
|
||||
.spoiler {overflow:hidden;}
|
||||
.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
|
||||
.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
|
||||
.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
|
||||
</style>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given a <strong>0-indexed</strong> integer array <code>nums</code> of size <code>n</code> and two integers <code>lower</code> and <code>upper</code>, return <em>the number of fair pairs</em>.</p>
|
||||
|
||||
<p>A pair <code>(i, j)</code> is <b>fair </b>if:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= i < j < n</code>, and</li>
|
||||
<li><code>lower <= nums[i] + nums[j] <= upper</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1,7,4,4,5], lower = 3, upper = 6
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,7,9,2,5], lower = 11, upper = 11
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> There is a single fair pair: (2,3).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>nums.length == n</code></li>
|
||||
<li><code><font face="monospace">-10<sup>9</sup></font> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code><font face="monospace">-10<sup>9</sup> <= lower <= upper <= 10<sup>9</sup></font></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user