mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-03 06:22:54 +08:00
update
This commit is contained in:
zhangbk1
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
171
leetcode/originData/convert-date-to-binary.json
Normal file
171
leetcode/originData/convert-date-to-binary.json
Normal file
File diff suppressed because one or more lines are too long
197
leetcode/originData/find-a-safe-walk-through-a-grid.json
Normal file
197
leetcode/originData/find-a-safe-walk-through-a-grid.json
Normal file
File diff suppressed because one or more lines are too long
165
leetcode/originData/find-indices-of-stable-mountains.json
Normal file
165
leetcode/originData/find-indices-of-stable-mountains.json
Normal file
File diff suppressed because one or more lines are too long
186
leetcode/originData/find-the-count-of-good-integers.json
Normal file
186
leetcode/originData/find-the-count-of-good-integers.json
Normal file
File diff suppressed because one or more lines are too long
165
leetcode/originData/find-the-key-of-the-numbers.json
Normal file
165
leetcode/originData/find-the-key-of-the-numbers.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
175
leetcode/originData/hash-divided-string.json
Normal file
175
leetcode/originData/hash-divided-string.json
Normal file
File diff suppressed because one or more lines are too long
175
leetcode/originData/k-th-nearest-obstacle-queries.json
Normal file
175
leetcode/originData/k-th-nearest-obstacle-queries.json
Normal file
File diff suppressed because one or more lines are too long
182
leetcode/originData/length-of-the-longest-increasing-path.json
Normal file
182
leetcode/originData/length-of-the-longest-increasing-path.json
Normal file
File diff suppressed because one or more lines are too long
187
leetcode/originData/maximize-score-of-numbers-in-ranges.json
Normal file
187
leetcode/originData/maximize-score-of-numbers-in-ranges.json
Normal file
File diff suppressed because one or more lines are too long
174
leetcode/originData/maximum-multiplication-score.json
Normal file
174
leetcode/originData/maximum-multiplication-score.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
175
leetcode/originData/maximum-xor-score-subarray-queries.json
Normal file
175
leetcode/originData/maximum-xor-score-subarray-queries.json
Normal file
File diff suppressed because one or more lines are too long
180
leetcode/originData/minimum-amount-of-damage-dealt-to-bob.json
Normal file
180
leetcode/originData/minimum-amount-of-damage-dealt-to-bob.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
173
leetcode/originData/reach-end-of-array-with-max-score.json
Normal file
173
leetcode/originData/reach-end-of-array-with-max-score.json
Normal file
File diff suppressed because one or more lines are too long
192
leetcode/originData/select-cells-in-grid-with-maximum-score.json
Normal file
192
leetcode/originData/select-cells-in-grid-with-maximum-score.json
Normal file
File diff suppressed because one or more lines are too long
179
leetcode/originData/the-two-sneaky-numbers-of-digitville.json
Normal file
179
leetcode/originData/the-two-sneaky-numbers-of-digitville.json
Normal file
File diff suppressed because one or more lines are too long
@@ -0,0 +1,43 @@
|
||||
<p>You are given two strings, <code>coordinate1</code> and <code>coordinate2</code>, representing the coordinates of a square on an <code>8 x 8</code> chessboard.</p>
|
||||
|
||||
<p>Below is the chessboard for reference.</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/17/screenshot-2021-02-20-at-22159-pm.png" style="width: 400px; height: 396px;" /></p>
|
||||
|
||||
<p>Return <code>true</code> if these two squares have the same color and <code>false</code> otherwise.</p>
|
||||
|
||||
<p>The coordinate will always represent a valid chessboard square. The coordinate will always have the letter first (indicating its column), and the number second (indicating its row).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">coordinate1 = "a1", coordinate2 = "c3"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">true</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Both squares are black.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">coordinate1 = "a1", coordinate2 = "h3"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">false</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Square <code>"a1"</code> is black and <code>"h3"</code> is white.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>coordinate1.length == coordinate2.length == 2</code></li>
|
||||
<li><code>'a' <= coordinate1[0], coordinate2[0] <= 'h'</code></li>
|
||||
<li><code>'1' <= coordinate1[1], coordinate2[1] <= '8'</code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/convert-date-to-binary.html
Normal file
39
leetcode/problem/convert-date-to-binary.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>You are given a string <code>date</code> representing a Gregorian calendar date in the <code>yyyy-mm-dd</code> format.</p>
|
||||
|
||||
<p><code>date</code> can be written in its binary representation obtained by converting year, month, and day to their binary representations without any leading zeroes and writing them down in <code>year-month-day</code> format.</p>
|
||||
|
||||
<p>Return the <strong>binary</strong> representation of <code>date</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">date = "2080-02-29"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">"100000100000-10-11101"</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><span class="example-io">100000100000, 10, and 11101 are the binary representations of 2080, 02, and 29 respectively.</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">date = "1900-01-01"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">"11101101100-1-1"</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><span class="example-io">11101101100, 1, and 1 are the binary representations of 1900, 1, and 1 respectively.</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>date.length == 10</code></li>
|
||||
<li><code>date[4] == date[7] == '-'</code>, and all other <code>date[i]</code>'s are digits.</li>
|
||||
<li>The input is generated such that <code>date</code> represents a valid Gregorian calendar date between Jan 1<sup>st</sup>, 1900 and Dec 31<sup>st</sup>, 2100 (both inclusive).</li>
|
||||
</ul>
|
||||
62
leetcode/problem/find-a-safe-walk-through-a-grid.html
Normal file
62
leetcode/problem/find-a-safe-walk-through-a-grid.html
Normal file
@@ -0,0 +1,62 @@
|
||||
<p>You are given an <code>m x n</code> binary matrix <code>grid</code> and an integer <code>health</code>.</p>
|
||||
|
||||
<p>You start on the upper-left corner <code>(0, 0)</code> and would like to get to the lower-right corner <code>(m - 1, n - 1)</code>.</p>
|
||||
|
||||
<p>You can move up, down, left, or right from one cell to another adjacent cell as long as your health <em>remains</em> <strong>positive</strong>.</p>
|
||||
|
||||
<p>Cells <code>(i, j)</code> with <code>grid[i][j] = 1</code> are considered <strong>unsafe</strong> and reduce your health by 1.</p>
|
||||
|
||||
<p>Return <code>true</code> if you can reach the final cell with a health value of 1 or more, and <code>false</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">true</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The final cell can be reached safely by walking along the gray cells below.</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2024/08/04/3868_examples_1drawio.png" style="width: 301px; height: 121px;" /></div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">false</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>A minimum of 4 health points is needed to reach the final cell safely.</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2024/08/04/3868_examples_2drawio.png" style="width: 361px; height: 161px;" /></div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">true</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The final cell can be reached safely by walking along the gray cells below.</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/04/3868_examples_3drawio.png" style="width: 181px; height: 121px;" /></p>
|
||||
|
||||
<p>Any path that does not go through the cell <code>(1, 1)</code> is unsafe since your health will drop to 0 when reaching the final cell.</p>
|
||||
</div>
|
||||
|
||||
<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>1 <= m, n <= 50</code></li>
|
||||
<li><code><font face="monospace">2 <= m * n</font></code></li>
|
||||
<li><code>1 <= health <= m + n</code></li>
|
||||
<li><code>grid[i][j]</code> is either 0 or 1.</li>
|
||||
</ul>
|
||||
46
leetcode/problem/find-indices-of-stable-mountains.html
Normal file
46
leetcode/problem/find-indices-of-stable-mountains.html
Normal file
@@ -0,0 +1,46 @@
|
||||
<p>There are <code>n</code> mountains in a row, and each mountain has a height. You are given an integer array <code>height</code> where <code>height[i]</code> represents the height of mountain <code>i</code>, and an integer <code>threshold</code>.</p>
|
||||
|
||||
<p>A mountain is called <strong>stable</strong> if the mountain just before it (<strong>if it exists</strong>) has a height <strong>strictly greater</strong> than <code>threshold</code>. <strong>Note</strong> that mountain 0 is <strong>not</strong> stable.</p>
|
||||
|
||||
<p>Return an array containing the indices of <em>all</em> <strong>stable</strong> mountains in <strong>any</strong> order.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">height = [1,2,3,4,5], threshold = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[3,4]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Mountain 3 is stable because <code>height[2] == 3</code> is greater than <code>threshold == 2</code>.</li>
|
||||
<li>Mountain 4 is stable because <code>height[3] == 4</code> is greater than <code>threshold == 2</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">height = [10,1,10,1,10], threshold = 3</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[1,3]</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">height = [10,1,10,1,10], threshold = 10</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[]</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n == height.length <= 100</code></li>
|
||||
<li><code>1 <= height[i] <= 100</code></li>
|
||||
<li><code>1 <= threshold <= 100</code></li>
|
||||
</ul>
|
||||
60
leetcode/problem/find-the-count-of-good-integers.html
Normal file
60
leetcode/problem/find-the-count-of-good-integers.html
Normal file
@@ -0,0 +1,60 @@
|
||||
<p>You are given two <strong>positive</strong> integers <code>n</code> and <code>k</code>.</p>
|
||||
|
||||
<p>An integer <code>x</code> is called <strong>k-palindromic</strong> if:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>x</code> is a <span data-keyword="palindrome-integer">palindrome</span>.</li>
|
||||
<li><code>x</code> is divisible by <code>k</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>An integer is called <strong>good</strong> if its digits can be <em>rearranged</em> to form a <strong>k-palindromic</strong> integer. For example, for <code>k = 2</code>, 2020 can be rearranged to form the <em>k-palindromic</em> integer 2002, whereas 1010 cannot be rearranged to form a <em>k-palindromic</em> integer.</p>
|
||||
|
||||
<p>Return the count of <strong>good</strong> integers containing <code>n</code> digits.</p>
|
||||
|
||||
<p><strong>Note</strong> that <em>any</em> integer must <strong>not</strong> have leading zeros, <strong>neither</strong> before <strong>nor</strong> after rearrangement. For example, 1010 <em>cannot</em> be rearranged to form 101.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">n = 3, k = 5</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">27</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><em>Some</em> of the good integers are:</p>
|
||||
|
||||
<ul>
|
||||
<li>551 because it can be rearranged to form 515.</li>
|
||||
<li>525 because it is already k-palindromic.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">n = 1, k = 4</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The two good integers are 4 and 8.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">n = 5, k = 6</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2468</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10</code></li>
|
||||
<li><code>1 <= k <= 9</code></li>
|
||||
</ul>
|
||||
55
leetcode/problem/find-the-key-of-the-numbers.html
Normal file
55
leetcode/problem/find-the-key-of-the-numbers.html
Normal file
@@ -0,0 +1,55 @@
|
||||
<p>You are given three <strong>positive</strong> integers <code>num1</code>, <code>num2</code>, and <code>num3</code>.</p>
|
||||
|
||||
<p>The <code>key</code> of <code>num1</code>, <code>num2</code>, and <code>num3</code> is defined as a four-digit number such that:</p>
|
||||
|
||||
<ul>
|
||||
<li>Initially, if any number has <strong>less than</strong> four digits, it is padded with <strong>leading zeros</strong>.</li>
|
||||
<li>The <code>i<sup>th</sup></code> digit (<code>1 <= i <= 4</code>) of the <code>key</code> is generated by taking the <strong>smallest</strong> digit among the <code>i<sup>th</sup></code> digits of <code>num1</code>, <code>num2</code>, and <code>num3</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <code>key</code> of the three numbers <strong>without</strong> leading zeros (<em>if any</em>).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">num1 = 1, num2 = 10, num3 = 1000</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">0</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>On padding, <code>num1</code> becomes <code>"0001"</code>, <code>num2</code> becomes <code>"0010"</code>, and <code>num3</code> remains <code>"1000"</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>The <code>1<sup>st</sup></code> digit of the <code>key</code> is <code>min(0, 0, 1)</code>.</li>
|
||||
<li>The <code>2<sup>nd</sup></code> digit of the <code>key</code> is <code>min(0, 0, 0)</code>.</li>
|
||||
<li>The <code>3<sup>rd</sup></code> digit of the <code>key</code> is <code>min(0, 1, 0)</code>.</li>
|
||||
<li>The <code>4<sup>th</sup></code> digit of the <code>key</code> is <code>min(1, 0, 0)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Hence, the <code>key</code> is <code>"0000"</code>, i.e. 0.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">num1 = 987, num2 = 879, num3 = 798</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">777</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">num1 = 1, num2 = 2, num3 = 3</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num1, num2, num3 <= 9999</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>You are given an integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.</p>
|
||||
|
||||
<p>The <strong>value</strong> of a sequence <code>seq</code> of size <code>2 * x</code> is defined as:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1])</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <strong>maximum</strong> <strong>value</strong> of any <span data-keyword="subsequence-array">subsequence</span> of <code>nums</code> having size <code>2 * k</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [2,6,7], k = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">5</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The subsequence <code>[2, 7]</code> has the maximum value of <code>2 XOR 7 = 5</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [4,2,5,6,7], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The subsequence <code>[4, 5, 6, 7]</code> has the maximum value of <code>(4 OR 5) XOR (6 OR 7) = 2</code>.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 400</code></li>
|
||||
<li><code>1 <= nums[i] < 2<sup>7</sup></code></li>
|
||||
<li><code>1 <= k <= nums.length / 2</code></li>
|
||||
</ul>
|
||||
52
leetcode/problem/hash-divided-string.html
Normal file
52
leetcode/problem/hash-divided-string.html
Normal file
@@ -0,0 +1,52 @@
|
||||
<p>You are given a string <code>s</code> of length <code>n</code> and an integer <code>k</code>, where <code>n</code> is a <strong>multiple</strong> of <code>k</code>. Your task is to hash the string <code>s</code> into a new string called <code>result</code>, which has a length of <code>n / k</code>.</p>
|
||||
|
||||
<p>First, divide <code>s</code> into <code>n / k</code> <strong><span data-keyword="substring-nonempty">substrings</span></strong>, each with a length of <code>k</code>. Then, initialize <code>result</code> as an <strong>empty</strong> string.</p>
|
||||
|
||||
<p>For each <strong>substring</strong> in order from the beginning:</p>
|
||||
|
||||
<ul>
|
||||
<li>The <strong>hash value</strong> of a character is the index of that characte<!-- notionvc: 4b67483a-fa95-40b6-870d-2eacd9bc18d8 -->r in the <strong>English alphabet</strong> (e.g., <code>'a' →<!-- notionvc: d3f8e4c2-23cd-41ad-a14b-101dfe4c5aba --> 0</code>, <code>'b' →<!-- notionvc: d3f8e4c2-23cd-41ad-a14b-101dfe4c5aba --> 1</code>, ..., <code>'z' →<!-- notionvc: d3f8e4c2-23cd-41ad-a14b-101dfe4c5aba --> 25</code>).</li>
|
||||
<li>Calculate the <em>sum</em> of all the <strong>hash values</strong> of the characters in the substring.</li>
|
||||
<li>Find the remainder of this sum when divided by 26, which is called <code>hashedChar</code>.</li>
|
||||
<li>Identify the character in the English lowercase alphabet that corresponds to <code>hashedChar</code>.</li>
|
||||
<li>Append that character to the end of <code>result</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <code>result</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abcd", k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">"bf"</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>First substring: <code>"ab"</code>, <code>0 + 1 = 1</code>, <code>1 % 26 = 1</code>, <code>result[0] = 'b'</code>.</p>
|
||||
|
||||
<p>Second substring: <code>"cd"</code>, <code>2 + 3 = 5</code>, <code>5 % 26 = 5</code>, <code>result[1] = 'f'</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "mxz", k = 3</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">"i"</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The only substring: <code>"mxz"</code>, <code>12 + 23 + 25 = 60</code>, <code>60 % 26 = 8</code>, <code>result[0] = 'i'</code>.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= 100</code></li>
|
||||
<li><code>k <= s.length <= 1000</code></li>
|
||||
<li><code>s.length</code> is divisible by <code>k</code>.</li>
|
||||
<li><code>s</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
60
leetcode/problem/k-th-nearest-obstacle-queries.html
Normal file
60
leetcode/problem/k-th-nearest-obstacle-queries.html
Normal file
@@ -0,0 +1,60 @@
|
||||
<p>There is an infinite 2D plane.</p>
|
||||
|
||||
<p>You are given a positive integer <code>k</code>. You are also given a 2D array <code>queries</code>, which contains the following queries:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>queries[i] = [x, y]</code>: Build an obstacle at coordinate <code>(x, y)</code> in the plane. It is guaranteed that there is <strong>no</strong> obstacle at this coordinate when this query is made.</li>
|
||||
</ul>
|
||||
|
||||
<p>After each query, you need to find the <strong>distance</strong> of the <code>k<sup>th</sup></code> <strong>nearest</strong> obstacle from the origin.</p>
|
||||
|
||||
<p>Return an integer array <code>results</code> where <code>results[i]</code> denotes the <code>k<sup>th</sup></code> nearest obstacle after query <code>i</code>, or <code>results[i] == -1</code> if there are less than <code>k</code> obstacles.</p>
|
||||
|
||||
<p><strong>Note</strong> that initially there are <strong>no</strong> obstacles anywhere.</p>
|
||||
|
||||
<p>The <strong>distance</strong> of an obstacle at coordinate <code>(x, y)</code> from the origin is given by <code>|x| + |y|</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[-1,7,5,3]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Initially, there are 0 obstacles.</li>
|
||||
<li>After <code>queries[0]</code>, there are less than 2 obstacles.</li>
|
||||
<li>After <code>queries[1]</code>, there are obstacles at distances 3 and 7.</li>
|
||||
<li>After <code>queries[2]</code>, there are obstacles at distances 3, 5, and 7.</li>
|
||||
<li>After <code>queries[3]</code>, there are obstacles at distances 3, 3, 5, and 7.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">queries = [[5,5],[4,4],[3,3]], k = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[10,8,6]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>After <code>queries[0]</code>, there is an obstacle at distance 10.</li>
|
||||
<li>After <code>queries[1]</code>, there are obstacles at distances 8 and 10.</li>
|
||||
<li>After <code>queries[2]</code>, there are obstacles at distances 6, 8, and 10.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= queries.length <= 2 * 10<sup>5</sup></code></li>
|
||||
<li>All <code>queries[i]</code> are unique.</li>
|
||||
<li><code>-10<sup>9</sup> <= queries[i][0], queries[i][1] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
48
leetcode/problem/length-of-the-longest-increasing-path.html
Normal file
48
leetcode/problem/length-of-the-longest-increasing-path.html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>You are given a 2D array of integers <code>coordinates</code> of length <code>n</code> and an integer <code>k</code>, where <code>0 <= k < n</code>.</p>
|
||||
|
||||
<p><code>coordinates[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> indicates the point <code>(x<sub>i</sub>, y<sub>i</sub>)</code> in a 2D plane.</p>
|
||||
|
||||
<p>An <strong>increasing path</strong> of length <code>m</code> is defined as a list of points <code>(x<sub>1</sub>, y<sub>1</sub>)</code>, <code>(x<sub>2</sub>, y<sub>2</sub>)</code>, <code>(x<sub>3</sub>, y<sub>3</sub>)</code>, ..., <code>(x<sub>m</sub>, y<sub>m</sub>)</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>x<sub>i</sub> < x<sub>i + 1</sub></code> and <code>y<sub>i</sub> < y<sub>i + 1</sub></code> for all <code>i</code> where <code>1 <= i < m</code>.</li>
|
||||
<li><code>(x<sub>i</sub>, y<sub>i</sub>)</code> is in the given coordinates for all <code>i</code> where <code>1 <= i <= m</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <strong>maximum</strong> length of an <strong>increasing path</strong> that contains <code>coordinates[k]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">coordinates = [[3,1],[2,2],[4,1],[0,0],[5,3]], k = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><code>(0, 0)</code>, <code>(2, 2)</code>, <code>(5, 3)</code><!-- notionvc: 082cee9e-4ce5-4ede-a09d-57001a72141d --> is the longest increasing path that contains <code>(2, 2)</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">coordinates = [[2,1],[7,0],[5,6]], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><code>(2, 1)</code>, <code>(5, 6)</code> is the longest increasing path that contains <code>(5, 6)</code>.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == coordinates.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>coordinates[i].length == 2</code></li>
|
||||
<li><code>0 <= coordinates[i][0], coordinates[i][1] <= 10<sup>9</sup></code></li>
|
||||
<li>All elements in <code>coordinates</code> are <strong>distinct</strong>.<!-- notionvc: 6e412fc2-f9dd-4ba2-b796-5e802a2b305a --><!-- notionvc: c2cf5618-fe99-4909-9b4c-e6b068be22a6 --></li>
|
||||
<li><code>0 <= k <= n - 1</code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/maximize-score-of-numbers-in-ranges.html
Normal file
39
leetcode/problem/maximize-score-of-numbers-in-ranges.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>You are given an array of integers <code>start</code> and an integer <code>d</code>, representing <code>n</code> intervals <code>[start[i], start[i] + d]</code>.</p>
|
||||
|
||||
<p>You are asked to choose <code>n</code> integers where the <code>i<sup>th</sup></code> integer must belong to the <code>i<sup>th</sup></code> interval. The <strong>score</strong> of the chosen integers is defined as the <strong>minimum</strong> absolute difference between any two integers that have been chosen.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> <em>possible score</em> of the chosen integers.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">start = [6,0,3], d = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The maximum possible score can be obtained by choosing integers: 8, 0, and 4. The score of these chosen integers is <code>min(|8 - 0|, |8 - 4|, |0 - 4|)</code> which equals 4.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">start = [2,6,13,13], d = 5</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">5</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The maximum possible score can be obtained by choosing integers: 2, 7, 13, and 18. The score of these chosen integers is <code>min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|)</code> which equals 5.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= start.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= start[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= d <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/maximum-multiplication-score.html
Normal file
37
leetcode/problem/maximum-multiplication-score.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>You are given an integer array <code>a</code> of size 4 and another integer array <code>b</code> of size <strong>at least</strong> 4.</p>
|
||||
|
||||
<p>You need to choose 4 indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, and <code>i<sub>3</sub></code> from the array <code>b</code> such that <code>i<sub>0</sub> < i<sub>1</sub> < i<sub>2</sub> < i<sub>3</sub></code>. Your score will be equal to the value <code>a[0] * b[i<sub>0</sub>] + a[1] * b[i<sub>1</sub>] + a[2] * b[i<sub>2</sub>] + a[3] * b[i<sub>3</sub>]</code>.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> score you can achieve.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">26</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong><br />
|
||||
We can choose the indices 0, 1, 2, and 5. The score will be <code>3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">-1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong><br />
|
||||
We can choose the indices 0, 1, 3, and 4. The score will be <code>(-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1</code>.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>a.length == 4</code></li>
|
||||
<li><code>4 <= b.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>5</sup> <= a[i], b[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,76 @@
|
||||
<p>There is a <code>50 x 50</code> chessboard with <strong>one</strong> knight and some pawns on it. You are given two integers <code>kx</code> and <code>ky</code> where <code>(kx, ky)</code> denotes the position of the knight, and a 2D array <code>positions</code> where <code>positions[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> denotes the position of the pawns on the chessboard.</p>
|
||||
|
||||
<p>Alice and Bob play a <em>turn-based</em> game, where Alice goes first. In each player's turn:</p>
|
||||
|
||||
<ul>
|
||||
<li>The player <em>selects </em>a pawn that still exists on the board and captures it with the knight in the <strong>fewest</strong> possible <strong>moves</strong>. <strong>Note</strong> that the player can select <strong>any</strong> pawn, it <strong>might not</strong> be one that can be captured in the <strong>least</strong> number of moves.</li>
|
||||
<li><span>In the process of capturing the <em>selected</em> pawn, the knight <strong>may</strong> pass other pawns <strong>without</strong> capturing them</span>. <strong>Only</strong> the <em>selected</em> pawn can be captured in <em>this</em> turn.</li>
|
||||
</ul>
|
||||
|
||||
<p>Alice is trying to <strong>maximize</strong> the <strong>sum</strong> of the number of moves made by <em>both</em> players until there are no more pawns on the board, whereas Bob tries to <strong>minimize</strong> them.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> <em>total</em> number of moves made during the game that Alice can achieve, assuming both players play <strong>optimally</strong>.</p>
|
||||
|
||||
<p>Note that in one <strong>move, </strong>a chess knight has eight possible positions it can move to, as illustrated below. Each move is two cells in a cardinal direction, then one cell in an orthogonal direction.</p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2024/08/01/chess_knight.jpg" style="width: 275px; height: 273px;" /></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">kx = 1, ky = 1, positions = [[0,0]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/16/gif3.gif" style="width: 275px; height: 275px;" /></p>
|
||||
|
||||
<p>The knight takes 4 moves to reach the pawn at <code>(0, 0)</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">8</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2024/08/16/gif4.gif" style="width: 320px; height: 320px;" /></strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Alice picks the pawn at <code>(2, 2)</code> and captures it in two moves: <code>(0, 2) -> (1, 4) -> (2, 2)</code>.</li>
|
||||
<li>Bob picks the pawn at <code>(3, 3)</code> and captures it in two moves: <code>(2, 2) -> (4, 1) -> (3, 3)</code>.</li>
|
||||
<li>Alice picks the pawn at <code>(1, 1)</code> and captures it in four moves: <code>(3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1)</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">kx = 0, ky = 0, positions = [[1,2],[2,4]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Alice picks the pawn at <code>(2, 4)</code> and captures it in two moves: <code>(0, 0) -> (1, 2) -> (2, 4)</code>. Note that the pawn at <code>(1, 2)</code> is not captured.</li>
|
||||
<li>Bob picks the pawn at <code>(1, 2)</code> and captures it in one move: <code>(2, 4) -> (1, 2)</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= kx, ky <= 49</code></li>
|
||||
<li><code>1 <= positions.length <= 15</code></li>
|
||||
<li><code>positions[i].length == 2</code></li>
|
||||
<li><code>0 <= positions[i][0], positions[i][1] <= 49</code></li>
|
||||
<li>All <code>positions[i]</code> are unique.</li>
|
||||
<li>The input is generated such that <code>positions[i] != [kx, ky]</code> for all <code>0 <= i < positions.length</code>.</li>
|
||||
</ul>
|
||||
94
leetcode/problem/maximum-xor-score-subarray-queries.html
Normal file
94
leetcode/problem/maximum-xor-score-subarray-queries.html
Normal file
@@ -0,0 +1,94 @@
|
||||
<p>You are given an array <code>nums</code> of <code>n</code> integers, and a 2D integer array <code>queries</code> of size <code>q</code>, where <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>For each query, you must find the <strong>maximum XOR score</strong> of any <span data-keyword="subarray">subarray</span> of <code>nums[l<sub>i</sub>..r<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>The <strong>XOR score</strong> of an array <code>a</code> is found by repeatedly applying the following operations on <code>a</code> so that only one element remains, that is the <strong>score</strong>:</p>
|
||||
|
||||
<ul>
|
||||
<li>Simultaneously replace <code>a[i]</code> with <code>a[i] XOR a[i + 1]</code> for all indices <code>i</code> except the last one.</li>
|
||||
<li>Remove the last element of <code>a</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return an array <code>answer</code> of size <code>q</code> where <code>answer[i]</code> is the answer to query <code>i</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[12,60,60]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>In the first query, <code>nums[0..2]</code> has 6 subarrays <code>[2]</code>, <code>[8]</code>, <code>[4]</code>, <code>[2, 8]</code>, <code>[8, 4]</code>, and <code>[2, 8, 4]</code> each with a respective XOR score of 2, 8, 4, 10, 12, and 6. The answer for the query is 12, the largest of all XOR scores.</p>
|
||||
|
||||
<p>In the second query, the subarray of <code>nums[1..4]</code> with the largest XOR score is <code>nums[1..4]</code> with a score of 60.</p>
|
||||
|
||||
<p>In the third query, the subarray of <code>nums[0..5]</code> with the largest XOR score is <code>nums[1..4]</code> with a score of 60.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[7,14,11,14,5]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<table height="70" width="472">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Index</th>
|
||||
<th>nums[l<sub>i</sub>..r<sub>i</sub>]</th>
|
||||
<th>Maximum XOR Score Subarray</th>
|
||||
<th>Maximum Subarray XOR Score</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>0</td>
|
||||
<td>[0, 7, 3, 2]</td>
|
||||
<td>[7]</td>
|
||||
<td>7</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>[7, 3, 2, 8, 5]</td>
|
||||
<td>[7, 3, 2, 8]</td>
|
||||
<td>14</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>[3, 2, 8]</td>
|
||||
<td>[3, 2, 8]</td>
|
||||
<td>11</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>3</td>
|
||||
<td>[3, 2, 8, 5, 1]</td>
|
||||
<td>[2, 8, 5, 1]</td>
|
||||
<td>14</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>4</td>
|
||||
<td>[5, 1]</td>
|
||||
<td>[5]</td>
|
||||
<td>5</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 2000</code></li>
|
||||
<li><code>0 <= nums[i] <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>1 <= q == queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>queries[i].length == 2 </code></li>
|
||||
<li><code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code></li>
|
||||
<li><code>0 <= l<sub>i</sub> <= r<sub>i</sub> <= n - 1</code></li>
|
||||
</ul>
|
||||
59
leetcode/problem/minimum-amount-of-damage-dealt-to-bob.html
Normal file
59
leetcode/problem/minimum-amount-of-damage-dealt-to-bob.html
Normal file
@@ -0,0 +1,59 @@
|
||||
<p>You are given an integer <code>power</code> and two integer arrays <code>damage</code> and <code>health</code>, both having length <code>n</code>.</p>
|
||||
|
||||
<p>Bob has <code>n</code> enemies, where enemy <code>i</code> will deal Bob <code>damage[i]</code> <strong>points</strong> of damage per second while they are <em>alive</em> (i.e. <code>health[i] > 0</code>).</p>
|
||||
|
||||
<p>Every second, <strong>after</strong> the enemies deal damage to Bob, he chooses <strong>one</strong> of the enemies that is still <em>alive</em> and deals <code>power</code> points of damage to them.</p>
|
||||
|
||||
<p>Determine the <strong>minimum</strong> total amount of damage points that will be dealt to Bob before <strong>all</strong> <code>n</code> enemies are <em>dead</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">power = 4, damage = [1,2,3,4], health = [4,5,6,8]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">39</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Attack enemy 3 in the first two seconds, after which enemy 3 will go down, the number of damage points dealt to Bob is <code>10 + 10 = 20</code> points.</li>
|
||||
<li>Attack enemy 2 in the next two seconds, after which enemy 2 will go down, the number of damage points dealt to Bob is <code>6 + 6 = 12</code> points.</li>
|
||||
<li>Attack enemy 0 in the next second, after which enemy 0 will go down, the number of damage points dealt to Bob is <code>3</code> points.</li>
|
||||
<li>Attack enemy 1 in the next two seconds, after which enemy 1 will go down, the number of damage points dealt to Bob is <code>2 + 2 = 4</code> points.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">power = 1, damage = [1,1,1,1], health = [1,2,3,4]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">20</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Attack enemy 0 in the first second, after which enemy 0 will go down, the number of damage points dealt to Bob is <code>4</code> points.</li>
|
||||
<li>Attack enemy 1 in the next two seconds, after which enemy 1 will go down, the number of damage points dealt to Bob is <code>3 + 3 = 6</code> points.</li>
|
||||
<li>Attack enemy 2 in the next three seconds, after which enemy 2 will go down, the number of damage points dealt to Bob is <code>2 + 2 + 2 = 6</code> points.</li>
|
||||
<li>Attack enemy 3 in the next four seconds, after which enemy 3 will go down, the number of damage points dealt to Bob is <code>1 + 1 + 1 + 1 = 4</code> points.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">power = 8, damage = [40], health = [59]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">320</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= power <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= n == damage.length == health.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= damage[i], health[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,61 @@
|
||||
<p>You are given an array of strings <code>words</code> and a string <code>target</code>.</p>
|
||||
|
||||
<p>A string <code>x</code> is called <strong>valid</strong> if <code>x</code> is a <span data-keyword="string-prefix">prefix</span> of <strong>any</strong> string in <code>words</code>.</p>
|
||||
|
||||
<p>Return the <strong>minimum</strong> number of <strong>valid</strong> strings that can be <em>concatenated</em> to form <code>target</code>. If it is <strong>not</strong> possible to form <code>target</code>, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abc","aaaaa","bcdef"], target = "aabcdabc"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The target string can be formed by concatenating:</p>
|
||||
|
||||
<ul>
|
||||
<li>Prefix of length 2 of <code>words[1]</code>, i.e. <code>"aa"</code>.</li>
|
||||
<li>Prefix of length 3 of <code>words[2]</code>, i.e. <code>"bcd"</code>.</li>
|
||||
<li>Prefix of length 3 of <code>words[0]</code>, i.e. <code>"abc"</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abababab","ab"], target = "ababaababa"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The target string can be formed by concatenating:</p>
|
||||
|
||||
<ul>
|
||||
<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>"ababa"</code>.</li>
|
||||
<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>"ababa"</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abcdef"], target = "xyz"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">-1</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>1 <= words[i].length <= 5 * 10<sup>3</sup></code></li>
|
||||
<li>The input is generated such that <code>sum(words[i].length) <= 10<sup>5</sup></code>.</li>
|
||||
<li><code>words[i]</code> consists only of lowercase English letters.</li>
|
||||
<li><code>1 <= target.length <= 5 * 10<sup>3</sup></code></li>
|
||||
<li><code>target</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,61 @@
|
||||
<p>You are given an array of strings <code>words</code> and a string <code>target</code>.</p>
|
||||
|
||||
<p>A string <code>x</code> is called <strong>valid</strong> if <code>x</code> is a <span data-keyword="string-prefix">prefix</span> of <strong>any</strong> string in <code>words</code>.</p>
|
||||
|
||||
<p>Return the <strong>minimum</strong> number of <strong>valid</strong> strings that can be <em>concatenated</em> to form <code>target</code>. If it is <strong>not</strong> possible to form <code>target</code>, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abc","aaaaa","bcdef"], target = "aabcdabc"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The target string can be formed by concatenating:</p>
|
||||
|
||||
<ul>
|
||||
<li>Prefix of length 2 of <code>words[1]</code>, i.e. <code>"aa"</code>.</li>
|
||||
<li>Prefix of length 3 of <code>words[2]</code>, i.e. <code>"bcd"</code>.</li>
|
||||
<li>Prefix of length 3 of <code>words[0]</code>, i.e. <code>"abc"</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abababab","ab"], target = "ababaababa"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The target string can be formed by concatenating:</p>
|
||||
|
||||
<ul>
|
||||
<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>"ababa"</code>.</li>
|
||||
<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>"ababa"</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["abcdef"], target = "xyz"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">-1</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>1 <= words[i].length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li>The input is generated such that <code>sum(words[i].length) <= 10<sup>5</sup></code>.</li>
|
||||
<li><code>words[i]</code> consists only of lowercase English letters.</li>
|
||||
<li><code>1 <= target.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>target</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
40
leetcode/problem/reach-end-of-array-with-max-score.html
Normal file
40
leetcode/problem/reach-end-of-array-with-max-score.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>You are given an integer array <code>nums</code> of length <code>n</code>.</p>
|
||||
|
||||
<p>Your goal is to start at index <code>0</code> and reach index <code>n - 1</code>. You can only jump to indices <strong>greater</strong> than your current index.</p>
|
||||
|
||||
<p>The score for a jump from index <code>i</code> to index <code>j</code> is calculated as <code>(j - i) * nums[i]</code>.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> possible <b>total score</b> by the time you reach the last index.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,3,1,5]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 7</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>First, jump to index 1 and then jump to the last index. The final score is <code>1 * 1 + 2 * 3 = 7</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [4,3,1,3,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 16</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Jump directly to the last index. The final score is <code>4 * 4 = 16</code>.</p>
|
||||
</div>
|
||||
|
||||
<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>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>You are given a 2D matrix <code>grid</code> consisting of positive integers.</p>
|
||||
|
||||
<p>You have to select <em>one or more</em> cells from the matrix such that the following conditions are satisfied:</p>
|
||||
|
||||
<ul>
|
||||
<li>No two selected cells are in the <strong>same</strong> row of the matrix.</li>
|
||||
<li>The values in the set of selected cells are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Your score will be the <strong>sum</strong> of the values of the selected cells.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> score you can achieve.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">grid = [[1,2,3],[4,3,2],[1,1,1]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">8</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/29/grid1drawio.png" /></p>
|
||||
|
||||
<p>We can select the cells with values 1, 3, and 4 that are colored above.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">grid = [[8,7,6],[8,3,2]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">15</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/29/grid8_8drawio.png" style="width: 170px; height: 114px;" /></p>
|
||||
|
||||
<p>We can select the cells with values 7 and 8 that are colored above.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= grid.length, grid[i].length <= 10</code></li>
|
||||
<li><code>1 <= grid[i][j] <= 100</code></li>
|
||||
</ul>
|
||||
50
leetcode/problem/the-two-sneaky-numbers-of-digitville.html
Normal file
50
leetcode/problem/the-two-sneaky-numbers-of-digitville.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>In the town of Digitville, there was a list of numbers called <code>nums</code> containing integers from <code>0</code> to <code>n - 1</code>. Each number was supposed to appear <strong>exactly once</strong> in the list, however, <strong>two</strong> mischievous numbers sneaked in an <em>additional time</em>, making the list longer than usual.<!-- notionvc: c37cfb04-95eb-4273-85d5-3c52d0525b95 --></p>
|
||||
|
||||
<p>As the town detective, your task is to find these two sneaky numbers. Return an array of size <strong>two</strong> containing the two numbers (in <em>any order</em>), so peace can return to Digitville.<!-- notionvc: 345db5be-c788-4828-9836-eefed31c982f --></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [0,1,1,0]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[0,1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The numbers 0 and 1 each appear twice in the array.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [0,3,2,1,3,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[2,3]</span></p>
|
||||
|
||||
<p><strong>Explanation: </strong></p>
|
||||
|
||||
<p>The numbers 2 and 3 each appear twice in the array.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [7,1,5,4,3,4,6,0,9,5,8,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[4,5]</span></p>
|
||||
|
||||
<p><strong>Explanation: </strong></p>
|
||||
|
||||
<p>The numbers 4 and 5 each appear twice in the array.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li data-stringify-border="0" data-stringify-indent="1"><code>2 <= n <= 100</code></li>
|
||||
<li data-stringify-border="0" data-stringify-indent="1"><code>nums.length == n + 2</code></li>
|
||||
<li data-stringify-border="0" data-stringify-indent="1"><code data-stringify-type="code">0 <= nums[i] < n</code></li>
|
||||
<li data-stringify-border="0" data-stringify-indent="1">The input is generated such that <code>nums</code> contains <strong>exactly</strong> two repeated elements.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user