mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-04 23:11:41 +08:00
update
This commit is contained in:
30
leetcode/problem/calculate-delayed-arrival-time.html
Normal file
30
leetcode/problem/calculate-delayed-arrival-time.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>You are given a positive integer <code>arrivalTime</code> denoting the arrival time of a train in hours, and another positive integer <code>delayedTime</code> denoting the amount of delay in hours.</p>
|
||||
|
||||
<p>Return <em>the time when the train will arrive at the station.</em></p>
|
||||
|
||||
<p>Note that the time in this problem is in 24-hours format.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arrivalTime = 15, delayedTime = 5
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation:</strong> Arrival time of the train was 15:00 hours. It is delayed by 5 hours. Now it will reach at 15+5 = 20 (20:00 hours).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arrivalTime = 13, delayedTime = 11
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Arrival time of the train was 13:00 hours. It is delayed by 11 hours. Now it will reach at 13+11=24 (Which is denoted by 00:00 in 24 hours format so return 0).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arrivaltime < 24</code></li>
|
||||
<li><code>1 <= delayedTime <= 24</code></li>
|
||||
</ul>
|
||||
41
leetcode/problem/cousins-in-binary-tree-ii.html
Normal file
41
leetcode/problem/cousins-in-binary-tree-ii.html
Normal file
@@ -0,0 +1,41 @@
|
||||
<p>Given the <code>root</code> of a binary tree, replace the value of each node in the tree with the <strong>sum of all its cousins' values</strong>.</p>
|
||||
|
||||
<p>Two nodes of a binary tree are <strong>cousins</strong> if they have the same depth with different parents.</p>
|
||||
|
||||
<p>Return <em>the </em><code>root</code><em> of the modified tree</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the depth of a node is the number of edges in the path from the root node to it.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/example11.png" style="width: 571px; height: 151px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [5,4,9,1,10,null,7]
|
||||
<strong>Output:</strong> [0,0,0,7,7,null,11]
|
||||
<strong>Explanation:</strong> The diagram above shows the initial binary tree and the binary tree after changing the value of each node.
|
||||
- Node with value 5 does not have any cousins so its sum is 0.
|
||||
- Node with value 4 does not have any cousins so its sum is 0.
|
||||
- Node with value 9 does not have any cousins so its sum is 0.
|
||||
- Node with value 1 has a cousin with value 7 so its sum is 7.
|
||||
- Node with value 10 has a cousin with value 7 so its sum is 7.
|
||||
- Node with value 7 has cousins with values 1 and 10 so its sum is 11.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/diagram33.png" style="width: 481px; height: 91px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,1,2]
|
||||
<strong>Output:</strong> [0,0,0]
|
||||
<strong>Explanation:</strong> The diagram above shows the initial binary tree and the binary tree after changing the value of each node.
|
||||
- Node with value 3 does not have any cousins so its sum is 0.
|
||||
- Node with value 1 does not have any cousins so its sum is 0.
|
||||
- Node with value 2 does not have any cousins so its sum is 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
135
leetcode/problem/design-cancellable-function.html
Normal file
135
leetcode/problem/design-cancellable-function.html
Normal file
@@ -0,0 +1,135 @@
|
||||
<p>Sometimes you have a long running task, and you may wish to cancel it before it completes. To help with this goal, write a function <code>cancellable</code> that accepts a generator object and returns an array of two values: a <strong>cancel function</strong> and a <strong>promise</strong>.</p>
|
||||
|
||||
<p>You may assume the generator function will only yield promises. It is your function's responsibility to pass the values resolved by the promise back to the generator. If the promise rejects, your function should throw that error back to the generator.</p>
|
||||
|
||||
<p>If the cancel callback is called before the generator is done, your function should throw an error back to the generator. That error should be the string <code>"Cancelled"</code> (Not an <code>Error</code> object). If the error was caught, the returned promise should resolve with the next value that was yielded or returned. Otherwise, the promise should reject with the thrown error. No more code should be executed.</p>
|
||||
|
||||
<p>When the generator is done, the promise your function returned should resolve the value the generator returned. If, however, the generator throws an error, the returned promise should reject with the error.</p>
|
||||
|
||||
<p>An example of how your code would be used:</p>
|
||||
|
||||
<pre>
|
||||
function* tasks() {
|
||||
const val = yield new Promise(resolve => resolve(2 + 2));
|
||||
yield new Promise(resolve => setTimeout(resolve, 100));
|
||||
return val + 1; // calculation shouldn't be done.
|
||||
}
|
||||
const [cancel, promise] = cancellable(tasks());
|
||||
setTimeout(cancel, 50);
|
||||
promise.catch(console.log); // logs "Cancelled" at t=50ms
|
||||
</pre>
|
||||
|
||||
<p>If instead <code>cancel()</code> was not called or was called after <code>t=100ms</code>, the promise would have resolved <code>5</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
return 42;
|
||||
}
|
||||
cancelledAt = 100
|
||||
<strong>Output:</strong> {"resolved": 42}
|
||||
<strong>Explanation:</strong>
|
||||
const generator = generatorFunction();
|
||||
const [cancel, promise] = cancellable(generator);
|
||||
setTimeout(cancel, 100);
|
||||
promise.then(console.log); // resolves 42 at t=0ms
|
||||
|
||||
The generator immediately yields 42 and finishes. Because of that, the returned promise immediately resolves 42. Note that cancelling a finished generator does nothing.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
const msg = yield new Promise(res => res("Hello"));
|
||||
throw `Error: ${msg}`;
|
||||
}
|
||||
cancelledAt = null
|
||||
<strong>Output:</strong> {"rejected": "Error: Hello"}
|
||||
<strong>Explanation:</strong>
|
||||
A promise is yielded. The function handles this by waiting for it to resolve and then passes the resolved value back to the generator. Then an error is thrown which has the effect of causing the promise to reject with the same thrown error.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
yield new Promise(res => setTimeout(res, 200));
|
||||
return "Success";
|
||||
}
|
||||
cancelledAt = 100
|
||||
<strong>Output:</strong> {"rejected": "Cancelled"}
|
||||
<strong>Explanation:</strong>
|
||||
While the function is waiting for the yielded promise to resolve, cancel() is called. This causes an error message to be sent back to the generator. Since this error is uncaught, the returned promise rejected with this error.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
let result = 0;
|
||||
yield new Promise(res => setTimeout(res, 100));
|
||||
result += yield new Promise(res => res(1));
|
||||
yield new Promise(res => setTimeout(res, 100));
|
||||
result += yield new Promise(res => res(1));
|
||||
return result;
|
||||
}
|
||||
cancelledAt = null
|
||||
<strong>Output:</strong> {"resolved": 2}
|
||||
<strong>Explanation:</strong>
|
||||
4 promises are yielded. Two of those promises have their values added to the result. After 200ms, the generator finishes with a value of 2, and that value is resolved by the returned promise.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 5:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
let result = 0;
|
||||
try {
|
||||
yield new Promise(res => setTimeout(res, 100));
|
||||
result += yield new Promise(res => res(1));
|
||||
yield new Promise(res => setTimeout(res, 100));
|
||||
result += yield new Promise(res => res(1));
|
||||
} catch(e) {
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
cancelledAt = 150
|
||||
<strong>Output:</strong> {"resolved": 1}
|
||||
<strong>Explanation:</strong>
|
||||
The first two yielded promises resolve and cause the result to increment. However, at t=150ms, the generator is cancelled. The error sent to the generator is caught and the result is returned and finally resolved by the returned promise.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 6:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
generatorFunction = function*() {
|
||||
try {
|
||||
yield new Promise((resolve, reject) => reject("Promise Rejected"));
|
||||
} catch(e) {
|
||||
let a = yield new Promise(resolve => resolve(2));
|
||||
let b = yield new Promise(resolve => resolve(2));
|
||||
return a + b;
|
||||
};
|
||||
}
|
||||
cancelledAt = null
|
||||
<strong>Output:</strong> {"resolved": 4}
|
||||
<strong>Explanation:</strong>
|
||||
The first yielded promise immediately rejects. This error is caught. Because the generator hasn't been cancelled, execution continues as usual. It ends up resolving 2 + 2 = 4.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>cancelledAt == null or 0 <= cancelledAt <= 1000</code></li>
|
||||
<li><code>generatorFunction returns a generator object</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>There is a <strong>directed weighted</strong> graph that consists of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code>. The edges of the graph are initially represented by the given array <code>edges</code> where <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>, edgeCost<sub>i</sub>]</code> meaning that there is an edge from <code>from<sub>i</sub></code> to <code>to<sub>i</sub></code> with the cost <code>edgeCost<sub>i</sub></code>.</p>
|
||||
|
||||
<p>Implement the <code>Graph</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Graph(int n, int[][] edges)</code> initializes the object with <code>n</code> nodes and the given edges.</li>
|
||||
<li><code>addEdge(int[] edge)</code> adds an edge to the list of edges where <code>edge = [from, to, edgeCost]</code>. It is guaranteed that there is no edge between the two nodes before adding this one.</li>
|
||||
<li><code>int shortestPath(int node1, int node2)</code> returns the <strong>minimum</strong> cost of a path from <code>node1</code> to <code>node2</code>. If no path exists, return <code>-1</code>. The cost of a path is the sum of the costs of the edges in the path.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/graph3drawio-2.png" style="width: 621px; height: 191px;" />
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["Graph", "shortestPath", "shortestPath", "addEdge", "shortestPath"]
|
||||
[[4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]], [3, 2], [0, 3], [[1, 3, 4]], [0, 3]]
|
||||
<strong>Output</strong>
|
||||
[null, 6, -1, null, 6]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
Graph g = new Graph(4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]);
|
||||
g.shortestPath(3, 2); // return 6. The shortest path from 3 to 2 in the first diagram above is 3 -> 0 -> 1 -> 2 with a total cost of 3 + 2 + 1 = 6.
|
||||
g.shortestPath(0, 3); // return -1. There is no path from 0 to 3.
|
||||
g.addEdge([1, 3, 4]); // We add an edge from node 1 to node 3, and we get the second diagram above.
|
||||
g.shortestPath(0, 3); // return 6. The shortest path from 0 to 3 now is 0 -> 1 -> 3 with a total cost of 2 + 4 = 6.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>0 <= edges.length <= n * (n - 1)</code></li>
|
||||
<li><code>edges[i].length == edge.length == 3</code></li>
|
||||
<li><code>0 <= from<sub>i</sub>, to<sub>i</sub>, from, to, node1, node2 <= n - 1</code></li>
|
||||
<li><code>1 <= edgeCost<sub>i</sub>, edgeCost <= 10<sup>6</sup></code></li>
|
||||
<li>There are no repeated edges and no self-loops in the graph at any point.</li>
|
||||
<li>At most <code>100</code> calls will be made for <code>addEdge</code>.</li>
|
||||
<li>At most <code>100</code> calls will be made for <code>shortestPath</code>.</li>
|
||||
</ul>
|
||||
49
leetcode/problem/find-the-maximum-divisibility-score.html
Normal file
49
leetcode/problem/find-the-maximum-divisibility-score.html
Normal file
@@ -0,0 +1,49 @@
|
||||
<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums</code> and <code>divisors</code>.</p>
|
||||
|
||||
<p>The <strong>divisibility score</strong> of <code>divisors[i]</code> is the number of indices <code>j</code> such that <code>nums[j]</code> is divisible by <code>divisors[i]</code>.</p>
|
||||
|
||||
<p>Return <em>the integer</em> <code>divisors[i]</code> <em>with the maximum divisibility score</em>. If there is more than one integer with the maximum score, return the minimum of them.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,7,9,3,9], divisors = [5,2,3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The divisibility score for every element in divisors is:
|
||||
The divisibility score of divisors[0] is 0 since no number in nums is divisible by 5.
|
||||
The divisibility score of divisors[1] is 1 since nums[0] is divisible by 2.
|
||||
The divisibility score of divisors[2] is 3 since nums[2], nums[3], and nums[4] are divisible by 3.
|
||||
Since divisors[2] has the maximum divisibility score, we return it.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [20,14,21,10], divisors = [5,7,5]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The divisibility score for every element in divisors is:
|
||||
The divisibility score of divisors[0] is 2 since nums[0] and nums[3] are divisible by 5.
|
||||
The divisibility score of divisors[1] is 2 since nums[1] and nums[2] are divisible by 7.
|
||||
The divisibility score of divisors[2] is 2 since nums[0] and nums[3] are divisible by 5.
|
||||
Since divisors[0], divisors[1], and divisors[2] all have the maximum divisibility score, we return the minimum of them (i.e., divisors[2]).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [12], divisors = [10,16]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The divisibility score for every element in divisors is:
|
||||
The divisibility score of divisors[0] is 0 since no number in nums is divisible by 10.
|
||||
The divisibility score of divisors[1] is 0 since no number in nums is divisible by 16.
|
||||
Since divisors[0] and divisors[1] both have the maximum divisibility score, we return the minimum of them (i.e., divisors[0]).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length, divisors.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i], divisors[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>We define the <strong>conversion array</strong> <code>conver</code> of an array <code>arr</code> as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>conver[i] = arr[i] + max(arr[0..i])</code> where <code>max(arr[0..i])</code> is the maximum value of <code>arr[j]</code> over <code>0 <= j <= i</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>We also define the <strong>score</strong> of an array <code>arr</code> as the sum of the values of the conversion array of <code>arr</code>.</p>
|
||||
|
||||
<p>Given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code>, return <em>an array </em><code>ans</code><em> of length </em><code>n</code><em> where </em><code>ans[i]</code><em> is the score of the prefix</em> <code>nums[0..i]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,7,5,10]
|
||||
<strong>Output:</strong> [4,10,24,36,56]
|
||||
<strong>Explanation:</strong>
|
||||
For the prefix [2], the conversion array is [4] hence the score is 4
|
||||
For the prefix [2, 3], the conversion array is [4, 6] hence the score is 10
|
||||
For the prefix [2, 3, 7], the conversion array is [4, 6, 14] hence the score is 24
|
||||
For the prefix [2, 3, 7, 5], the conversion array is [4, 6, 14, 12] hence the score is 36
|
||||
For the prefix [2, 3, 7, 5, 10], the conversion array is [4, 6, 14, 12, 20] hence the score is 56
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,2,4,8,16]
|
||||
<strong>Output:</strong> [2,4,8,16,32,64]
|
||||
<strong>Explanation:</strong>
|
||||
For the prefix [1], the conversion array is [2] hence the score is 2
|
||||
For the prefix [1, 1], the conversion array is [2, 2] hence the score is 4
|
||||
For the prefix [1, 1, 2], the conversion array is [2, 2, 4] hence the score is 8
|
||||
For the prefix [1, 1, 2, 4], the conversion array is [2, 2, 4, 8] hence the score is 16
|
||||
For the prefix [1, 1, 2, 4, 8], the conversion array is [2, 2, 4, 8, 16] hence the score is 32
|
||||
For the prefix [1, 1, 2, 4, 8, 16], the conversion array is [2, 2, 4, 8, 16, 32] hence the score is 64
|
||||
</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>
|
||||
39
leetcode/problem/find-the-width-of-columns-of-a-grid.html
Normal file
39
leetcode/problem/find-the-width-of-columns-of-a-grid.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> integer matrix <code>grid</code>. The width of a column is the maximum <strong>length </strong>of its integers.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, if <code>grid = [[-10], [3], [12]]</code>, the width of the only column is <code>3</code> since <code>-10</code> is of length <code>3</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array</em> <code>ans</code> <em>of size</em> <code>n</code> <em>where</em> <code>ans[i]</code> <em>is the width of the</em> <code>i<sup>th</sup></code> <em>column</em>.</p>
|
||||
|
||||
<p>The <strong>length</strong> of an integer <code>x</code> with <code>len</code> digits is equal to <code>len</code> if <code>x</code> is non-negative, and <code>len + 1</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1],[22],[333]]
|
||||
<strong>Output:</strong> [3]
|
||||
<strong>Explanation:</strong> In the 0<sup>th</sup> column, 333 is of length 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[-15,1,3],[15,7,12],[5,6,-2]]
|
||||
<strong>Output:</strong> [3,1,2]
|
||||
<strong>Explanation:</strong>
|
||||
In the 0<sup>th</sup> column, only -15 is of length 3.
|
||||
In the 1<sup>st</sup> column, all integers are of length 1.
|
||||
In the 2<sup>nd</sup> column, both 12 and -2 are of length 2.
|
||||
</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>1 <= m, n <= 100 </code></li>
|
||||
<li><code>-10<sup>9</sup> <= grid[r][c] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
35
leetcode/problem/generate-fibonacci-sequence.html
Normal file
35
leetcode/problem/generate-fibonacci-sequence.html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>Write a generator function that returns a generator object which yields the <strong>fibonacci sequence</strong>.</p>
|
||||
|
||||
<p>The <strong>fibonacci sequence</strong> is defined by the relation <code>X<sub>n</sub> = X<sub>n-1</sub> + X<sub>n-2</sub></code>.</p>
|
||||
|
||||
<p>The first few numbers of the series are <code>0, 1, 1, 2, 3, 5, 8, 13</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> callCount = 5
|
||||
<strong>Output:</strong> [0,1,1,2,3]
|
||||
<strong>Explanation:</strong>
|
||||
const gen = fibGenerator();
|
||||
gen.next().value; // 0
|
||||
gen.next().value; // 1
|
||||
gen.next().value; // 1
|
||||
gen.next().value; // 2
|
||||
gen.next().value; // 3
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> callCount = 0
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> gen.next() is never called so nothing is outputted
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= callCount <= 50</code></li>
|
||||
</ul>
|
||||
50
leetcode/problem/minimize-the-total-price-of-the-trips.html
Normal file
50
leetcode/problem/minimize-the-total-price-of-the-trips.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>There exists an undirected and unrooted tree with <code>n</code> nodes indexed from <code>0</code> to <code>n - 1</code>. You are given the integer <code>n</code> and a 2D integer array <code>edges</code> of length <code>n - 1</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.</p>
|
||||
|
||||
<p>Each node has an associated price. You are given an integer array <code>price</code>, where <code>price[i]</code> is the price of the <code>i<sup>th</sup></code> node.</p>
|
||||
|
||||
<p>The <strong>price sum</strong> of a given path is the sum of the prices of all nodes lying on that path.</p>
|
||||
|
||||
<p>Additionally, you are given a 2D integer array <code>trips</code>, where <code>trips[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> indicates that you start the <code>i<sup>th</sup></code> trip from the node <code>start<sub>i</sub></code> and travel to the node <code>end<sub>i</sub></code> by any path you like.</p>
|
||||
|
||||
<p>Before performing your first trip, you can choose some <strong>non-adjacent</strong> nodes and halve the prices.</p>
|
||||
|
||||
<p>Return <em>the minimum total price sum to perform all the given trips</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/16/diagram2.png" style="width: 541px; height: 181px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]
|
||||
<strong>Output:</strong> 23
|
||||
<strong>Explanation:</strong> The diagram above denotes the tree after rooting it at node 2. The first part shows the initial tree and the second part shows the tree after choosing nodes 0, 2, and 3, and making their price half.
|
||||
For the 1<sup>st</sup> trip, we choose path [0,1,3]. The price sum of that path is 1 + 2 + 3 = 6.
|
||||
For the 2<sup>nd</sup> trip, we choose path [2,1]. The price sum of that path is 2 + 5 = 7.
|
||||
For the 3<sup>rd</sup> trip, we choose path [2,1,3]. The price sum of that path is 5 + 2 + 3 = 10.
|
||||
The total price sum of all trips is 6 + 7 + 10 = 23.
|
||||
It can be proven, that 23 is the minimum answer that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/16/diagram3.png" style="width: 456px; height: 111px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The diagram above denotes the tree after rooting it at node 0. The first part shows the initial tree and the second part shows the tree after choosing node 0, and making its price half.
|
||||
For the 1<sup>st</sup> trip, we choose path [0]. The price sum of that path is 1.
|
||||
The total price sum of all trips is 1. It can be proven, that 1 is the minimum answer that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>edges</code> represents a valid tree.</li>
|
||||
<li><code>price.length == n</code></li>
|
||||
<li><code>price[i]</code> is an even integer.</li>
|
||||
<li><code>1 <= price[i] <= 1000</code></li>
|
||||
<li><code>1 <= trips.length <= 100</code></li>
|
||||
<li><code>0 <= start<sub>i</sub>, end<sub>i</sub> <= n - 1</code></li>
|
||||
</ul>
|
||||
36
leetcode/problem/minimum-additions-to-make-valid-string.html
Normal file
36
leetcode/problem/minimum-additions-to-make-valid-string.html
Normal file
@@ -0,0 +1,36 @@
|
||||
<p>Given a string <code>word</code> to which you can insert letters "a", "b" or "c" anywhere and any number of times, return <em>the minimum number of letters that must be inserted so that <code>word</code> becomes <strong>valid</strong>.</em></p>
|
||||
|
||||
<p>A string is called <strong>valid </strong>if it can be formed by concatenating the string "abc" several times.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "b"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Insert the letter "a" right before "b", and the letter "c" right next to "a" to obtain the valid string "<strong>a</strong>b<strong>c</strong>".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "aaa"
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Insert letters "b" and "c" next to each "a" to obtain the valid string "a<strong>bc</strong>a<strong>bc</strong>a<strong>bc</strong>".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "abc"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> word is already valid. No modifications are needed.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 50</code></li>
|
||||
<li><code>word</code> consists of letters "a", "b" and "c" only. </li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> consisiting of <strong>positive</strong> integers. You can do the following operation on the array <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Select an index <code>i</code> such that <code>0 <= i < n - 1</code> and replace either of <code>nums[i]</code> or <code>nums[i+1]</code> with their gcd value.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of operations to make all elements of </em><code>nums</code><em> equal to </em><code>1</code>. If it is impossible, return <code>-1</code>.</p>
|
||||
|
||||
<p>The gcd of two integers is the greatest common divisor of the two integers.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,6,3,4]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> We can do the following operations:
|
||||
- Choose index i = 2 and replace nums[2] with gcd(3,4) = 1. Now we have nums = [2,6,1,4].
|
||||
- Choose index i = 1 and replace nums[1] with gcd(6,1) = 1. Now we have nums = [2,1,1,4].
|
||||
- Choose index i = 0 and replace nums[0] with gcd(2,1) = 1. Now we have nums = [1,1,1,4].
|
||||
- Choose index i = 2 and replace nums[3] with gcd(1,4) = 1. Now we have nums = [1,1,1,1].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,10,6,14]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It can be shown that it is impossible to make all the elements equal to 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 50</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
36
leetcode/problem/nested-array-generator.html
Normal file
36
leetcode/problem/nested-array-generator.html
Normal file
@@ -0,0 +1,36 @@
|
||||
<p>Given a <strong>multi-dimensional array</strong> of integers, return a generator object which yields integers in the same order as <strong>inorder traversal</strong>.</p>
|
||||
|
||||
<p>A <strong>multi-dimensional array</strong> is a recursive data structure that contains both integers and other <strong>multi-dimensional arrays</strong>.</p>
|
||||
|
||||
<p><strong>inorder traversal</strong> iterates over each array from left to right, yielding any integers it encounters or applying <strong>inorder traversal</strong> to any arrays it encounters.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [[[6]],[1,3],[]]
|
||||
<strong>Output:</strong> [6,1,3]
|
||||
<strong>Explanation:</strong>
|
||||
const generator = inorderTraversal(arr);
|
||||
generator.next().value; // 6
|
||||
generator.next().value; // 1
|
||||
generator.next().value; // 3
|
||||
generator.next().done; // true
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = []
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> There are no integers so the generator doesn't yield anything.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= arr.flat().length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= arr.flat()[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>maxNestingDepth <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
40
leetcode/problem/row-with-maximum-ones.html
Normal file
40
leetcode/problem/row-with-maximum-ones.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>Given a <code>m x n</code> binary matrix <code>mat</code>, find the <strong>0-indexed</strong> position of the row that contains the <strong>maximum</strong> count of <strong>ones,</strong> and the number of ones in that row.</p>
|
||||
|
||||
<p>In case there are multiple rows that have the maximum count of ones, the row with the <strong>smallest row number</strong> should be selected.</p>
|
||||
|
||||
<p>Return<em> an array containing the index of the row, and the number of ones in it.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,1],[1,0]]
|
||||
<strong>Output:</strong> [0,1]
|
||||
<strong>Explanation:</strong> Both rows have the same number of 1's. So we return the index of the smaller row, 0, and the maximum count of ones (1<code>)</code>. So, the answer is [0,1].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0,0],[0,1,1]]
|
||||
<strong>Output:</strong> [1,2]
|
||||
<strong>Explanation:</strong> The row indexed 1 has the maximum count of ones <code>(2)</code>. So we return its index, <code>1</code>, and the count. So, the answer is [1,2].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0],[1,1],[0,0]]
|
||||
<strong>Output:</strong> [1,2]
|
||||
<strong>Explanation:</strong> The row indexed 1 has the maximum count of ones (2). So the answer is [1,2].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length</code> </li>
|
||||
<li><code>n == mat[i].length</code> </li>
|
||||
<li><code>1 <= m, n <= 100</code> </li>
|
||||
<li><code>mat[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
56
leetcode/problem/sliding-subarray-beauty.html
Normal file
56
leetcode/problem/sliding-subarray-beauty.html
Normal file
@@ -0,0 +1,56 @@
|
||||
<p>Given an integer array <code>nums</code> containing <code>n</code> integers, find the <strong>beauty</strong> of each subarray of size <code>k</code>.</p>
|
||||
|
||||
<p>The <strong>beauty</strong> of a subarray is the <code>x<sup>th</sup></code><strong> smallest integer </strong>in the subarray if it is <strong>negative</strong>, or <code>0</code> if there are fewer than <code>x</code> negative integers.</p>
|
||||
|
||||
<p>Return <em>an integer array containing </em><code>n - k + 1</code> <em>integers, which denote the </em><strong>beauty</strong><em> of the subarrays <strong>in order</strong> from the first index in the array.</em></p>
|
||||
|
||||
<ul>
|
||||
<li>
|
||||
<p>A subarray is a contiguous <strong>non-empty</strong> sequence of elements within an array.</p>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,-1,-3,-2,3], k = 3, x = 2
|
||||
<strong>Output:</strong> [-1,-2,-2]
|
||||
<strong>Explanation:</strong> There are 3 subarrays with size k = 3.
|
||||
The first subarray is <code>[1, -1, -3]</code> and the 2<sup>nd</sup> smallest negative integer is -1.
|
||||
The second subarray is <code>[-1, -3, -2]</code> and the 2<sup>nd</sup> smallest negative integer is -2.
|
||||
The third subarray is <code>[-3, -2, 3] </code>and the 2<sup>nd</sup> smallest negative integer is -2.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,-2,-3,-4,-5], k = 2, x = 2
|
||||
<strong>Output:</strong> [-1,-2,-3,-4]
|
||||
<strong>Explanation:</strong> There are 4 subarrays with size k = 2.
|
||||
For <code>[-1, -2]</code>, the 2<sup>nd</sup> smallest negative integer is -1.
|
||||
For <code>[-2, -3]</code>, the 2<sup>nd</sup> smallest negative integer is -2.
|
||||
For <code>[-3, -4]</code>, the 2<sup>nd</sup> smallest negative integer is -3.
|
||||
For <code>[-4, -5]</code>, the 2<sup>nd</sup> smallest negative integer is -4. </pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-3,1,2,-3,0,-3], k = 2, x = 1
|
||||
<strong>Output:</strong> [-3,0,-3,-3,-3]
|
||||
<strong>Explanation:</strong> There are 5 subarrays with size k = 2<strong>.</strong>
|
||||
For <code>[-3, 1]</code>, the 1<sup>st</sup> smallest negative integer is -3.
|
||||
For <code>[1, 2]</code>, there is no negative integer so the beauty is 0.
|
||||
For <code>[2, -3]</code>, the 1<sup>st</sup> smallest negative integer is -3.
|
||||
For <code>[-3, 0]</code>, the 1<sup>st</sup> smallest negative integer is -3.
|
||||
For <code>[0, -3]</code>, the 1<sup>st</sup> smallest negative integer is -3.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length </code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= n</code></li>
|
||||
<li><code>1 <= x <= k </code></li>
|
||||
<li><code>-50 <= nums[i] <= 50 </code></li>
|
||||
</ul>
|
||||
35
leetcode/problem/sum-multiples.html
Normal file
35
leetcode/problem/sum-multiples.html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>Given a positive integer <code>n</code>, find the sum of all integers in the range <code>[1, n]</code> <strong>inclusive</strong> that are divisible by <code>3</code>, <code>5</code>, or <code>7</code>.</p>
|
||||
|
||||
<p>Return <em>an integer denoting the sum of all numbers in the given range satisfying the constraint.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7
|
||||
<strong>Output:</strong> 21
|
||||
<strong>Explanation:</strong> Numbers in the range <code>[1, 7]</code> that are divisible by <code>3</code>, <code>5,</code> or <code>7 </code>are <code>3, 5, 6, 7</code>. The sum of these numbers is <code>21</code>.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 10
|
||||
<strong>Output:</strong> 40
|
||||
<strong>Explanation:</strong> Numbers in the range <code>[1, 10] that are</code> divisible by <code>3</code>, <code>5,</code> or <code>7</code> are <code>3, 5, 6, 7, 9, 10</code>. The sum of these numbers is 40.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 9
|
||||
<strong>Output:</strong> 30
|
||||
<strong>Explanation:</strong> Numbers in the range <code>[1, 9]</code> that are divisible by <code>3</code>, <code>5</code>, or <code>7</code> are <code>3, 5, 6, 7, 9</code>. The sum of these numbers is <code>30</code>.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>3</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user