mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-14 03:41:41 +08:00
add leetcode problem-cn part1
This commit is contained in:
@@ -0,0 +1,36 @@
|
||||
<p>There is a pizza with <code>3n</code> slices of varying size, you and your friends will take slices of pizza as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>You will pick <strong>any</strong> pizza slice.</li>
|
||||
<li>Your friend Alice will pick the next slice in the anti-clockwise direction of your pick.</li>
|
||||
<li>Your friend Bob will pick the next slice in the clockwise direction of your pick.</li>
|
||||
<li>Repeat until there are no more slices of pizzas.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer array <code>slices</code> that represent the sizes of the pizza slices in a clockwise direction, return <em>the maximum possible sum of slice sizes that you can pick</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_3_1723.png" style="width: 500px; height: 266px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> slices = [1,2,3,4,5,6]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> Pick pizza slice of size 4, Alice and Bob will pick slices with size 3 and 5 respectively. Then Pick slices with size 6, finally Alice and Bob will pick slice of size 2 and 1 respectively. Total = 4 + 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_4_1723.png" style="width: 500px; height: 299px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> slices = [8,9,8,6,1,1]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> Pick pizza slice of size 8 in each turn. If you pick slice with size 9 your partners will pick slices of size 8.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 * n == slices.length</code></li>
|
||||
<li><code>1 <= slices.length <= 500</code></li>
|
||||
<li><code>1 <= slices[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given a positive integer <code>num</code> consisting only of digits <code>6</code> and <code>9</code>.</p>
|
||||
|
||||
<p>Return <em>the maximum number you can get by changing <strong>at most</strong> one digit (</em><code>6</code><em> becomes </em><code>9</code><em>, and </em><code>9</code><em> becomes </em><code>6</code><em>)</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9669
|
||||
<strong>Output:</strong> 9969
|
||||
<strong>Explanation:</strong>
|
||||
Changing the first digit results in 6669.
|
||||
Changing the second digit results in 9969.
|
||||
Changing the third digit results in 9699.
|
||||
Changing the fourth digit results in 9666.
|
||||
The maximum number is 9969.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9996
|
||||
<strong>Output:</strong> 9999
|
||||
<strong>Explanation:</strong> Changing the last digit 6 to 9 results in the maximum number.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 9999
|
||||
<strong>Output:</strong> 9999
|
||||
<strong>Explanation:</strong> It is better not to apply any change.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num <= 10<sup>4</sup></code></li>
|
||||
<li><code>num</code> consists of only <code>6</code> and <code>9</code> digits.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,22 @@
|
||||
<p>Given two strings <code>first</code> and <code>second</code>, consider occurrences in some text of the form <code>"first second third"</code>, where <code>second</code> comes immediately after <code>first</code>, and <code>third</code> comes immediately after <code>second</code>.</p>
|
||||
|
||||
<p>Return <em>an array of all the words</em> <code>third</code> <em>for each occurrence of</em> <code>"first second third"</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> text = "alice is a good girl she is a good student", first = "a", second = "good"
|
||||
<strong>Output:</strong> ["girl","student"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> text = "we will we will rock you", first = "we", second = "will"
|
||||
<strong>Output:</strong> ["we","rock"]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 1000</code></li>
|
||||
<li><code>text</code> consists of lowercase English letters and spaces.</li>
|
||||
<li>All the words in <code>text</code> a separated by <strong>a single space</strong>.</li>
|
||||
<li><code>1 <= first.length, second.length <= 10</code></li>
|
||||
<li><code>first</code> and <code>second</code> consist of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>There are two kinds of threads: <code>oxygen</code> and <code>hydrogen</code>. Your goal is to group these threads to form water molecules.</p>
|
||||
|
||||
<p>There is a barrier where each thread has to wait until a complete molecule can be formed. Hydrogen and oxygen threads will be given <code>releaseHydrogen</code> and <code>releaseOxygen</code> methods respectively, which will allow them to pass the barrier. These threads should pass the barrier in groups of three, and they must immediately bond with each other to form a water molecule. You must guarantee that all the threads from one molecule bond before any other threads from the next molecule do.</p>
|
||||
|
||||
<p>In other words:</p>
|
||||
|
||||
<ul>
|
||||
<li>If an oxygen thread arrives at the barrier when no hydrogen threads are present, it must wait for two hydrogen threads.</li>
|
||||
<li>If a hydrogen thread arrives at the barrier when no other threads are present, it must wait for an oxygen thread and another hydrogen thread.</li>
|
||||
</ul>
|
||||
|
||||
<p>We do not have to worry about matching the threads up explicitly; the threads do not necessarily know which other threads they are paired up with. The key is that threads pass the barriers in complete sets; thus, if we examine the sequence of threads that bind and divide them into groups of three, each group should contain one oxygen and two hydrogen threads.</p>
|
||||
|
||||
<p>Write synchronization code for oxygen and hydrogen molecules that enforces these constraints.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> water = "HOH"
|
||||
<strong>Output:</strong> "HHO"
|
||||
<strong>Explanation:</strong> "HOH" and "OHH" are also valid answers.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> water = "OOHHHH"
|
||||
<strong>Output:</strong> "HHOHHO"
|
||||
<strong>Explanation:</strong> "HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" and "OHHOHH" are also valid answers.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 * n == water.length</code></li>
|
||||
<li><code>1 <= n <= 20</code></li>
|
||||
<li><code>water[i]</code> is either <code>'H'</code> or <code>'O'</code>.</li>
|
||||
<li>There will be exactly <code>2 * n</code> <code>'H'</code> in <code>water</code>.</li>
|
||||
<li>There will be exactly <code>n</code> <code>'O'</code> in <code>water</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p><strong>HTML entity parser</strong> is the parser that takes HTML code as input and replace all the entities of the special characters by the characters itself.</p>
|
||||
|
||||
<p>The special characters and their entities for HTML are:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Quotation Mark:</strong> the entity is <code>&quot;</code> and symbol character is <code>"</code>.</li>
|
||||
<li><strong>Single Quote Mark:</strong> the entity is <code>&apos;</code> and symbol character is <code>'</code>.</li>
|
||||
<li><strong>Ampersand:</strong> the entity is <code>&amp;</code> and symbol character is <code>&</code>.</li>
|
||||
<li><strong>Greater Than Sign:</strong> the entity is <code>&gt;</code> and symbol character is <code>></code>.</li>
|
||||
<li><strong>Less Than Sign:</strong> the entity is <code>&lt;</code> and symbol character is <code><</code>.</li>
|
||||
<li><strong>Slash:</strong> the entity is <code>&frasl;</code> and symbol character is <code>/</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given the input <code>text</code> string to the HTML parser, you have to implement the entity parser.</p>
|
||||
|
||||
<p>Return <em>the text after replacing the entities by the special characters</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "&amp; is an HTML entity but &ambassador; is not."
|
||||
<strong>Output:</strong> "& is an HTML entity but &ambassador; is not."
|
||||
<strong>Explanation:</strong> The parser will replace the &amp; entity by &
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "and I quote: &quot;...&quot;"
|
||||
<strong>Output:</strong> "and I quote: \"...\""
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10<sup>5</sup></code></li>
|
||||
<li>The string may contain any possible characters out of all the 256 ASCII characters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,18 @@
|
||||
<p>Given a valid (IPv4) IP <code>address</code>, return a defanged version of that IP address.</p>
|
||||
|
||||
|
||||
|
||||
<p>A <em>defanged IP address</em> replaces every period <code>"."</code> with <code>"[.]"</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre><strong>Input:</strong> address = "1.1.1.1"
|
||||
|
||||
<strong>Output:</strong> "1[.]1[.]1[.]1"
|
||||
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given an integer array <code>arr</code> and an integer <code>k</code>, modify the array by repeating it <code>k</code> times.</p>
|
||||
|
||||
<p>For example, if <code>arr = [1, 2]</code> and <code>k = 3 </code>then the modified array will be <code>[1, 2, 1, 2, 1, 2]</code>.</p>
|
||||
|
||||
<p>Return the maximum sub-array sum in the modified array. Note that the length of the sub-array can be <code>0</code> and its sum in that case is <code>0</code>.</p>
|
||||
|
||||
<p>As the answer can be very large, return the answer <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,2], k = 3
|
||||
<strong>Output:</strong> 9
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,-2,1], k = 5
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [-1,-2], k = 7
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> representing the contents of a <b>pile</b>, where <code>nums[0]</code> is the topmost element of the pile.</p>
|
||||
|
||||
<p>In one move, you can perform <strong>either</strong> of the following:</p>
|
||||
|
||||
<ul>
|
||||
<li>If the pile is not empty, <strong>remove</strong> the topmost element of the pile.</li>
|
||||
<li>If there are one or more removed elements, <strong>add</strong> any one of them back onto the pile. This element becomes the new topmost element.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are also given an integer <code>k</code>, which denotes the total number of moves to be made.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum value</strong> of the topmost element of the pile possible after <strong>exactly</strong></em> <code>k</code> <em>moves</em>. In case it is not possible to obtain a non-empty pile after <code>k</code> moves, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,2,2,4,0,6], k = 4
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
One of the ways we can end with 5 at the top of the pile after 4 moves is as follows:
|
||||
- Step 1: Remove the topmost element = 5. The pile becomes [2,2,4,0,6].
|
||||
- Step 2: Remove the topmost element = 2. The pile becomes [2,4,0,6].
|
||||
- Step 3: Remove the topmost element = 2. The pile becomes [4,0,6].
|
||||
- Step 4: Add 5 back onto the pile. The pile becomes [5,4,0,6].
|
||||
Note that this is not the only way to end with 5 at the top of the pile. It can be shown that 5 is the largest answer possible after 4 moves.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2], k = 1
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong>
|
||||
In the first move, our only option is to pop the topmost element of the pile.
|
||||
Since it is not possible to obtain a non-empty pile after one move, we return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i], k <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>Given two strings <code>s</code> and <code>t</code>, your goal is to convert <code>s</code> into <code>t</code> in <code>k</code><strong> </strong>moves or less.</p>
|
||||
|
||||
<p>During the <code>i<sup>th</sup></code> (<font face="monospace"><code>1 <= i <= k</code>) </font>move you can:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose any index <code>j</code> (1-indexed) from <code>s</code>, such that <code>1 <= j <= s.length</code> and <code>j</code> has not been chosen in any previous move, and shift the character at that index <code>i</code> times.</li>
|
||||
<li>Do nothing.</li>
|
||||
</ul>
|
||||
|
||||
<p>Shifting a character means replacing it by the next letter in the alphabet (wrapping around so that <code>'z'</code> becomes <code>'a'</code>). Shifting a character by <code>i</code> means applying the shift operations <code>i</code> times.</p>
|
||||
|
||||
<p>Remember that any index <code>j</code> can be picked at most once.</p>
|
||||
|
||||
<p>Return <code>true</code> if it's possible to convert <code>s</code> into <code>t</code> in no more than <code>k</code> moves, otherwise return <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "input", t = "ouput", k = 9
|
||||
<strong>Output:</strong> true
|
||||
<b>Explanation: </b>In the 6th move, we shift 'i' 6 times to get 'o'. And in the 7th move we shift 'n' to get 'u'.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abc", t = "bcd", k = 10
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation: </strong>We need to shift each character in s one time to convert it into t. We can shift 'a' to 'b' during the 1st move. However, there is no way to shift the other characters in the remaining moves to obtain t from s.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aab", t = "bbb", k = 27
|
||||
<strong>Output:</strong> true
|
||||
<b>Explanation: </b>In the 1st move, we shift the first 'a' 1 time to get 'b'. In the 27th move, we shift the second 'a' 27 times to get 'b'.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length, t.length <= 10^5</code></li>
|
||||
<li><code>0 <= k <= 10^9</code></li>
|
||||
<li><code>s</code>, <code>t</code> contain only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an undirected tree consisting of <code>n</code> vertices numbered from <code>1</code> to <code>n</code>. A frog starts jumping from <strong>vertex 1</strong>. In one second, the frog jumps from its current vertex to another <strong>unvisited</strong> vertex if they are directly connected. The frog can not jump back to a visited vertex. In case the frog can jump to several vertices, it jumps randomly to one of them with the same probability. Otherwise, when the frog can not jump to any unvisited vertex, it jumps forever on the same vertex.</p>
|
||||
|
||||
<p>The edges of the undirected tree are given in the array <code>edges</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> means that exists an edge connecting the vertices <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.</p>
|
||||
|
||||
<p><em>Return the probability that after <code>t</code> seconds the frog is on the vertex <code>target</code>. </em>Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/frog1.jpg" style="width: 338px; height: 304px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4
|
||||
<strong>Output:</strong> 0.16666666666666666
|
||||
<strong>Explanation:</strong> The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 probability to the vertex 2 after <strong>second 1</strong> and then jumping with 1/2 probability to vertex 4 after <strong>second 2</strong>. Thus the probability for the frog is on the vertex 4 after 2 seconds is 1/3 * 1/2 = 1/6 = 0.16666666666666666.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<strong><img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/frog2.jpg" style="width: 304px; height: 304px;" /></strong>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 7
|
||||
<strong>Output:</strong> 0.3333333333333333
|
||||
<strong>Explanation: </strong>The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 = 0.3333333333333333 probability to the vertex 7 after <strong>second 1</strong>.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code></li>
|
||||
<li><code>1 <= t <= 50</code></li>
|
||||
<li><code>1 <= target <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>You are given two positive integers <code>n</code> and <code>k</code>. A factor of an integer <code>n</code> is defined as an integer <code>i</code> where <code>n % i == 0</code>.</p>
|
||||
|
||||
<p>Consider a list of all factors of <code>n</code> sorted in <strong>ascending order</strong>, return <em>the </em><code>k<sup>th</sup></code><em> factor</em> in this list or return <code>-1</code> if <code>n</code> has less than <code>k</code> factors.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 12, k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Factors list is [1, 2, 3, 4, 6, 12], the 3<sup>rd</sup> factor is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, k = 2
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Factors list is [1, 7], the 2<sup>nd</sup> factor is 7.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, k = 4
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> Factors list is [1, 2, 4], there is only 3 factors. We should return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= n <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given a string <code>text</code>, you want to use the characters of <code>text</code> to form as many instances of the word <strong>"balloon"</strong> as possible.</p>
|
||||
|
||||
<p>You can use each character in <code>text</code> <strong>at most once</strong>. Return the maximum number of instances that can be formed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/09/05/1536_ex1_upd.JPG" style="width: 132px; height: 35px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "nlaebolko"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/09/05/1536_ex2_upd.JPG" style="width: 267px; height: 35px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "loonbalxballpoon"
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "leetcode"
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>text</code> consists of lower case English letters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given a date, return the corresponding day of the week for that date.</p>
|
||||
|
||||
<p>The input is given as three integers representing the <code>day</code>, <code>month</code> and <code>year</code> respectively.</p>
|
||||
|
||||
<p>Return the answer as one of the following values <code>{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 31, month = 8, year = 2019
|
||||
<strong>Output:</strong> "Saturday"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 18, month = 7, year = 1999
|
||||
<strong>Output:</strong> "Sunday"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> day = 15, month = 8, year = 1993
|
||||
<strong>Output:</strong> "Sunday"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The given dates are valid dates between the years <code>1971</code> and <code>2100</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given a string <code>date</code> representing a <a href="https://en.wikipedia.org/wiki/Gregorian_calendar" target="_blank">Gregorian calendar</a> date formatted as <code>YYYY-MM-DD</code>, return <em>the day number of the year</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> date = "2019-01-09"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Given date is the 9th day of the year in 2019.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> date = "2019-02-10"
|
||||
<strong>Output:</strong> 41
|
||||
</pre>
|
||||
|
||||
<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><code>date</code> represents a calendar date between Jan 1<sup>st</sup>, 1900 and Dec 31<sup>th</sup>, 2019.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>Given an array <code>nums</code>. We define a running sum of an array as <code>runningSum[i] = sum(nums[0]…nums[i])</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p>Return the running sum of <code>nums</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
|
||||
<strong>Output:</strong> [1,3,6,10]
|
||||
|
||||
<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].</pre>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> nums = [1,1,1,1,1]
|
||||
|
||||
<strong>Output:</strong> [1,2,3,4,5]
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>You are given an integer array <code>nums</code>. In one move, you can choose one element of <code>nums</code> and change it by <strong>any value</strong>.</p>
|
||||
|
||||
<p>Return <em>the minimum difference between the largest and smallest value of <code>nums</code> after performing <strong>at most three moves</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,3,2,4]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Change the array [5,3,2,4] to [<strong>2</strong>,<strong>2</strong>,2,<strong>2</strong>].
|
||||
The difference between the maximum and minimum is 2-2 = 0.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,5,0,10,14]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Change the array [1,5,0,10,14] to [1,<strong>1</strong>,0,<strong>1</strong>,<strong>1</strong>].
|
||||
The difference between the maximum and minimum is 1-0 = 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a string <code>s</code>. Reorder the string using the following algorithm:</p>
|
||||
|
||||
<ol>
|
||||
<li>Pick the <strong>smallest</strong> character from <code>s</code> and <strong>append</strong> it to the result.</li>
|
||||
<li>Pick the <strong>smallest</strong> character from <code>s</code> which is greater than the last appended character to the result and <strong>append</strong> it.</li>
|
||||
<li>Repeat step 2 until you cannot pick more characters.</li>
|
||||
<li>Pick the <strong>largest</strong> character from <code>s</code> and <strong>append</strong> it to the result.</li>
|
||||
<li>Pick the <strong>largest</strong> character from <code>s</code> which is smaller than the last appended character to the result and <strong>append</strong> it.</li>
|
||||
<li>Repeat step 5 until you cannot pick more characters.</li>
|
||||
<li>Repeat the steps from 1 to 6 until you pick all characters from <code>s</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.</p>
|
||||
|
||||
<p>Return <em>the result string after sorting </em><code>s</code><em> with this algorithm</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aaaabbbbcccc"
|
||||
<strong>Output:</strong> "abccbaabccba"
|
||||
<strong>Explanation:</strong> After steps 1, 2 and 3 of the first iteration, result = "abc"
|
||||
After steps 4, 5 and 6 of the first iteration, result = "abccba"
|
||||
First iteration is done. Now s = "aabbcc" and we go back to step 1
|
||||
After steps 1, 2 and 3 of the second iteration, result = "abccbaabc"
|
||||
After steps 4, 5 and 6 of the second iteration, result = "abccbaabccba"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "rat"
|
||||
<strong>Output:</strong> "art"
|
||||
<strong>Explanation:</strong> The word "rat" becomes "art" after re-ordering it with the mentioned algorithm.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 500</code></li>
|
||||
<li><code>s</code> consists of only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>Given an <code>n x n</code> integer matrix <code>grid</code>, return <em>the minimum sum of a <strong>falling path with non-zero shifts</strong></em>.</p>
|
||||
|
||||
<p>A <strong>falling path with non-zero shifts</strong> is a choice of exactly one element from each row of <code>grid</code> such that no two elements chosen in adjacent rows are in the same column.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/falling-grid.jpg" style="width: 244px; height: 245px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [[1,2,3],[4,5,6],[7,8,9]]
|
||||
<strong>Output:</strong> 13
|
||||
<strong>Explanation:</strong>
|
||||
The possible falling paths are:
|
||||
[1,5,9], [1,5,7], [1,6,7], [1,6,8],
|
||||
[2,4,8], [2,4,9], [2,6,7], [2,6,8],
|
||||
[3,4,8], [3,4,9], [3,5,7], [3,5,9]
|
||||
The falling path with the smallest sum is [1,5,7], so the answer is 13.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[7]]
|
||||
<strong>Output:</strong> 7
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == grid.length == grid[i].length</code></li>
|
||||
<li><code>1 <= n <= 200</code></li>
|
||||
<li><code>-99 <= grid[i][j] <= 99</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given a string <code>s</code>, return <em>the lexicographically smallest subsequence of</em> <code>s</code> <em>that contains all the distinct characters of</em> <code>s</code> <em>exactly once</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "bcabc"
|
||||
<strong>Output:</strong> "abc"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "cbacdcbc"
|
||||
<strong>Output:</strong> "acdb"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Note:</strong> This question is the same as 316: <a href="https://leetcode.com/problems/remove-duplicate-letters/" target="_blank">https://leetcode.com/problems/remove-duplicate-letters/</a>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Given an array of integers <code>arr</code> and an integer <code>k</code>. Find the <em>least number of unique integers</em> after removing <strong>exactly</strong> <code>k</code> elements<b>.</b></p>
|
||||
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input: </strong>arr = [5,5,4], k = 1
|
||||
|
||||
<strong>Output: </strong>1
|
||||
|
||||
<strong>Explanation</strong>: Remove the single 4, only 5 is left.
|
||||
|
||||
</pre>
|
||||
|
||||
<strong>Example 2:</strong>
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Return the number of <strong>distinct</strong> non-empty substrings of <code>text</code> that can be written as the concatenation of some string with itself (i.e. it can be written as <code>a + a</code> where <code>a</code> is some string).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "abcabcabc"
|
||||
<strong>Output:</strong> 3
|
||||
<b>Explanation: </b>The 3 substrings are "abcabc", "bcabca" and "cabcab".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "leetcodeleetcode"
|
||||
<strong>Output:</strong> 2
|
||||
<b>Explanation: </b>The 2 substrings are "ee" and "leetcodeleetcode".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 2000</code></li>
|
||||
<li><code>text</code> has only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>Given two integers <code>tomatoSlices</code> and <code>cheeseSlices</code>. The ingredients of different burgers are as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Jumbo Burger:</strong> <code>4</code> tomato slices and <code>1</code> cheese slice.</li>
|
||||
<li><strong>Small Burger:</strong> <code>2</code> Tomato slices and <code>1</code> cheese slice.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <code>[total_jumbo, total_small]</code> so that the number of remaining <code>tomatoSlices</code> equal to <code>0</code> and the number of remaining <code>cheeseSlices</code> equal to <code>0</code>. If it is not possible to make the remaining <code>tomatoSlices</code> and <code>cheeseSlices</code> equal to <code>0</code> return <code>[]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tomatoSlices = 16, cheeseSlices = 7
|
||||
<strong>Output:</strong> [1,6]
|
||||
<strong>Explantion:</strong> To make one jumbo burger and 6 small burgers we need 4*1 + 2*6 = 16 tomato and 1 + 6 = 7 cheese.
|
||||
There will be no remaining ingredients.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tomatoSlices = 17, cheeseSlices = 4
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explantion:</strong> There will be no way to use all ingredients to make small and jumbo burgers.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tomatoSlices = 4, cheeseSlices = 17
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explantion:</strong> Making 1 jumbo burger there will be 16 cheese remaining and making 2 small burgers there will be 15 cheese remaining.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= tomatoSlices, cheeseSlices <= 10<sup>7</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>. We write the integers of <code>nums1</code> and <code>nums2</code> (in the order they are given) on two separate horizontal lines.</p>
|
||||
|
||||
<p>We may draw connecting lines: a straight line connecting two numbers <code>nums1[i]</code> and <code>nums2[j]</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>nums1[i] == nums2[j]</code>, and</li>
|
||||
<li>the line we draw does not intersect any other connecting (non-horizontal) line.</li>
|
||||
</ul>
|
||||
|
||||
<p>Note that a connecting line cannot intersect even at the endpoints (i.e., each number can only belong to one connecting line).</p>
|
||||
|
||||
<p>Return <em>the maximum number of connecting lines we can draw in this way</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/04/26/142.png" style="width: 400px; height: 286px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,4,2], nums2 = [1,2,4]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can draw 2 uncrossed lines as in the diagram.
|
||||
We cannot draw 3 uncrossed lines, because the line from nums1[1] = 4 to nums2[2] = 4 will intersect the line from nums1[2]=2 to nums2[1]=2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 500</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[j] <= 2000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You have <code>n</code> gardens, labeled from <code>1</code> to <code>n</code>, and an array <code>paths</code> where <code>paths[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> describes a bidirectional path between garden <code>x<sub>i</sub></code> to garden <code>y<sub>i</sub></code>. In each garden, you want to plant one of 4 types of flowers.</p>
|
||||
|
||||
<p>All gardens have <strong>at most 3</strong> paths coming into or leaving it.</p>
|
||||
|
||||
<p>Your task is to choose a flower type for each garden such that, for any two gardens connected by a path, they have different types of flowers.</p>
|
||||
|
||||
<p>Return <em><strong>any</strong> such a choice as an array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> is the type of flower planted in the </em><code>(i+1)<sup>th</sup></code><em> garden. The flower types are denoted </em><code>1</code><em>, </em><code>2</code><em>, </em><code>3</code><em>, or </em><code>4</code><em>. It is guaranteed an answer exists.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, paths = [[1,2],[2,3],[3,1]]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
<strong>Explanation:</strong>
|
||||
Gardens 1 and 2 have different types.
|
||||
Gardens 2 and 3 have different types.
|
||||
Gardens 3 and 1 have different types.
|
||||
Hence, [1,2,3] is a valid answer. Other valid answers include [1,2,4], [1,4,2], and [3,2,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, paths = [[1,2],[3,4]]
|
||||
<strong>Output:</strong> [1,2,1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
|
||||
<strong>Output:</strong> [1,2,3,4]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= paths.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>paths[i].length == 2</code></li>
|
||||
<li><code>1 <= x<sub>i</sub>, y<sub>i</sub> <= n</code></li>
|
||||
<li><code>x<sub>i</sub> != y<sub>i</sub></code></li>
|
||||
<li>Every garden has <strong>at most 3</strong> paths coming into or leaving it.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>An <strong>ugly number</strong> is a positive integer that is divisible by <code>a</code>, <code>b</code>, or <code>c</code>.</p>
|
||||
|
||||
<p>Given four integers <code>n</code>, <code>a</code>, <code>b</code>, and <code>c</code>, return the <code>n<sup>th</sup></code> <strong>ugly number</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, a = 2, b = 3, c = 5
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The ugly numbers are 2, 3, 4, 5, 6, 8, 9, 10... The 3<sup>rd</sup> is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, a = 2, b = 3, c = 4
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The ugly numbers are 2, 3, 4, 6, 8, 9, 10, 12... The 4<sup>th</sup> is 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, a = 2, b = 11, c = 13
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The ugly numbers are 2, 4, 6, 8, 10, 11, 12, 13... The 5<sup>th</sup> is 10.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, a, b, c <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= a * b * c <= 10<sup>18</sup></code></li>
|
||||
<li>It is guaranteed that the result will be in range <code>[1, 2 * 10<sup>9</sup>]</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>s</code> and are tasked with finding two <strong>non-intersecting palindromic </strong>substrings of <strong>odd</strong> length such that the product of their lengths is maximized.</p>
|
||||
|
||||
<p>More formally, you want to choose four integers <code>i</code>, <code>j</code>, <code>k</code>, <code>l</code> such that <code>0 <= i <= j < k <= l < s.length</code> and both the substrings <code>s[i...j]</code> and <code>s[k...l]</code> are palindromes and have odd lengths. <code>s[i...j]</code> denotes a substring from index <code>i</code> to index <code>j</code> <strong>inclusive</strong>.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> possible product of the lengths of the two non-intersecting palindromic substrings.</em></p>
|
||||
|
||||
<p>A <strong>palindrome</strong> is a string that is the same forward and backward. A <strong>substring</strong> is a contiguous sequence of characters in a string.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ababbb"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Substrings "aba" and "bbb" are palindromes with odd length. product = 3 * 3 = 9.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "zaaaxbbby"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Substrings "aaa" and "bbb" are palindromes with odd length. product = 3 * 3 = 9.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given two arrays <code>nums1</code> and <code><font face="monospace">nums2</font></code><font face="monospace">.</font></p>
|
||||
|
||||
<p>Return the maximum dot product between <strong>non-empty</strong> subsequences of nums1 and nums2 with the same length.</p>
|
||||
|
||||
<p>A subsequence of a array is a new array which is formed from the original array by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, <code>[2,3,5]</code> is a subsequence of <code>[1,2,3,4,5]</code> while <code>[1,5,3]</code> is not).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [2,1,-2,5], nums2 = [3,0,-6]
|
||||
<strong>Output:</strong> 18
|
||||
<strong>Explanation:</strong> Take subsequence [2,-2] from nums1 and subsequence [3,-6] from nums2.
|
||||
Their dot product is (2*3 + (-2)*(-6)) = 18.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [3,-2], nums2 = [2,-6,7]
|
||||
<strong>Output:</strong> 21
|
||||
<strong>Explanation:</strong> Take subsequence [3] from nums1 and subsequence [7] from nums2.
|
||||
Their dot product is (3*7) = 21.</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [-1,-1], nums2 = [1,1]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation: </strong>Take subsequence [-1] from nums1 and subsequence [1] from nums2.
|
||||
Their dot product is -1.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 500</code></li>
|
||||
<li><code>-1000 <= nums1[i], nums2[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>Given two integer arrays <code>arr1</code> and <code>arr2</code>, and the integer <code>d</code>, <em>return the distance value between the two arrays</em>.</p>
|
||||
|
||||
<p>The distance value is defined as the number of elements <code>arr1[i]</code> such that there is not any element <code>arr2[j]</code> where <code>|arr1[i]-arr2[j]| <= d</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
For arr1[0]=4 we have:
|
||||
|4-10|=6 > d=2
|
||||
|4-9|=5 > d=2
|
||||
|4-1|=3 > d=2
|
||||
|4-8|=4 > d=2
|
||||
For arr1[1]=5 we have:
|
||||
|5-10|=5 > d=2
|
||||
|5-9|=4 > d=2
|
||||
|5-1|=4 > d=2
|
||||
|5-8|=3 > d=2
|
||||
For arr1[2]=8 we have:
|
||||
<strong>|8-10|=2 <= d=2</strong>
|
||||
<strong>|8-9|=1 <= d=2</strong>
|
||||
|8-1|=7 > d=2
|
||||
<strong>|8-8|=0 <= d=2</strong>
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr1.length, arr2.length <= 500</code></li>
|
||||
<li><code>-1000 <= arr1[i], arr2[j] <= 1000</code></li>
|
||||
<li><code>0 <= d <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>Given <code>2n</code> balls of <code>k</code> distinct colors. You will be given an integer array <code>balls</code> of size <code>k</code> where <code>balls[i]</code> is the number of balls of color <code>i</code>.</p>
|
||||
|
||||
<p>All the balls will be <strong>shuffled uniformly at random</strong>, then we will distribute the first <code>n</code> balls to the first box and the remaining <code>n</code> balls to the other box (Please read the explanation of the second example carefully).</p>
|
||||
|
||||
<p>Please note that the two boxes are considered different. For example, if we have two balls of colors <code>a</code> and <code>b</code>, and two boxes <code>[]</code> and <code>()</code>, then the distribution <code>[a] (b)</code> is considered different than the distribution <code>[b] (a) </code>(Please read the explanation of the first example carefully).</p>
|
||||
|
||||
<p>Return<em> the probability</em> that the two boxes have the same number of distinct balls. Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted as correct.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> balls = [1,1]
|
||||
<strong>Output:</strong> 1.00000
|
||||
<strong>Explanation:</strong> Only 2 ways to divide the balls equally:
|
||||
- A ball of color 1 to box 1 and a ball of color 2 to box 2
|
||||
- A ball of color 2 to box 1 and a ball of color 1 to box 2
|
||||
In both ways, the number of distinct colors in each box is equal. The probability is 2/2 = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> balls = [2,1,1]
|
||||
<strong>Output:</strong> 0.66667
|
||||
<strong>Explanation:</strong> We have the set of balls [1, 1, 2, 3]
|
||||
This set of balls will be shuffled randomly and we may have one of the 12 distinct shuffles with equal probability (i.e. 1/12):
|
||||
[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]
|
||||
After that, we add the first two balls to the first box and the second two balls to the second box.
|
||||
We can see that 8 of these 12 possible random distributions have the same number of distinct colors of balls in each box.
|
||||
Probability is 8/12 = 0.66667
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> balls = [1,2,1,2]
|
||||
<strong>Output:</strong> 0.60000
|
||||
<strong>Explanation:</strong> The set of balls is [1, 2, 2, 3, 4, 4]. It is hard to display all the 180 possible random shuffles of this set but it is easy to check that 108 of them will have the same number of distinct colors in each box.
|
||||
Probability = 108 / 180 = 0.6
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= balls.length <= 8</code></li>
|
||||
<li><code>1 <= balls[i] <= 6</code></li>
|
||||
<li><code>sum(balls)</code> is even.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,24 @@
|
||||
<p>Given two binary search trees <code>root1</code> and <code>root2</code>, return <em>a list containing all the integers from both trees sorted in <strong>ascending</strong> order</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/q2-e1.png" style="width: 457px; height: 207px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root1 = [2,1,4], root2 = [1,0,3]
|
||||
<strong>Output:</strong> [0,1,1,2,3,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/q2-e5-.png" style="width: 352px; height: 197px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root1 = [1,null,8], root2 = [8,1]
|
||||
<strong>Output:</strong> [1,1,8,8]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in each tree is in the range <code>[0, 5000]</code>.</li>
|
||||
<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given an array of strings <code>arr</code>. A string <code>s</code> is formed by the <strong>concatenation</strong> of a <strong>subsequence</strong> of <code>arr</code> that has <strong>unique characters</strong>.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> possible length</em> of <code>s</code>.</p>
|
||||
|
||||
<p>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = ["un","iq","ue"]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> All the valid concatenations are:
|
||||
- ""
|
||||
- "un"
|
||||
- "iq"
|
||||
- "ue"
|
||||
- "uniq" ("un" + "iq")
|
||||
- "ique" ("iq" + "ue")
|
||||
Maximum length is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = ["cha","r","act","ers"]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Possible longest valid concatenations are "chaers" ("cha" + "ers") and "acters" ("act" + "ers").
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = ["abcdefghijklmnopqrstuvwxyz"]
|
||||
<strong>Output:</strong> 26
|
||||
<strong>Explanation:</strong> The only string in arr has all 26 characters.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 16</code></li>
|
||||
<li><code>1 <= arr[i].length <= 26</code></li>
|
||||
<li><code>arr[i]</code> contains only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>Given a <strong>binary tree</strong> <code>root</code>, return <em>the maximum sum of all keys of <strong>any</strong> sub-tree which is also a Binary Search Tree (BST)</em>.</p>
|
||||
|
||||
<p>Assume a BST is defined as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
|
||||
<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
|
||||
<li>Both the left and right subtrees must also be binary search trees.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/01/30/sample_1_1709.png" style="width: 320px; height: 250px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation:</strong> Maximum sum in a valid Binary search tree is obtained in root node with key equal to 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/01/30/sample_2_1709.png" style="width: 134px; height: 180px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [4,3,null,1,2]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Maximum sum in a valid Binary search tree is obtained in a single root node with key equal to 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [-4,-2,-5]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> All values are negatives. Return an empty BST.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 4 * 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-4 * 10<sup>4</sup> <= Node.val <= 4 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given a binary tree where node values are digits from 1 to 9. A path in the binary tree is said to be <strong>pseudo-palindromic</strong> if at least one permutation of the node values in the path is a palindrome.</p>
|
||||
|
||||
<p><em>Return the number of <strong>pseudo-palindromic</strong> paths going from the root node to leaf nodes.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/05/06/palindromic_paths_1.png" style="width: 300px; height: 201px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,3,1,3,1,null,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the red path [2,3,3], the green path [2,1,1], and the path [2,3,1]. Among these paths only red path and green path are pseudo-palindromic paths since the red path [2,3,3] can be rearranged in [3,2,3] (palindrome) and the green path [2,1,1] can be rearranged in [1,2,1] (palindrome).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/05/07/palindromic_paths_2.png" style="width: 300px; height: 314px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,1,1,1,3,null,null,null,null,null,1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the green path [2,1,1], the path [2,1,3,1], and the path [2,1]. Among these paths only the green path is pseudo-palindromic since [2,1,1] can be rearranged in [1,2,1] (palindrome).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [9]
|
||||
<strong>Output:</strong> 1
|
||||
</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 <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>Given a binary tree <code>root</code> and a linked list with <code>head</code> as the first node. </p>
|
||||
|
||||
<p>Return True if all the elements in the linked list starting from the <code>head</code> correspond to some <em>downward path</em> connected in the binary tree otherwise return False.</p>
|
||||
|
||||
<p>In this context downward path means a path that starts at some node and goes downwards.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/02/12/sample_1_1720.png" style="width: 220px; height: 280px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Nodes in blue form a subpath in the binary Tree.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/02/12/sample_2_1720.png" style="width: 220px; height: 280px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,4,2,6], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,4,2,6,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> There is no path in the binary tree that contains all the elements of the linked list from <code>head</code>.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree will be in the range <code>[1, 2500]</code>.</li>
|
||||
<li>The number of nodes in the list will be in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 100</code> for each node in the linked list and binary tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given the <code>root</code> of a binary tree.</p>
|
||||
|
||||
<p>A ZigZag path for a binary tree is defined as follow:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose <strong>any </strong>node in the binary tree and a direction (right or left).</li>
|
||||
<li>If the current direction is right, move to the right child of the current node; otherwise, move to the left child.</li>
|
||||
<li>Change the direction from right to left or from left to right.</li>
|
||||
<li>Repeat the second and third steps until you can't move in the tree.</li>
|
||||
</ul>
|
||||
|
||||
<p>Zigzag length is defined as the number of nodes visited - 1. (A single node has a length of 0).</p>
|
||||
|
||||
<p>Return <em>the longest <strong>ZigZag</strong> path contained in that tree</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/22/sample_1_1702.png" style="width: 221px; height: 383px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Longest ZigZag path in blue nodes (right -> left -> right).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/22/sample_2_1702.png" style="width: 157px; height: 329px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,1,1,null,1,null,null,1,1,null,1]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Longest ZigZag path in blue nodes (left -> right -> left -> right).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 5 * 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>In an infinite binary tree where every node has two children, the nodes are labelled in row order.</p>
|
||||
|
||||
<p>In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/06/24/tree.png" style="width: 300px; height: 138px;" /></p>
|
||||
|
||||
<p>Given the <code>label</code> of a node in this tree, return the labels in the path from the root of the tree to the node with that <code>label</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> label = 14
|
||||
<strong>Output:</strong> [1,3,4,14]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> label = 26
|
||||
<strong>Output:</strong> [1,2,6,10,26]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= label <= 10^6</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Two players play a turn based game on a binary tree. We are given the <code>root</code> of this binary tree, and the number of nodes <code>n</code> in the tree. <code>n</code> is odd, and each node has a distinct value from <code>1</code> to <code>n</code>.</p>
|
||||
|
||||
<p>Initially, the first player names a value <code>x</code> with <code>1 <= x <= n</code>, and the second player names a value <code>y</code> with <code>1 <= y <= n</code> and <code>y != x</code>. The first player colors the node with value <code>x</code> red, and the second player colors the node with value <code>y</code> blue.</p>
|
||||
|
||||
<p>Then, the players take turns starting with the first player. In each turn, that player chooses a node of their color (red if player 1, blue if player 2) and colors an <strong>uncolored</strong> neighbor of the chosen node (either the left child, right child, or parent of the chosen node.)</p>
|
||||
|
||||
<p>If (and only if) a player cannot choose such a node in this way, they must pass their turn. If both players pass their turn, the game ends, and the winner is the player that colored more nodes.</p>
|
||||
|
||||
<p>You are the second player. If it is possible to choose such a <code>y</code> to ensure you win the game, return <code>true</code>. If it is not possible, return <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/08/01/1480-binary-tree-coloring-game.png" style="width: 500px; height: 310px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>The second player can choose the node with value 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3], n = 3, x = 1
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is <code>n</code>.</li>
|
||||
<li><code>1 <= x <= n <= 100</code></li>
|
||||
<li><code>n</code> is odd.</li>
|
||||
<li>1 <= Node.val <= n</li>
|
||||
<li>All the values of the tree are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/02/leetcode_keyboard.png" style="width: 349px; height: 209px;" />
|
||||
<p>You have a keyboard layout as shown above in the <strong>X-Y</strong> plane, where each English uppercase letter is located at some coordinate.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the letter <code>'A'</code> is located at coordinate <code>(0, 0)</code>, the letter <code>'B'</code> is located at coordinate <code>(0, 1)</code>, the letter <code>'P'</code> is located at coordinate <code>(2, 3)</code> and the letter <code>'Z'</code> is located at coordinate <code>(4, 1)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given the string <code>word</code>, return <em>the minimum total <strong>distance</strong> to type such string using only two fingers</em>.</p>
|
||||
|
||||
<p>The <strong>distance</strong> between coordinates <code>(x<sub>1</sub>, y<sub>1</sub>)</code> and <code>(x<sub>2</sub>, y<sub>2</sub>)</code> is <code>|x<sub>1</sub> - x<sub>2</sub>| + |y<sub>1</sub> - y<sub>2</sub>|</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the initial positions of your two fingers are considered free so do not count towards your total distance, also your two fingers do not have to start at the first letter or the first two letters.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "CAKE"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Using two fingers, one optimal way to type "CAKE" is:
|
||||
Finger 1 on letter 'C' -> cost = 0
|
||||
Finger 1 on letter 'A' -> cost = Distance from letter 'C' to letter 'A' = 2
|
||||
Finger 2 on letter 'K' -> cost = 0
|
||||
Finger 2 on letter 'E' -> cost = Distance from letter 'K' to letter 'E' = 1
|
||||
Total distance = 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "HAPPY"
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Using two fingers, one optimal way to type "HAPPY" is:
|
||||
Finger 1 on letter 'H' -> cost = 0
|
||||
Finger 1 on letter 'A' -> cost = Distance from letter 'H' to letter 'A' = 2
|
||||
Finger 2 on letter 'P' -> cost = 0
|
||||
Finger 2 on letter 'P' -> cost = Distance from letter 'P' to letter 'P' = 0
|
||||
Finger 1 on letter 'Y' -> cost = Distance from letter 'A' to letter 'Y' = 4
|
||||
Total distance = 6
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= word.length <= 300</code></li>
|
||||
<li><code>word</code> consists of uppercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>Given a 2D <code>grid</code> of size <code>m x n</code> and an integer <code>k</code>. You need to shift the <code>grid</code> <code>k</code> times.</p>
|
||||
|
||||
<p>In one shift operation:</p>
|
||||
|
||||
<ul>
|
||||
<li>Element at <code>grid[i][j]</code> moves to <code>grid[i][j + 1]</code>.</li>
|
||||
<li>Element at <code>grid[i][n - 1]</code> moves to <code>grid[i + 1][0]</code>.</li>
|
||||
<li>Element at <code>grid[m - 1][n - 1]</code> moves to <code>grid[0][0]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <em>2D grid</em> after applying shift operation <code>k</code> times.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/11/05/e1.png" style="width: 400px; height: 178px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> <code>grid</code> = [[1,2,3],[4,5,6],[7,8,9]], k = 1
|
||||
<strong>Output:</strong> [[9,1,2],[3,4,5],[6,7,8]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/11/05/e2.png" style="width: 400px; height: 166px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> <code>grid</code> = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
|
||||
<strong>Output:</strong> [[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> <code>grid</code> = [[1,2,3],[4,5,6],[7,8,9]], k = 9
|
||||
<strong>Output:</strong> [[1,2,3],[4,5,6],[7,8,9]]
|
||||
</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 <= 50</code></li>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>-1000 <= grid[i][j] <= 1000</code></li>
|
||||
<li><code>0 <= k <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You have a <strong>1-indexed</strong> binary string of length <code>n</code> where all the bits are <code>0</code> initially. We will flip all the bits of this binary string (i.e., change them from <code>0</code> to <code>1</code>) one by one. You are given a <strong>1-indexed</strong> integer array <code>flips</code> where <code>flips[i]</code> indicates that the bit at index <code>i</code> will be flipped in the <code>i<sup>th</sup></code> step.</p>
|
||||
|
||||
<p>A binary string is <strong>prefix-aligned</strong> if, after the <code>i<sup>th</sup></code> step, all the bits in the <strong>inclusive</strong> range <code>[1, i]</code> are ones and all the other bits are zeros.</p>
|
||||
|
||||
<p>Return <em>the number of times the binary string is <strong>prefix-aligned</strong> during the flipping process</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> flips = [3,2,4,1,5]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The binary string is initially "00000".
|
||||
After applying step 1: The string becomes "00100", which is not prefix-aligned.
|
||||
After applying step 2: The string becomes "01100", which is not prefix-aligned.
|
||||
After applying step 3: The string becomes "01110", which is not prefix-aligned.
|
||||
After applying step 4: The string becomes "11110", which is prefix-aligned.
|
||||
After applying step 5: The string becomes "11111", which is prefix-aligned.
|
||||
We can see that the string was prefix-aligned 2 times, so we return 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> flips = [4,1,2,3]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The binary string is initially "0000".
|
||||
After applying step 1: The string becomes "0001", which is not prefix-aligned.
|
||||
After applying step 2: The string becomes "1001", which is not prefix-aligned.
|
||||
After applying step 3: The string becomes "1101", which is not prefix-aligned.
|
||||
After applying step 4: The string becomes "1111", which is prefix-aligned.
|
||||
We can see that the string was prefix-aligned 1 time, so we return 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == flips.length</code></li>
|
||||
<li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>flips</code> is a permutation of the integers in the range <code>[1, n]</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>Given an <code>n x n</code> binary matrix <code>grid</code>, return <em>the length of the shortest <strong>clear path</strong> in the matrix</em>. If there is no clear path, return <code>-1</code>.</p>
|
||||
|
||||
<p>A <strong>clear path</strong> in a binary matrix is a path from the <strong>top-left</strong> cell (i.e., <code>(0, 0)</code>) to the <strong>bottom-right</strong> cell (i.e., <code>(n - 1, n - 1)</code>) such that:</p>
|
||||
|
||||
<ul>
|
||||
<li>All the visited cells of the path are <code>0</code>.</li>
|
||||
<li>All the adjacent cells of the path are <strong>8-directionally</strong> connected (i.e., they are different and they share an edge or a corner).</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>length of a clear path</strong> is the number of visited cells of this path.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example1_1.png" style="width: 500px; height: 234px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,1],[1,0]]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example2_1.png" style="height: 216px; width: 500px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,0,0],[1,1,0],[1,1,0]]
|
||||
<strong>Output:</strong> 4
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,0,0],[1,1,0],[1,1,0]]
|
||||
<strong>Output:</strong> -1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>grid[i][j] is 0 or 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Given <code>head</code> which is a reference node to a singly-linked list. The value of each node in the linked list is either <code>0</code> or <code>1</code>. The linked list holds the binary representation of a number.</p>
|
||||
|
||||
<p>Return the <em>decimal value</em> of the number in the linked list.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/05/graph-1.png" style="width: 426px; height: 108px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,0,1]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> (101) in base 2 = (5) in base 10
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [0]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The Linked List is not empty.</li>
|
||||
<li>Number of nodes will not exceed <code>30</code>.</li>
|
||||
<li>Each node's value is either <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given an array of positive integers <code>arr</code> (not necessarily distinct), return <em>the lexicographically largest permutation that is smaller than</em> <code>arr</code>, that can be <strong>made with exactly one swap</strong> (A <em>swap</em> exchanges the positions of two numbers <code>arr[i]</code> and <code>arr[j]</code>). If it cannot be done, then return the same array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [3,2,1]
|
||||
<strong>Output:</strong> [3,1,2]
|
||||
<strong>Explanation:</strong> Swapping 2 and 1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,1,5]
|
||||
<strong>Output:</strong> [1,1,5]
|
||||
<strong>Explanation:</strong> This is already the smallest permutation.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,9,4,6,7]
|
||||
<strong>Output:</strong> [1,7,4,6,9]
|
||||
<strong>Explanation:</strong> Swapping 9 and 7.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You are given a string <code>s</code>, and an array of pairs of indices in the string <code>pairs</code> where <code>pairs[i] = [a, b]</code> indicates 2 indices(0-indexed) of the string.</p>
|
||||
|
||||
<p>You can swap the characters at any pair of indices in the given <code>pairs</code> <strong>any number of times</strong>.</p>
|
||||
|
||||
<p>Return the lexicographically smallest string that <code>s</code> can be changed to after using the swaps.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "dcab", pairs = [[0,3],[1,2]]
|
||||
<strong>Output:</strong> "bacd"
|
||||
<strong>Explaination:</strong>
|
||||
Swap s[0] and s[3], s = "bcad"
|
||||
Swap s[1] and s[2], s = "bacd"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "dcab", pairs = [[0,3],[1,2],[0,2]]
|
||||
<strong>Output:</strong> "abcd"
|
||||
<strong>Explaination: </strong>
|
||||
Swap s[0] and s[3], s = "bcad"
|
||||
Swap s[0] and s[2], s = "acbd"
|
||||
Swap s[1] and s[2], s = "abcd"</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "cba", pairs = [[0,1],[1,2]]
|
||||
<strong>Output:</strong> "abc"
|
||||
<strong>Explaination: </strong>
|
||||
Swap s[0] and s[1], s = "bca"
|
||||
Swap s[1] and s[2], s = "bac"
|
||||
Swap s[0] and s[1], s = "abc"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10^5</code></li>
|
||||
<li><code>0 <= pairs.length <= 10^5</code></li>
|
||||
<li><code>0 <= pairs[i][0], pairs[i][1] < s.length</code></li>
|
||||
<li><code>s</code> only contains lower case English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>You are given two strings <code>s1</code> and <code>s2</code> of equal length consisting of letters <code>"x"</code> and <code>"y"</code> <strong>only</strong>. Your task is to make these two strings equal to each other. You can swap any two characters that belong to <strong>different</strong> strings, which means: swap <code>s1[i]</code> and <code>s2[j]</code>.</p>
|
||||
|
||||
<p>Return the minimum number of swaps required to make <code>s1</code> and <code>s2</code> equal, or return <code>-1</code> if it is impossible to do so.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "xx", s2 = "yy"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Swap s1[0] and s2[1], s1 = "yx", s2 = "yx".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "xy", s2 = "yx"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Swap s1[0] and s2[0], s1 = "yy", s2 = "xx".
|
||||
Swap s1[0] and s2[1], s1 = "xy", s2 = "xy".
|
||||
Note that you cannot swap s1[0] and s1[1] to make s1 equal to "yx", cause we can only swap chars in different strings.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "xx", s2 = "xy"
|
||||
<strong>Output:</strong> -1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s1.length, s2.length <= 1000</code></li>
|
||||
<li><code>s1, s2</code> only contain <code>'x'</code> or <code>'y'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>Suppose you are given the following code:</p>
|
||||
|
||||
<pre>
|
||||
class FooBar {
|
||||
public void foo() {
|
||||
for (int i = 0; i < n; i++) {
|
||||
print("foo");
|
||||
}
|
||||
}
|
||||
|
||||
public void bar() {
|
||||
for (int i = 0; i < n; i++) {
|
||||
print("bar");
|
||||
}
|
||||
}
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>The same instance of <code>FooBar</code> will be passed to two different threads:</p>
|
||||
|
||||
<ul>
|
||||
<li>thread <code>A</code> will call <code>foo()</code>, while</li>
|
||||
<li>thread <code>B</code> will call <code>bar()</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Modify the given program to output <code>"foobar"</code> <code>n</code> times.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> "foobar"
|
||||
<strong>Explanation:</strong> There are two threads being fired asynchronously. One of them calls foo(), while the other calls bar().
|
||||
"foobar" is being output 1 time.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> "foobarfoobar"
|
||||
<strong>Explanation:</strong> "foobar" is being output 2 times.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>You have the four functions:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>printFizz</code> that prints the word <code>"Fizz"</code> to the console,</li>
|
||||
<li><code>printBuzz</code> that prints the word <code>"Buzz"</code> to the console,</li>
|
||||
<li><code>printFizzBuzz</code> that prints the word <code>"FizzBuzz"</code> to the console, and</li>
|
||||
<li><code>printNumber</code> that prints a given integer to the console.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given an instance of the class <code>FizzBuzz</code> that has four functions: <code>fizz</code>, <code>buzz</code>, <code>fizzbuzz</code> and <code>number</code>. The same instance of <code>FizzBuzz</code> will be passed to four different threads:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Thread A:</strong> calls <code>fizz()</code> that should output the word <code>"Fizz"</code>.</li>
|
||||
<li><strong>Thread B:</strong> calls <code>buzz()</code> that should output the word <code>"Buzz"</code>.</li>
|
||||
<li><strong>Thread C:</strong> calls <code>fizzbuzz()</code> that should output the word <code>"FizzBuzz"</code>.</li>
|
||||
<li><strong>Thread D:</strong> calls <code>number()</code> that should only output the integers.</li>
|
||||
</ul>
|
||||
|
||||
<p>Modify the given class to output the series <code>[1, 2, "Fizz", 4, "Buzz", ...]</code> where the <code>i<sup>th</sup></code> token (<strong>1-indexed</strong>) of the series is:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>"FizzBuzz"</code> if <code>i</code> is divisible by <code>3</code> and <code>5</code>,</li>
|
||||
<li><code>"Fizz"</code> if <code>i</code> is divisible by <code>3</code> and not <code>5</code>,</li>
|
||||
<li><code>"Buzz"</code> if <code>i</code> is divisible by <code>5</code> and not <code>3</code>, or</li>
|
||||
<li><code>i</code> if <code>i</code> is not divisible by <code>3</code> or <code>5</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Implement the <code>FizzBuzz</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>FizzBuzz(int n)</code> Initializes the object with the number <code>n</code> that represents the length of the sequence that should be printed.</li>
|
||||
<li><code>void fizz(printFizz)</code> Calls <code>printFizz</code> to output <code>"Fizz"</code>.</li>
|
||||
<li><code>void buzz(printBuzz)</code> Calls <code>printBuzz</code> to output <code>"Buzz"</code>.</li>
|
||||
<li><code>void fizzbuzz(printFizzBuzz)</code> Calls <code>printFizzBuzz</code> to output <code>"FizzBuzz"</code>.</li>
|
||||
<li><code>void number(printNumber)</code> Calls <code>printnumber</code> to output the numbers.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 15
|
||||
<strong>Output:</strong> [1,2,"fizz",4,"buzz","fizz",7,8,"fizz","buzz",11,"fizz",13,14,"fizzbuzz"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> [1,2,"fizz",4,"buzz"]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given a binary string <code>s</code>, return <em>the number of substrings with all characters</em> <code>1</code><em>'s</em>. Since the answer may be too large, return it modulo <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "0110111"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> There are 9 substring in total with only 1's characters.
|
||||
"1" -> 5 times.
|
||||
"11" -> 3 times.
|
||||
"111" -> 1 time.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "101"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Substring "1" is shown 2 times in s.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "111111"
|
||||
<strong>Output:</strong> 21
|
||||
<strong>Explanation:</strong> Each substring contains only 1's characters.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given the <code>root</code> of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.</p>
|
||||
|
||||
<p>As a reminder, a <em>binary search tree</em> is a tree that satisfies these constraints:</p>
|
||||
|
||||
<ul>
|
||||
<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
|
||||
<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
|
||||
<li>Both the left and right subtrees must also be binary search trees.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/05/02/tree.png" style="width: 400px; height: 273px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
|
||||
<strong>Output:</strong> [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [0,null,1]
|
||||
<strong>Output:</strong> [1,null,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 100</code></li>
|
||||
<li>All the values in the tree are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Note:</strong> This question is the same as 538: <a href="https://leetcode.com/problems/convert-bst-to-greater-tree/" target="_blank">https://leetcode.com/problems/convert-bst-to-greater-tree/</a></p>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>There are <code>n</code> <strong>piles</strong> of coins on a table. Each pile consists of a <strong>positive number</strong> of coins of assorted denominations.</p>
|
||||
|
||||
<p>In one move, you can choose any coin on <strong>top</strong> of any pile, remove it, and add it to your wallet.</p>
|
||||
|
||||
<p>Given a list <code>piles</code>, where <code>piles[i]</code> is a list of integers denoting the composition of the <code>i<sup>th</sup></code> pile from <strong>top to bottom</strong>, and a positive integer <code>k</code>, return <em>the <strong>maximum total value</strong> of coins you can have in your wallet if you choose <strong>exactly</strong></em> <code>k</code> <em>coins optimally</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/11/09/e1.png" style="width: 600px; height: 243px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> piles = [[1,100,3],[7,8,9]], k = 2
|
||||
<strong>Output:</strong> 101
|
||||
<strong>Explanation:</strong>
|
||||
The above diagram shows the different ways we can choose k coins.
|
||||
The maximum total we can obtain is 101.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> piles = [[100],[100],[100],[100],[100],[100],[1,1,1,1,1,1,700]], k = 7
|
||||
<strong>Output:</strong> 706
|
||||
<strong>Explanation:
|
||||
</strong>The maximum total can be obtained if we choose all coins from the last pile.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == piles.length</code></li>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>1 <= piles[i][j] <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= sum(piles[i].length) <= 2000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given the <code>head</code> of a linked list, we repeatedly delete consecutive sequences of nodes that sum to <code>0</code> until there are no such sequences.</p>
|
||||
|
||||
|
||||
|
||||
<p>After doing so, return the head of the final linked list. You may return any such answer.</p>
|
||||
|
||||
|
||||
<p> </p>
|
||||
<p>(Note that in the examples below, all sequences are serializations of <code>ListNode</code> objects.)</p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,-3,3,1]
|
||||
<strong>Output:</strong> [3,1]
|
||||
<strong>Note:</strong> The answer [1,2,1] would also be accepted.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,-3,4]
|
||||
<strong>Output:</strong> [1,2,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,-3,-2]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>You have <code>n</code> boxes labeled from <code>0</code> to <code>n - 1</code>. You are given four arrays: <code>status</code>, <code>candies</code>, <code>keys</code>, and <code>containedBoxes</code> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>status[i]</code> is <code>1</code> if the <code>i<sup>th</sup></code> box is open and <code>0</code> if the <code>i<sup>th</sup></code> box is closed,</li>
|
||||
<li><code>candies[i]</code> is the number of candies in the <code>i<sup>th</sup></code> box,</li>
|
||||
<li><code>keys[i]</code> is a list of the labels of the boxes you can open after opening the <code>i<sup>th</sup></code> box.</li>
|
||||
<li><code>containedBoxes[i]</code> is a list of the boxes you found inside the <code>i<sup>th</sup></code> box.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given an integer array <code>initialBoxes</code> that contains the labels of the boxes you initially have. You can take all the candies in <strong>any open box</strong> and you can use the keys in it to open new boxes and you also can use the boxes you find in it.</p>
|
||||
|
||||
<p>Return <em>the maximum number of candies you can get following the rules above</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> You will be initially given box 0. You will find 7 candies in it and boxes 1 and 2.
|
||||
Box 1 is closed and you do not have a key for it so you will open box 2. You will find 4 candies and a key to box 1 in box 2.
|
||||
In box 1, you will find 5 candies and box 3 but you will not find a key to box 3 so box 3 will remain closed.
|
||||
Total number of candies collected = 7 + 4 + 5 = 16 candy.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> You have initially box 0. Opening it you can find boxes 1,2,3,4 and 5 and their keys.
|
||||
The total number of candies will be 6.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == status.length == candies.length == keys.length == containedBoxes.length</code></li>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>status[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li><code>1 <= candies[i] <= 1000</code></li>
|
||||
<li><code>0 <= keys[i].length <= n</code></li>
|
||||
<li><code>0 <= keys[i][j] < n</code></li>
|
||||
<li>All values of <code>keys[i]</code> are <strong>unique</strong>.</li>
|
||||
<li><code>0 <= containedBoxes[i].length <= n</code></li>
|
||||
<li><code>0 <= containedBoxes[i][j] < n</code></li>
|
||||
<li>All values of <code>containedBoxes[i]</code> are unique.</li>
|
||||
<li>Each box is contained in one box at most.</li>
|
||||
<li><code>0 <= initialBoxes.length <= n</code></li>
|
||||
<li><code>0 <= initialBoxes[i] < n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given two integer arrays <code>arr1</code> and <code>arr2</code>, return the minimum number of operations (possibly zero) needed to make <code>arr1</code> strictly increasing.</p>
|
||||
|
||||
|
||||
|
||||
<p>In one operation, you can choose two indices <code>0 <= i < arr1.length</code> and <code>0 <= j < arr2.length</code> and do the assignment <code>arr1[i] = arr2[j]</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p>If there is no way to make <code>arr1</code> strictly increasing, return <code>-1</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
|
||||
|
||||
<strong>Output:</strong> 1
|
||||
|
||||
<strong>Explanation:</strong> Replace <code>5</code> with <code>2</code>, then <code>arr1 = [1, 2, 3, 6, 7]</code>.
|
||||
|
||||
</pre>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> arr1 = [1,5,3,6,7], arr2 = [4,3,1]
|
||||
|
||||
<strong>Output:</strong> 2
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given an array of integers <code>nums</code> and an integer <code>threshold</code>, we will choose a positive integer <code>divisor</code>, divide all the array by it, and sum the division's result. Find the <strong>smallest</strong> <code>divisor</code> such that the result mentioned above is less than or equal to <code>threshold</code>.</p>
|
||||
|
||||
<p>Each result of the division is rounded to the nearest integer greater than or equal to that element. (For example: <code>7/3 = 3</code> and <code>10/2 = 5</code>).</p>
|
||||
|
||||
<p>The test cases are generated so that there will be an answer.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,5,9], threshold = 6
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> We can get a sum to 17 (1+2+5+9) if the divisor is 1.
|
||||
If the divisor is 4 we can get a sum of 7 (1+1+2+3) and if the divisor is 5 the sum will be 5 (1+1+1+2).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [44,22,33,11,1], threshold = 5
|
||||
<strong>Output:</strong> 44
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>nums.length <= threshold <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>Given an <code>m x n</code> grid. Each cell of the grid has a sign pointing to the next cell you should visit if you are currently in this cell. The sign of <code>grid[i][j]</code> can be:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>1</code> which means go to the cell to the right. (i.e go from <code>grid[i][j]</code> to <code>grid[i][j + 1]</code>)</li>
|
||||
<li><code>2</code> which means go to the cell to the left. (i.e go from <code>grid[i][j]</code> to <code>grid[i][j - 1]</code>)</li>
|
||||
<li><code>3</code> which means go to the lower cell. (i.e go from <code>grid[i][j]</code> to <code>grid[i + 1][j]</code>)</li>
|
||||
<li><code>4</code> which means go to the upper cell. (i.e go from <code>grid[i][j]</code> to <code>grid[i - 1][j]</code>)</li>
|
||||
</ul>
|
||||
|
||||
<p>Notice that there could be some signs on the cells of the grid that point outside the grid.</p>
|
||||
|
||||
<p>You will initially start at the upper left cell <code>(0, 0)</code>. A valid path in the grid is a path that starts from the upper left cell <code>(0, 0)</code> and ends at the bottom-right cell <code>(m - 1, n - 1)</code> following the signs on the grid. The valid path does not have to be the shortest.</p>
|
||||
|
||||
<p>You can modify the sign on a cell with <code>cost = 1</code>. You can modify the sign on a cell <strong>one time only</strong>.</p>
|
||||
|
||||
<p>Return <em>the minimum cost to make the grid have at least one valid path</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/13/grid1.png" style="width: 400px; height: 390px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> You will start at point (0, 0).
|
||||
The path to (3, 3) is as follows. (0, 0) --> (0, 1) --> (0, 2) --> (0, 3) change the arrow to down with cost = 1 --> (1, 3) --> (1, 2) --> (1, 1) --> (1, 0) change the arrow to down with cost = 1 --> (2, 0) --> (2, 1) --> (2, 2) --> (2, 3) change the arrow to down with cost = 1 --> (3, 3)
|
||||
The total cost = 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/13/grid2.png" style="width: 350px; height: 341px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,1,3],[3,2,2],[1,1,4]]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> You can follow the path from (0, 0) to (2, 2).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/13/grid3.png" style="width: 200px; height: 192px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2],[4,3]]
|
||||
<strong>Output:</strong> 1
|
||||
</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>1 <= grid[i][j] <= 4</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>Given an array of strings <code>names</code> of size <code>n</code>. You will create <code>n</code> folders in your file system <strong>such that</strong>, at the <code>i<sup>th</sup></code> minute, you will create a folder with the name <code>names[i]</code>.</p>
|
||||
|
||||
<p>Since two files <strong>cannot</strong> have the same name, if you enter a folder name that was previously used, the system will have a suffix addition to its name in the form of <code>(k)</code>, where, <code>k</code> is the <strong>smallest positive integer</strong> such that the obtained name remains unique.</p>
|
||||
|
||||
<p>Return <em>an array of strings of length </em><code>n</code> where <code>ans[i]</code> is the actual name the system will assign to the <code>i<sup>th</sup></code> folder when you create it.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> names = ["pes","fifa","gta","pes(2019)"]
|
||||
<strong>Output:</strong> ["pes","fifa","gta","pes(2019)"]
|
||||
<strong>Explanation:</strong> Let's see how the file system creates folder names:
|
||||
"pes" --> not assigned before, remains "pes"
|
||||
"fifa" --> not assigned before, remains "fifa"
|
||||
"gta" --> not assigned before, remains "gta"
|
||||
"pes(2019)" --> not assigned before, remains "pes(2019)"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> names = ["gta","gta(1)","gta","avalon"]
|
||||
<strong>Output:</strong> ["gta","gta(1)","gta(2)","avalon"]
|
||||
<strong>Explanation:</strong> Let's see how the file system creates folder names:
|
||||
"gta" --> not assigned before, remains "gta"
|
||||
"gta(1)" --> not assigned before, remains "gta(1)"
|
||||
"gta" --> the name is reserved, system adds (k), since "gta(1)" is also reserved, systems put k = 2. it becomes "gta(2)"
|
||||
"avalon" --> not assigned before, remains "avalon"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> names = ["onepiece","onepiece(1)","onepiece(2)","onepiece(3)","onepiece"]
|
||||
<strong>Output:</strong> ["onepiece","onepiece(1)","onepiece(2)","onepiece(3)","onepiece(4)"]
|
||||
<strong>Explanation:</strong> When the last folder is created, the smallest positive valid k is 4, and it becomes "onepiece(4)".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= names.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= names[i].length <= 20</code></li>
|
||||
<li><code>names[i]</code> consists of lowercase English letters, digits, and/or round brackets.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>A chef has collected data on the <code>satisfaction</code> level of his <code>n</code> dishes. Chef can cook any dish in 1 unit of time.</p>
|
||||
|
||||
<p><strong>Like-time coefficient</strong> of a dish is defined as the time taken to cook that dish including previous dishes multiplied by its satisfaction level i.e. <code>time[i] * satisfaction[i]</code>.</p>
|
||||
|
||||
<p>Return <em>the maximum sum of <strong>like-time coefficient</strong> that the chef can obtain after dishes preparation</em>.</p>
|
||||
|
||||
<p>Dishes can be prepared in <strong>any </strong>order and the chef can discard some dishes to get this maximum value.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> satisfaction = [-1,-8,0,5,-9]
|
||||
<strong>Output:</strong> 14
|
||||
<strong>Explanation:</strong> After Removing the second and last dish, the maximum total <strong>like-time coefficient</strong> will be equal to (-1*1 + 0*2 + 5*3 = 14).
|
||||
Each dish is prepared in one unit of time.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> satisfaction = [4,3,2]
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation:</strong> Dishes can be prepared in any order, (2*1 + 3*2 + 4*3 = 20)
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> satisfaction = [-1,-4,-5]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> People do not like the dishes. No dish is prepared.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == satisfaction.length</code></li>
|
||||
<li><code>1 <= n <= 500</code></li>
|
||||
<li><code>-1000 <= satisfaction[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You have a pointer at index <code>0</code> in an array of size <code>arrLen</code>. At each step, you can move 1 position to the left, 1 position to the right in the array, or stay in the same place (The pointer should not be placed outside the array at any time).</p>
|
||||
|
||||
<p>Given two integers <code>steps</code> and <code>arrLen</code>, return the number of ways such that your pointer still at index <code>0</code> after <strong>exactly</strong> <code>steps</code> steps. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> steps = 3, arrLen = 2
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation: </strong>There are 4 differents ways to stay at index 0 after 3 steps.
|
||||
Right, Left, Stay
|
||||
Stay, Right, Left
|
||||
Right, Stay, Left
|
||||
Stay, Stay, Stay
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> steps = 2, arrLen = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There are 2 differents ways to stay at index 0 after 2 steps
|
||||
Right, Left
|
||||
Stay, Stay
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> steps = 4, arrLen = 2
|
||||
<strong>Output:</strong> 8
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= steps <= 500</code></li>
|
||||
<li><code>1 <= arrLen <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given a <code>matrix</code> and a <code>target</code>, return the number of non-empty submatrices that sum to <font face="monospace">target</font>.</p>
|
||||
|
||||
<p>A submatrix <code>x1, y1, x2, y2</code> is the set of all cells <code>matrix[x][y]</code> with <code>x1 <= x <= x2</code> and <code>y1 <= y <= y2</code>.</p>
|
||||
|
||||
<p>Two submatrices <code>(x1, y1, x2, y2)</code> and <code>(x1', y1', x2', y2')</code> are different if they have some coordinate that is different: for example, if <code>x1 != x1'</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/02/mate1.jpg" style="width: 242px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The four 1x1 submatrices that only contain 0.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> matrix = [[1,-1],[-1,1]], target = 0
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> matrix = [[904]], target = 0
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= matrix.length <= 100</code></li>
|
||||
<li><code>1 <= matrix[0].length <= 100</code></li>
|
||||
<li><code>-1000 <= matrix[i] <= 1000</code></li>
|
||||
<li><code>-10^8 <= target <= 10^8</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Given a <code>m x n</code> matrix <code>mat</code> and an integer <code>threshold</code>, return <em>the maximum side-length of a square with a sum less than or equal to </em><code>threshold</code><em> or return </em><code>0</code><em> if there is no such square</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/05/e1.png" style="width: 335px; height: 186px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The maximum side length of square with sum less than 4 is 2 as shown.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1
|
||||
<strong>Output:</strong> 0
|
||||
</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 <= 300</code></li>
|
||||
<li><code>0 <= mat[i][j] <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= threshold <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>A bus has <code>n</code> stops numbered from <code>0</code> to <code>n - 1</code> that form a circle. We know the distance between all pairs of neighboring stops where <code>distance[i]</code> is the distance between the stops number <code>i</code> and <code>(i + 1) % n</code>.</p>
|
||||
|
||||
|
||||
|
||||
<p>The bus goes along both directions i.e. clockwise and counterclockwise.</p>
|
||||
|
||||
|
||||
|
||||
<p>Return the shortest distance between the given <code>start</code> and <code>destination</code> stops.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/09/03/untitled-diagram-1.jpg" style="width: 388px; height: 240px;" /></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> distance = [1,2,3,4], start = 0, destination = 1
|
||||
|
||||
<strong>Output:</strong> 1
|
||||
|
||||
<strong>Explanation:</strong> Distance between 0 and 1 is 1 or 9, minimum is 1.</pre>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/09/03/untitled-diagram-1-1.jpg" style="width: 388px; height: 240px;" /></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> distance = [1,2,3,4], start = 0, destination = 2
|
||||
|
||||
<strong>Output:</strong> 3
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given a string <code>s</code> containing lowercase letters and an integer <code>k</code>. You need to :</p>
|
||||
|
||||
<ul>
|
||||
<li>First, change some characters of <code>s</code> to other lowercase English letters.</li>
|
||||
<li>Then divide <code>s</code> into <code>k</code> non-empty disjoint substrings such that each substring is a palindrome.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the minimal number of characters that you need to change to divide the string</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abc", k = 2
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> You can split the string into "ab" and "c", and change 1 character in "ab" to make it palindrome.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aabbc", k = 3
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> You can split the string into "aa", "bb" and "c", all of them are palindrome.</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "leetcode", k = 8
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= s.length <= 100</code>.</li>
|
||||
<li><code>s</code> only contains lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>Given a string <code>s</code> of zeros and ones, <em>return the maximum score after splitting the string into two <strong>non-empty</strong> substrings</em> (i.e. <strong>left</strong> substring and <strong>right</strong> substring).</p>
|
||||
|
||||
<p>The score after splitting a string is the number of <strong>zeros</strong> in the <strong>left</strong> substring plus the number of <strong>ones</strong> in the <strong>right</strong> substring.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "011101"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
All possible ways of splitting s into two non-empty substrings are:
|
||||
left = "0" and right = "11101", score = 1 + 4 = 5
|
||||
left = "01" and right = "1101", score = 1 + 3 = 4
|
||||
left = "011" and right = "101", score = 1 + 2 = 3
|
||||
left = "0111" and right = "01", score = 1 + 1 = 2
|
||||
left = "01110" and right = "1", score = 2 + 1 = 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "00111"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> When left = "00" and right = "111", we get the maximum score = 2 + 3 = 5
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "1111"
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= s.length <= 500</code></li>
|
||||
<li>The string <code>s</code> consists of characters <code>'0'</code> and <code>'1'</code> only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p><strong>Balanced</strong> strings are those that have an equal quantity of <code>'L'</code> and <code>'R'</code> characters.</p>
|
||||
|
||||
<p>Given a <strong>balanced</strong> string <code>s</code>, split it in the maximum amount of balanced strings.</p>
|
||||
|
||||
<p>Return <em>the maximum amount of split <strong>balanced</strong> strings</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "RLRRLLRLRL"
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> s can be split into "RL", "RRLL", "RL", "RL", each substring contains same number of 'L' and 'R'.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "RLLLLRRRLR"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> s can be split into "RL", "LLLRRR", "LR", each substring contains same number of 'L' and 'R'.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "LLLLRRRR"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> s can be split into "LLLLRRRR".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s[i]</code> is either <code>'L'</code> or <code>'R'</code>.</li>
|
||||
<li><code>s</code> is a <strong>balanced</strong> string.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>We distribute some number of <code>candies</code>, to a row of <strong><code>n = num_people</code></strong> people in the following way:</p>
|
||||
|
||||
<p>We then give 1 candy to the first person, 2 candies to the second person, and so on until we give <code>n</code> candies to the last person.</p>
|
||||
|
||||
<p>Then, we go back to the start of the row, giving <code>n + 1</code> candies to the first person, <code>n + 2</code> candies to the second person, and so on until we give <code>2 * n</code> candies to the last person.</p>
|
||||
|
||||
<p>This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies. The last person will receive all of our remaining candies (not necessarily one more than the previous gift).</p>
|
||||
|
||||
<p>Return an array (of length <code>num_people</code> and sum <code>candies</code>) that represents the final distribution of candies.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> candies = 7, num_people = 4
|
||||
<strong>Output:</strong> [1,2,3,1]
|
||||
<strong>Explanation:</strong>
|
||||
On the first turn, ans[0] += 1, and the array is [1,0,0,0].
|
||||
On the second turn, ans[1] += 2, and the array is [1,2,0,0].
|
||||
On the third turn, ans[2] += 3, and the array is [1,2,3,0].
|
||||
On the fourth turn, ans[3] += 1 (because there is only one candy left), and the final array is [1,2,3,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> candies = 10, num_people = 3
|
||||
<strong>Output:</strong> [5,2,3]
|
||||
<strong>Explanation: </strong>
|
||||
On the first turn, ans[0] += 1, and the array is [1,0,0].
|
||||
On the second turn, ans[1] += 2, and the array is [1,2,0].
|
||||
On the third turn, ans[2] += 3, and the array is [1,2,3].
|
||||
On the fourth turn, ans[0] += 4, and the final array is [5,2,3].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>1 <= candies <= 10^9</li>
|
||||
<li>1 <= num_people <= 1000</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Given the <code>root</code> of a binary tree, split the binary tree into two subtrees by removing one edge such that the product of the sums of the subtrees is maximized.</p>
|
||||
|
||||
<p>Return <em>the maximum product of the sums of the two subtrees</em>. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that you need to maximize the answer before taking the mod and not after taking it.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/21/sample_1_1699.png" style="width: 500px; height: 167px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,4,5,6]
|
||||
<strong>Output:</strong> 110
|
||||
<strong>Explanation:</strong> Remove the red edge and get 2 binary trees with sum 11 and 10. Their product is 110 (11*10)
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/21/sample_2_1699.png" style="width: 500px; height: 211px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3,4,null,null,5,6]
|
||||
<strong>Output:</strong> 90
|
||||
<strong>Explanation:</strong> Remove the red edge and get 2 binary trees with sum 15 and 6.Their product is 90 (15*6)
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[2, 5 * 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an integer array <code>arr</code>, partition the array into (contiguous) subarrays of length <strong>at most</strong> <code>k</code>. After partitioning, each subarray has their values changed to become the maximum value of that subarray.</p>
|
||||
|
||||
<p>Return <em>the largest sum of the given array after partitioning. Test cases are generated so that the answer fits in a <strong>32-bit</strong> integer.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,15,7,9,2,5,10], k = 3
|
||||
<strong>Output:</strong> 84
|
||||
<strong>Explanation:</strong> arr becomes [15,15,15,9,10,10,10]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,4,1,5,7,3,6,1,9,9,3], k = 4
|
||||
<strong>Output:</strong> 83
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1], k = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 500</code></li>
|
||||
<li><code>0 <= arr[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= arr.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a rectangular cake of size <code>h x w</code> and two arrays of integers <code>horizontalCuts</code> and <code>verticalCuts</code> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>horizontalCuts[i]</code> is the distance from the top of the rectangular cake to the <code>i<sup>th</sup></code> horizontal cut and similarly, and</li>
|
||||
<li><code>verticalCuts[j]</code> is the distance from the left of the rectangular cake to the <code>j<sup>th</sup></code> vertical cut.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays</em> <code>horizontalCuts</code> <em>and</em> <code>verticalCuts</code>. Since the answer can be a large number, return this <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/05/14/leetcode_max_area_2.png" style="width: 225px; height: 240px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green piece of cake has the maximum area.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/05/14/leetcode_max_area_3.png" style="width: 225px; height: 240px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green and yellow pieces of cake have the maximum area.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]
|
||||
<strong>Output:</strong> 9
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= h, w <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= horizontalCuts.length <= min(h - 1, 10<sup>5</sup>)</code></li>
|
||||
<li><code>1 <= verticalCuts.length <= min(w - 1, 10<sup>5</sup>)</code></li>
|
||||
<li><code>1 <= horizontalCuts[i] < h</code></li>
|
||||
<li><code>1 <= verticalCuts[i] < w</code></li>
|
||||
<li>All the elements in <code>horizontalCuts</code> are distinct.</li>
|
||||
<li>All the elements in <code>verticalCuts</code> are distinct.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>Given a rectangular pizza represented as a <code>rows x cols</code> matrix containing the following characters: <code>'A'</code> (an apple) and <code>'.'</code> (empty cell) and given the integer <code>k</code>. You have to cut the pizza into <code>k</code> pieces using <code>k-1</code> cuts. </p>
|
||||
|
||||
|
||||
|
||||
<p>For each cut you choose the direction: vertical or horizontal, then you choose a cut position at the cell boundary and cut the pizza into two pieces. If you cut the pizza vertically, give the left part of the pizza to a person. If you cut the pizza horizontally, give the upper part of the pizza to a person. Give the last piece of pizza to the last person.</p>
|
||||
|
||||
|
||||
|
||||
<p><em>Return the number of ways of cutting the pizza such that each piece contains <strong>at least</strong> one apple. </em>Since the answer can be a huge number, return this modulo 10^9 + 7.</p>
|
||||
|
||||
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/04/23/ways_to_cut_apple_1.png" style="width: 500px; height: 378px;" /></strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> pizza = ["A..","AAA","..."], k = 3
|
||||
|
||||
<strong>Output:</strong> 3
|
||||
|
||||
<strong>Explanation:</strong> The figure above shows the three ways to cut the pizza. Note that pieces must contain at least one apple.
|
||||
|
||||
</pre>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> pizza = ["A..","AA.","..."], k = 3
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given an array of integers <code>nums</code> and a positive integer <code>k</code>, check whether it is possible to divide this array into sets of <code>k</code> consecutive numbers.</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if it is possible</em>.<strong> </strong>Otherwise, return <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,3,4,4,5,6], k = 4
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Array can be divided into [1,2,3,4] and [3,4,5,6].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Array can be divided into [1,2,3] , [2,3,4] , [3,4,5] and [9,10,11].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4], k = 3
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> Each array should be divided in subarrays of size 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Note:</strong> This question is the same as 846: <a href="https://leetcode.com/problems/hand-of-straights/" target="_blank">https://leetcode.com/problems/hand-of-straights/</a>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given a binary array <code>nums</code>, you should delete one element from it.</p>
|
||||
|
||||
<p>Return <em>the size of the longest non-empty subarray containing only </em><code>1</code><em>'s in the resulting array</em>. Return <code>0</code> if there is no such subarray.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,0,1]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1,1,1,0,1,1,0,1]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> You must delete one element.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Given the <code>root</code> of a binary tree, each node in the tree has a distinct value.</p>
|
||||
|
||||
<p>After deleting all nodes with a value in <code>to_delete</code>, we are left with a forest (a disjoint union of trees).</p>
|
||||
|
||||
<p>Return the roots of the trees in the remaining forest. You may return the result in any order.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/07/01/screen-shot-2019-07-01-at-53836-pm.png" style="width: 237px; height: 150px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,4,5,6,7], to_delete = [3,5]
|
||||
<strong>Output:</strong> [[1,2,null,4],[6],[7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,4,null,3], to_delete = [3]
|
||||
<strong>Output:</strong> [[1,2,4]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the given tree is at most <code>1000</code>.</li>
|
||||
<li>Each node has a distinct value between <code>1</code> and <code>1000</code>.</li>
|
||||
<li><code>to_delete.length <= 1000</code></li>
|
||||
<li><code>to_delete</code> contains distinct values between <code>1</code> and <code>1000</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an array of integers, return the maximum sum for a <strong>non-empty</strong> subarray (contiguous elements) with at most one element deletion. In other words, you want to choose a subarray and optionally delete one element from it so that there is still at least one element left and the sum of the remaining elements is maximum possible.</p>
|
||||
|
||||
<p>Note that the subarray needs to be <strong>non-empty</strong> after deleting one element.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,-2,0,3]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation: </strong>Because we can choose [1, -2, 0, 3] and drop -2, thus the subarray [1, 0, 3] becomes the maximum value.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,-2,-2,3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation: </strong>We just choose [3] and it's the maximum sum.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [-1,-1,-1,-1]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> The final subarray needs to be non-empty. You can't choose [-1] and delete -1 from it, then get an empty subarray to make the sum equals to 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You are given a string <code>s</code> consisting <strong>only</strong> of letters <code>'a'</code> and <code>'b'</code>. In a single step you can remove one <strong>palindromic subsequence</strong> from <code>s</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of steps to make the given string empty</em>.</p>
|
||||
|
||||
<p>A string is a <strong>subsequence</strong> of a given string if it is generated by deleting some characters of a given string without changing its order. Note that a subsequence does <strong>not</strong> necessarily need to be contiguous.</p>
|
||||
|
||||
<p>A string is called <strong>palindrome</strong> if is one that reads the same backward as well as forward.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ababa"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> s is already a palindrome, so its entirety can be removed in a single step.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abb"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> "<u>a</u>bb" -> "<u>bb</u>" -> "".
|
||||
Remove palindromic subsequence "a" then "bb".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "baabb"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> "<u>baa</u>b<u>b</u>" -> "<u>b</u>" -> "".
|
||||
Remove palindromic subsequence "baab" then "b".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s[i]</code> is either <code>'a'</code> or <code>'b'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>Given a list of folders <code>folder</code>, return <em>the folders after removing all <strong>sub-folders</strong> in those folders</em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p>If a <code>folder[i]</code> is located within another <code>folder[j]</code>, it is called a <strong>sub-folder</strong> of it.</p>
|
||||
|
||||
<p>The format of a path is one or more concatenated strings of the form: <code>'/'</code> followed by one or more lowercase English letters.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"/leetcode"</code> and <code>"/leetcode/problems"</code> are valid paths while an empty string and <code>"/"</code> are not.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
|
||||
<strong>Output:</strong> ["/a","/c/d","/c/f"]
|
||||
<strong>Explanation:</strong> Folders "/a/b" is a subfolder of "/a" and "/c/d/e" is inside of folder "/c/d" in our filesystem.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> folder = ["/a","/a/b/c","/a/b/d"]
|
||||
<strong>Output:</strong> ["/a"]
|
||||
<strong>Explanation:</strong> Folders "/a/b/c" and "/a/b/d" will be removed because they are subfolders of "/a".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> folder = ["/a/b/c","/a/b/ca","/a/b/d"]
|
||||
<strong>Output:</strong> ["/a/b/c","/a/b/ca","/a/b/d"]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= folder.length <= 4 * 10<sup>4</sup></code></li>
|
||||
<li><code>2 <= folder[i].length <= 100</code></li>
|
||||
<li><code>folder[i]</code> contains only lowercase letters and <code>'/'</code>.</li>
|
||||
<li><code>folder[i]</code> always starts with the character <code>'/'</code>.</li>
|
||||
<li>Each folder name is <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given a string <code>s</code> and an integer <code>k</code>, a <code>k</code> <strong>duplicate removal</strong> consists of choosing <code>k</code> adjacent and equal letters from <code>s</code> and removing them, causing the left and the right side of the deleted substring to concatenate together.</p>
|
||||
|
||||
<p>We repeatedly make <code>k</code> <strong>duplicate removals</strong> on <code>s</code> until we no longer can.</p>
|
||||
|
||||
<p>Return the final string after all such duplicate removals have been made. It is guaranteed that the answer is unique.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcd", k = 2
|
||||
<strong>Output:</strong> "abcd"
|
||||
<strong>Explanation: </strong>There's nothing to delete.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "deeedbbcccbdaa", k = 3
|
||||
<strong>Output:</strong> "aa"
|
||||
<strong>Explanation:
|
||||
</strong>First delete "eee" and "ccc", get "ddbbbdaa"
|
||||
Then delete "bbb", get "dddaa"
|
||||
Finally delete "ddd", get "aa"</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "pbbcggttciiippooaais", k = 2
|
||||
<strong>Output:</strong> "ps"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>2 <= k <= 10<sup>4</sup></code></li>
|
||||
<li><code>s</code> only contains lower case English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>You are given a string <code>s</code> consisting of lowercase English letters. A <strong>duplicate removal</strong> consists of choosing two <strong>adjacent</strong> and <strong>equal</strong> letters and removing them.</p>
|
||||
|
||||
<p>We repeatedly make <strong>duplicate removals</strong> on <code>s</code> until we no longer can.</p>
|
||||
|
||||
<p>Return <em>the final string after all such duplicate removals have been made</em>. It can be proven that the answer is <strong>unique</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abbaca"
|
||||
<strong>Output:</strong> "ca"
|
||||
<strong>Explanation:</strong>
|
||||
For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move. The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "azxxzy"
|
||||
<strong>Output:</strong> "ay"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>A <strong>fancy string</strong> is a string where no <strong>three</strong> <strong>consecutive</strong> characters are equal.</p>
|
||||
|
||||
<p>Given a string <code>s</code>, delete the <strong>minimum</strong> possible number of characters from <code>s</code> to make it <strong>fancy</strong>.</p>
|
||||
|
||||
<p>Return <em>the final string after the deletion</em>. It can be shown that the answer will always be <strong>unique</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "le<u>e</u>etcode"
|
||||
<strong>Output:</strong> "leetcode"
|
||||
<strong>Explanation:</strong>
|
||||
Remove an 'e' from the first group of 'e's to create "leetcode".
|
||||
No three consecutive characters are equal, so return "leetcode".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "<u>a</u>aab<u>aa</u>aa"
|
||||
<strong>Output:</strong> "aabaa"
|
||||
<strong>Explanation:</strong>
|
||||
Remove an 'a' from the first group of 'a's to create "aabaaaa".
|
||||
Remove two 'a's from the second group of 'a's to create "aabaa".
|
||||
No three consecutive characters are equal, so return "aabaa".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aab"
|
||||
<strong>Output:</strong> "aab"
|
||||
<strong>Explanation:</strong> No three consecutive characters are equal, so return "aab".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an integer array <code>arr</code>, return <em>the mean of the remaining integers after removing the smallest <code>5%</code> and the largest <code>5%</code> of the elements.</em></p>
|
||||
|
||||
<p>Answers within <code>10<sup>-5</sup></code> of the <strong>actual answer</strong> will be considered accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]
|
||||
<strong>Output:</strong> 2.00000
|
||||
<strong>Explanation:</strong> After erasing the minimum and the maximum values of this array, all elements are equal to 2, so the mean is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]
|
||||
<strong>Output:</strong> 4.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4]
|
||||
<strong>Output:</strong> 4.77778
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>20 <= arr.length <= 1000</code></li>
|
||||
<li><code>arr.length</code><b> </b><strong>is a multiple</strong> of <code>20</code>.</li>
|
||||
<li><code><font face="monospace">0 <= arr[i] <= 10<sup>5</sup></font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>Given a binary tree <code>root</code> and an integer <code>target</code>, delete all the <strong>leaf nodes</strong> with value <code>target</code>.</p>
|
||||
|
||||
<p>Note that once you delete a leaf node with value <code>target</code><strong>, </strong>if its parent node becomes a leaf node and has the value <code>target</code>, it should also be deleted (you need to continue doing that until you cannot).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/09/sample_1_1684.png" style="width: 500px; height: 112px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,2,null,2,4], target = 2
|
||||
<strong>Output:</strong> [1,null,3,null,4]
|
||||
<strong>Explanation:</strong> Leaf nodes in green with value (target = 2) are removed (Picture in left).
|
||||
After removing, new nodes become leaf nodes with value (target = 2) (Picture in center).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/09/sample_2_1684.png" style="width: 400px; height: 154px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,3,3,3,2], target = 3
|
||||
<strong>Output:</strong> [1,3,null,null,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/15/sample_3_1684.png" style="width: 500px; height: 166px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,null,2,null,2], target = 2
|
||||
<strong>Output:</strong> [1]
|
||||
<strong>Explanation:</strong> Leaf nodes in green with value (target = 2) are removed at each step.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 3000]</code>.</li>
|
||||
<li><code>1 <= Node.val, target <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given an array <code>intervals</code> where <code>intervals[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> represent the interval <code>[l<sub>i</sub>, r<sub>i</sub>)</code>, remove all intervals that are covered by another interval in the list.</p>
|
||||
|
||||
<p>The interval <code>[a, b)</code> is covered by the interval <code>[c, d)</code> if and only if <code>c <= a</code> and <code>b <= d</code>.</p>
|
||||
|
||||
<p>Return <em>the number of remaining intervals</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> intervals = [[1,4],[3,6],[2,8]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Interval [3,6] is covered by [2,8], therefore it is removed.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> intervals = [[1,4],[2,3]]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= intervals.length <= 1000</code></li>
|
||||
<li><code>intervals[i].length == 2</code></li>
|
||||
<li><code>0 <= l<sub>i</sub> < r<sub>i</sub> <= 10<sup>5</sup></code></li>
|
||||
<li>All the given intervals are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>A sequence of numbers is called an <strong>arithmetic progression</strong> if the difference between any two consecutive elements is the same.</p>
|
||||
|
||||
<p>Given an array of numbers <code>arr</code>, return <code>true</code> <em>if the array can be rearranged to form an <strong>arithmetic progression</strong>. Otherwise, return</em> <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [3,5,1]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>We can reorder the elements as [1,3,5] or [5,3,1] with differences 2 and -2 respectively, between each consecutive elements.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,2,4]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation: </strong>There is no way to reorder the elements to obtain an arithmetic progression.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= arr.length <= 1000</code></li>
|
||||
<li><code>-10<sup>6</sup> <= arr[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given a string <code>path</code>, where <code>path[i] = 'N'</code>, <code>'S'</code>, <code>'E'</code> or <code>'W'</code>, each representing moving one unit north, south, east, or west, respectively. You start at the origin <code>(0, 0)</code> on a 2D plane and walk on the path specified by <code>path</code>.</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if the path crosses itself at any point, that is, if at any time you are on a location you have previously visited</em>. Return <code>false</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/06/10/screen-shot-2020-06-10-at-123929-pm.png" style="width: 400px; height: 358px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> path = "NES"
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> Notice that the path doesn't cross any point more than once.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/06/10/screen-shot-2020-06-10-at-123843-pm.png" style="width: 400px; height: 339px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> path = "NESWW"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Notice that the path visits the origin twice.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= path.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>path[i]</code> is either <code>'N'</code>, <code>'S'</code>, <code>'E'</code>, or <code>'W'</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>You are given an integer array <code>bloomDay</code>, an integer <code>m</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>You want to make <code>m</code> bouquets. To make a bouquet, you need to use <code>k</code> <strong>adjacent flowers</strong> from the garden.</p>
|
||||
|
||||
<p>The garden consists of <code>n</code> flowers, the <code>i<sup>th</sup></code> flower will bloom in the <code>bloomDay[i]</code> and then can be used in <strong>exactly one</strong> bouquet.</p>
|
||||
|
||||
<p>Return <em>the minimum number of days you need to wait to be able to make </em><code>m</code><em> bouquets from the garden</em>. If it is impossible to make m bouquets return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bloomDay = [1,10,3,10,2], m = 3, k = 1
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Let us see what happened in the first three days. x means flower bloomed and _ means flower did not bloom in the garden.
|
||||
We need 3 bouquets each should contain 1 flower.
|
||||
After day 1: [x, _, _, _, _] // we can only make one bouquet.
|
||||
After day 2: [x, _, _, _, x] // we can only make two bouquets.
|
||||
After day 3: [x, _, x, _, x] // we can make 3 bouquets. The answer is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bloomDay = [1,10,3,10,2], m = 3, k = 2
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> We need 3 bouquets each has 2 flowers, that means we need 6 flowers. We only have 5 flowers so it is impossible to get the needed bouquets and we return -1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> We need 2 bouquets each should have 3 flowers.
|
||||
Here is the garden after the 7 and 12 days:
|
||||
After day 7: [x, x, x, x, _, x, x]
|
||||
We can make one bouquet of the first three flowers that bloomed. We cannot make another bouquet from the last three flowers that bloomed because they are not adjacent.
|
||||
After day 12: [x, x, x, x, x, x, x]
|
||||
It is obvious that we can make two bouquets in different ways.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>bloomDay.length == n</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= bloomDay[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= m <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= k <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given two strings of the same length <code>s</code> and <code>t</code>. In one step you can choose <strong>any character</strong> of <code>t</code> and replace it with <strong>another character</strong>.</p>
|
||||
|
||||
<p>Return <em>the minimum number of steps</em> to make <code>t</code> an anagram of <code>s</code>.</p>
|
||||
|
||||
<p>An <strong>Anagram</strong> of a string is a string that contains the same characters with a different (or the same) ordering.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "bab", t = "aba"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Replace the first 'a' in t with b, t = "bba" which is anagram of s.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "leetcode", t = "practice"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> Replace 'p', 'r', 'a', 'i' and 'c' from t with proper characters to make t anagram of s.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "anagram", t = "mangaar"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> "anagram" and "mangaar" are anagrams.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>s.length == t.length</code></li>
|
||||
<li><code>s</code> and <code>t</code> consist of lowercase English letters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given a string <code>s</code> consisting only of characters <em>a</em>, <em>b</em> and <em>c</em>.</p>
|
||||
|
||||
<p>Return the number of substrings containing <b>at least</b> one occurrence of all these characters <em>a</em>, <em>b</em> and <em>c</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcabc"
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The substrings containing at least one occurrence of the characters <em>a</em>, <em>b</em> and <em>c are "</em>abc<em>", "</em>abca<em>", "</em>abcab<em>", "</em>abcabc<em>", "</em>bca<em>", "</em>bcab<em>", "</em>bcabc<em>", "</em>cab<em>", "</em>cabc<em>" </em>and<em> "</em>abc<em>" </em>(<strong>again</strong>)<em>. </em>
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aaacb"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The substrings containing at least one occurrence of the characters <em>a</em>, <em>b</em> and <em>c are "</em>aaacb<em>", "</em>aacb<em>" </em>and<em> "</em>acb<em>".</em><em> </em>
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abc"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= s.length <= 5 x 10^4</code></li>
|
||||
<li><code>s</code> only consists of <em>a</em>, <em>b</em> or <em>c </em>characters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Design a data structure to find the <strong>frequency</strong> of a given value in a given subarray.</p>
|
||||
|
||||
<p>The <strong>frequency</strong> of a value in a subarray is the number of occurrences of that value in the subarray.</p>
|
||||
|
||||
<p>Implement the <code>RangeFreqQuery</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RangeFreqQuery(int[] arr)</code> Constructs an instance of the class with the given <strong>0-indexed</strong> integer array <code>arr</code>.</li>
|
||||
<li><code>int query(int left, int right, int value)</code> Returns the <strong>frequency</strong> of <code>value</code> in the subarray <code>arr[left...right]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array. <code>arr[left...right]</code> denotes the subarray that contains the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> (<strong>inclusive</strong>).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RangeFreqQuery", "query", "query"]
|
||||
[[[12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]], [1, 2, 4], [0, 11, 33]]
|
||||
<strong>Output</strong>
|
||||
[null, 1, 2]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RangeFreqQuery rangeFreqQuery = new RangeFreqQuery([12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]);
|
||||
rangeFreqQuery.query(1, 2, 4); // return 1. The value 4 occurs 1 time in the subarray [33, 4]
|
||||
rangeFreqQuery.query(0, 11, 33); // return 2. The value 33 occurs 2 times in the whole array.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= arr[i], value <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= left <= right < arr.length</code></li>
|
||||
<li>At most <code>10<sup>5</sup></code> calls will be made to <code>query</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,23 @@
|
||||
<p>Given an integer <code>n</code>, add a dot (".") as the thousands separator and return it in string format.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 987
|
||||
<strong>Output:</strong> "987"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1234
|
||||
<strong>Output:</strong> "1.234"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a string <code>text</code>. You can swap two of the characters in the <code>text</code>.</p>
|
||||
|
||||
<p>Return <em>the length of the longest substring with repeated characters</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "ababa"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can swap the first 'b' with the last 'a', or the last 'b' with the first 'a'. Then, the longest repeated character substring is "aaa" with length 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "aaabaaa"
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Swap 'b' with the last 'a' (or the first 'a'), and we get longest repeated character substring "aaaaaa" with length 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "aaaaa"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> No need to swap, longest repeated character substring is "aaaaa" with length is 5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>text</code> consist of lowercase English characters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p><a href="http://en.wikipedia.org/wiki/Run-length_encoding">Run-length encoding</a> is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string <code>"aabccc"</code> we replace <font face="monospace"><code>"aa"</code></font> by <font face="monospace"><code>"a2"</code></font> and replace <font face="monospace"><code>"ccc"</code></font> by <font face="monospace"><code>"c3"</code></font>. Thus the compressed string becomes <font face="monospace"><code>"a2bc3"</code>.</font></p>
|
||||
|
||||
<p>Notice that in this problem, we are not adding <code>'1'</code> after single characters.</p>
|
||||
|
||||
<p>Given a string <code>s</code> and an integer <code>k</code>. You need to delete <strong>at most</strong> <code>k</code> characters from <code>s</code> such that the run-length encoded version of <code>s</code> has minimum length.</p>
|
||||
|
||||
<p>Find the <em>minimum length of the run-length encoded version of </em><code>s</code><em> after deleting at most </em><code>k</code><em> characters</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aaabcccd", k = 2
|
||||
<strong>Output:</strong> 4
|
||||
<b>Explanation: </b>Compressing s without deleting anything will give us "a3bc3d" of length 6. Deleting any of the characters 'a' or 'c' would at most decrease the length of the compressed string to 5, for instance delete 2 'a' then we will have s = "abcccd" which compressed is abc3d. Therefore, the optimal way is to delete 'b' and 'd', then the compressed version of s will be "a3c3" of length 4.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aabbaa", k = 2
|
||||
<strong>Output:</strong> 2
|
||||
<b>Explanation: </b>If we delete both 'b' characters, the resulting compressed string would be "a4" of length 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aaaaaaaaaaa", k = 0
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation: </strong>Since k is zero, we cannot delete anything. The compressed string is "a11" of length 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>0 <= k <= s.length</code></li>
|
||||
<li><code>s</code> contains only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>You are given an array of <strong>unique</strong> integers <code>salary</code> where <code>salary[i]</code> is the salary of the <code>i<sup>th</sup></code> employee.</p>
|
||||
|
||||
<p>Return <em>the average salary of employees excluding the minimum and maximum salary</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> salary = [4000,3000,1000,2000]
|
||||
<strong>Output:</strong> 2500.00000
|
||||
<strong>Explanation:</strong> Minimum salary and maximum salary are 1000 and 4000 respectively.
|
||||
Average salary excluding minimum and maximum salary is (2000+3000) / 2 = 2500
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> salary = [1000,2000,3000]
|
||||
<strong>Output:</strong> 2000.00000
|
||||
<strong>Explanation:</strong> Minimum salary and maximum salary are 1000 and 3000 respectively.
|
||||
Average salary excluding minimum and maximum salary is (2000) / 1 = 2000
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= salary.length <= 100</code></li>
|
||||
<li><code>1000 <= salary[i] <= 10<sup>6</sup></code></li>
|
||||
<li>All the integers of <code>salary</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>Given a <code>m * n</code> matrix <code>seats</code> that represent seats distributions in a classroom. If a seat is broken, it is denoted by <code>'#'</code> character otherwise it is denoted by a <code>'.'</code> character.</p>
|
||||
|
||||
<p>Students can see the answers of those sitting next to the left, right, upper left and upper right, but he cannot see the answers of the student sitting directly in front or behind him. Return the <strong>maximum </strong>number of students that can take the exam together without any cheating being possible..</p>
|
||||
|
||||
<p>Students must be placed in seats in good condition.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img height="200" src="https://assets.leetcode.com/uploads/2020/01/29/image.png" width="339" />
|
||||
<pre>
|
||||
<strong>Input:</strong> seats = [["#",".","#","#",".","#"],
|
||||
[".","#","#","#","#","."],
|
||||
["#",".","#","#",".","#"]]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Teacher can place 4 students in available seats so they don't cheat on the exam.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> seats = [[".","#"],
|
||||
["#","#"],
|
||||
["#","."],
|
||||
["#","#"],
|
||||
[".","#"]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Place all students in available seats.
|
||||
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> seats = [["#",".","<strong>.</strong>",".","#"],
|
||||
["<strong>.</strong>","#","<strong>.</strong>","#","<strong>.</strong>"],
|
||||
["<strong>.</strong>",".","#",".","<strong>.</strong>"],
|
||||
["<strong>.</strong>","#","<strong>.</strong>","#","<strong>.</strong>"],
|
||||
["#",".","<strong>.</strong>",".","#"]]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> Place students in available seats in column 1, 3 and 5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>seats</code> contains only characters <code>'.'<font face="sans-serif, Arial, Verdana, Trebuchet MS"> and</font></code><code>'#'.</code></li>
|
||||
<li><code>m == seats.length</code></li>
|
||||
<li><code>n == seats[i].length</code></li>
|
||||
<li><code>1 <= m <= 8</code></li>
|
||||
<li><code>1 <= n <= 8</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given a string <code>s</code> that consists of lower case English letters and brackets.</p>
|
||||
|
||||
<p>Reverse the strings in each pair of matching parentheses, starting from the innermost one.</p>
|
||||
|
||||
<p>Your result should <strong>not</strong> contain any brackets.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(abcd)"
|
||||
<strong>Output:</strong> "dcba"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(u(love)i)"
|
||||
<strong>Output:</strong> "iloveu"
|
||||
<strong>Explanation:</strong> The substring "love" is reversed first, then the whole string is reversed.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(ed(et(oc))el)"
|
||||
<strong>Output:</strong> "leetcode"
|
||||
<strong>Explanation:</strong> First, we reverse the substring "oc", then "etco", and finally, the whole string.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 2000</code></li>
|
||||
<li><code>s</code> only contains lower case English characters and parentheses.</li>
|
||||
<li>It is guaranteed that all parentheses are balanced.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>There is a set of <code>n</code> items. You are given two integer arrays <code>values</code> and <code>labels</code> where the value and the label of the <code>i<sup>th</sup></code> element are <code>values[i]</code> and <code>labels[i]</code> respectively. You are also given two integers <code>numWanted</code> and <code>useLimit</code>.</p>
|
||||
|
||||
<p>Choose a subset <code>s</code> of the <code>n</code> elements such that:</p>
|
||||
|
||||
<ul>
|
||||
<li>The size of the subset <code>s</code> is <strong>less than or equal to</strong> <code>numWanted</code>.</li>
|
||||
<li>There are <strong>at most</strong> <code>useLimit</code> items with the same label in <code>s</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>score</strong> of a subset is the sum of the values in the subset.</p>
|
||||
|
||||
<p>Return <em>the maximum <strong>score</strong> of a subset </em><code>s</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> The subset chosen is the first, third, and fifth items.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> values = [5,4,3,2,1], labels = [1,3,3,3,2], numWanted = 3, useLimit = 2
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The subset chosen is the first, second, and third items.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> values = [9,8,8,7,6], labels = [0,0,0,1,1], numWanted = 3, useLimit = 1
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> The subset chosen is the first and fourth items.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == values.length == labels.length</code></li>
|
||||
<li><code>1 <= n <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= values[i], labels[i] <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= numWanted, useLimit <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>Given an equation, represented by <code>words</code> on the left side and the <code>result</code> on the right side.</p>
|
||||
|
||||
<p>You need to check if the equation is solvable under the following rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>Each character is decoded as one digit (0 - 9).</li>
|
||||
<li>Every pair of different characters must map to different digits.</li>
|
||||
<li>Each <code>words[i]</code> and <code>result</code> are decoded as one number <strong>without</strong> leading zeros.</li>
|
||||
<li>Sum of numbers on the left side (<code>words</code>) will equal to the number on the right side (<code>result</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <code>true</code> <em>if the equation is solvable, otherwise return</em> <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["SEND","MORE"], result = "MONEY"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Map 'S'-> 9, 'E'->5, 'N'->6, 'D'->7, 'M'->1, 'O'->0, 'R'->8, 'Y'->'2'
|
||||
Such that: "SEND" + "MORE" = "MONEY" , 9567 + 1085 = 10652</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["SIX","SEVEN","SEVEN"], result = "TWENTY"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Map 'S'-> 6, 'I'->5, 'X'->0, 'E'->8, 'V'->7, 'N'->2, 'T'->1, 'W'->'3', 'Y'->4
|
||||
Such that: "SIX" + "SEVEN" + "SEVEN" = "TWENTY" , 650 + 68782 + 68782 = 138214</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["LEET","CODE"], result = "POINT"
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= words.length <= 5</code></li>
|
||||
<li><code>1 <= words[i].length, result.length <= 7</code></li>
|
||||
<li><code>words[i], result</code> contain only uppercase English letters.</li>
|
||||
<li>The number of different characters used in the expression is at most <code>10</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>On an <strong>8x8</strong> chessboard, there can be multiple Black Queens and one White King.</p>
|
||||
|
||||
|
||||
|
||||
<p>Given an array of integer coordinates <code>queens</code> that represents the positions of the Black Queens, and a pair of coordinates <code>king</code> that represent the position of the White King, return the coordinates of all the queens (in any order) that can attack the King.</p>
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/10/01/untitled-diagram.jpg" style="width: 321px; height: 321px;" /></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
<strong>Input:</strong> queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
|
||||
|
||||
<strong>Output:</strong> [[0,1],[1,0],[3,3]]
|
||||
|
||||
<strong>Explanation:</strong>
|
||||
|
||||
The queen at [0,1] can attack the king cause they're in the same row.
|
||||
|
||||
The queen at [1,0] can attack the king cause they're in the same column.
|
||||
|
||||
The queen at [3,3] can attack the king cause they're in the same diagnal.
|
||||
|
||||
The queen at [0,4] can't attack the king cause it's blocked by the queen at [0,1].
|
||||
|
||||
The queen at [4,0] can't attack the king cause it's blocked by the queen at [1,0].
|
||||
|
||||
The queen at [2,4] can't attack the king cause it's not in the same row/column/diagnal as the king.
|
||||
|
||||
</pre>
|
||||
|
||||
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/01/untitled-diagram-1.jpg" style="width: 321px; height: 321px;" /></strong></p>
|
||||
|
||||
|
||||
|
||||
<pre>
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>There is a malfunctioning keyboard where some letter keys do not work. All other keys on the keyboard work properly.</p>
|
||||
|
||||
<p>Given a string <code>text</code> of words separated by a single space (no leading or trailing spaces) and a string <code>brokenLetters</code> of all <strong>distinct</strong> letter keys that are broken, return <em>the <strong>number of words</strong> in</em> <code>text</code> <em>you can fully type using this keyboard</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "hello world", brokenLetters = "ad"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> We cannot type "world" because the 'd' key is broken.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "leet code", brokenLetters = "lt"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> We cannot type "leet" because the 'l' and 't' keys are broken.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> text = "leet code", brokenLetters = "e"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> We cannot type either word because the 'e' key is broken.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= brokenLetters.length <= 26</code></li>
|
||||
<li><code>text</code> consists of words separated by a single space without any leading or trailing spaces.</li>
|
||||
<li>Each word only consists of lowercase English letters.</li>
|
||||
<li><code>brokenLetters</code> consists of <strong>distinct</strong> lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>There are several cards <strong>arranged in a row</strong>, and each card has an associated number of points. The points are given in the integer array <code>cardPoints</code>.</p>
|
||||
|
||||
<p>In one step, you can take one card from the beginning or from the end of the row. You have to take exactly <code>k</code> cards.</p>
|
||||
|
||||
<p>Your score is the sum of the points of the cards you have taken.</p>
|
||||
|
||||
<p>Given the integer array <code>cardPoints</code> and the integer <code>k</code>, return the <em>maximum score</em> you can obtain.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cardPoints = [1,2,3,4,5,6,1], k = 3
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cardPoints = [2,2,2], k = 2
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Regardless of which two cards you take, your score will always be 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cardPoints = [9,7,7,9,7,7,9], k = 7
|
||||
<strong>Output:</strong> 55
|
||||
<strong>Explanation:</strong> You have to take all the cards. Your score is the sum of points of all cards.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= cardPoints.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= cardPoints[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= k <= cardPoints.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given an array <code>nums</code> of integers, we need to find the maximum possible sum of elements of the array such that it is divisible by three.</p>
|
||||
|
||||
<ol>
|
||||
</ol>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,6,5,1,8]
|
||||
<strong>Output:</strong> 18
|
||||
<strong>Explanation:</strong> Pick numbers 3, 6, 1 and 8 their sum is 18 (maximum sum divisible by 3).</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Since 4 is not divisible by 3, do not pick any number.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,4]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> Pick numbers 1, 3, 4 and 4 their sum is 12 (maximum sum divisible by 3).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 4 * 10^4</code></li>
|
||||
<li><code>1 <= nums[i] <= 10^4</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given an array <code>arr</code> of positive integers, consider all binary trees such that:</p>
|
||||
|
||||
<ul>
|
||||
<li>Each node has either <code>0</code> or <code>2</code> children;</li>
|
||||
<li>The values of <code>arr</code> correspond to the values of each <strong>leaf</strong> in an in-order traversal of the tree.</li>
|
||||
<li>The value of each non-leaf node is equal to the product of the largest leaf value in its left and right subtree, respectively.</li>
|
||||
</ul>
|
||||
|
||||
<p>Among all possible binary trees considered, return <em>the smallest possible sum of the values of each non-leaf node</em>. It is guaranteed this sum fits into a <strong>32-bit</strong> integer.</p>
|
||||
|
||||
<p>A node is a <strong>leaf</strong> if and only if it has zero children.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/tree1.jpg" style="width: 500px; height: 169px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [6,2,4]
|
||||
<strong>Output:</strong> 32
|
||||
<strong>Explanation:</strong> There are two possible trees shown.
|
||||
The first has a non-leaf node sum 36, and the second has non-leaf node sum 32.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/tree2.jpg" style="width: 224px; height: 145px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [4,11]
|
||||
<strong>Output:</strong> 44
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= arr.length <= 40</code></li>
|
||||
<li><code>1 <= arr[i] <= 15</code></li>
|
||||
<li>It is guaranteed that the answer fits into a <strong>32-bit</strong> signed integer (i.e., it is less than 2<sup>31</sup>).</li>
|
||||
</ul>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user