mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-10-20 04:26:48 +08:00
update
This commit is contained in:
30
leetcode/problem/01-matrix.html
Normal file
30
leetcode/problem/01-matrix.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an <code>m x n</code> binary matrix <code>mat</code>, return <em>the distance of the nearest </em><code>0</code><em> for each cell</em>.</p>
|
||||
|
||||
<p>The distance between two adjacent cells is <code>1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-1-grid.jpg" style="width: 253px; height: 253px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0,0],[0,1,0],[0,0,0]]
|
||||
<strong>Output:</strong> [[0,0,0],[0,1,0],[0,0,0]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-2-grid.jpg" style="width: 253px; height: 253px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[0,0,0],[0,1,0],[1,1,1]]
|
||||
<strong>Output:</strong> [[0,0,0],[0,1,0],[1,2,1]]
|
||||
</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 <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>4</sup></code></li>
|
||||
<li><code>mat[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li>There is at least one <code>0</code> in <code>mat</code>.</li>
|
||||
</ul>
|
||||
35
leetcode/problem/1-bit-and-2-bit-characters.html
Normal file
35
leetcode/problem/1-bit-and-2-bit-characters.html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>We have two special characters:</p>
|
||||
|
||||
<ul>
|
||||
<li>The first character can be represented by one bit <code>0</code>.</li>
|
||||
<li>The second character can be represented by two bits (<code>10</code> or <code>11</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p>Given a binary array <code>bits</code> that ends with <code>0</code>, return <code>true</code> if the last character must be a one-bit character.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bits = [1,0,0]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> The only way to decode it is two-bit character and one-bit character.
|
||||
So the last character is one-bit character.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> bits = [1,1,1,0]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> The only way to decode it is two-bit character and two-bit character.
|
||||
So the last character is not one-bit character.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= bits.length <= 1000</code></li>
|
||||
<li><code>bits[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
37
leetcode/problem/132-pattern.html
Normal file
37
leetcode/problem/132-pattern.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given an array of <code>n</code> integers <code>nums</code>, a <strong>132 pattern</strong> is a subsequence of three integers <code>nums[i]</code>, <code>nums[j]</code> and <code>nums[k]</code> such that <code>i < j < k</code> and <code>nums[i] < nums[k] < nums[j]</code>.</p>
|
||||
|
||||
<p>Return <em><code>true</code> if there is a <strong>132 pattern</strong> in <code>nums</code>, otherwise, return <code>false</code>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> There is no 132 pattern in the sequence.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,4,2]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> There is a 132 pattern in the sequence: [1, 4, 2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,3,2,0]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 2 * 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
34
leetcode/problem/2-keys-keyboard.html
Normal file
34
leetcode/problem/2-keys-keyboard.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>There is only one character <code>'A'</code> on the screen of a notepad. You can perform two operations on this notepad for each step:</p>
|
||||
|
||||
<ul>
|
||||
<li>Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).</li>
|
||||
<li>Paste: You can paste the characters which are copied last time.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>the minimum number of operations to get the character</em> <code>'A'</code> <em>exactly</em> <code>n</code> <em>times on the screen</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Intitally, we have one character 'A'.
|
||||
In step 1, we use Copy All operation.
|
||||
In step 2, we use Paste operation to get 'AA'.
|
||||
In step 3, we use Paste operation to get 'AAA'.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
</ul>
|
||||
48
leetcode/problem/24-game.html
Normal file
48
leetcode/problem/24-game.html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>You are given an integer array <code>cards</code> of length <code>4</code>. You have four cards, each containing a number in the range <code>[1, 9]</code>. You should arrange the numbers on these cards in a mathematical expression using the operators <code>['+', '-', '*', '/']</code> and the parentheses <code>'('</code> and <code>')'</code> to get the value 24.</p>
|
||||
|
||||
<p>You are restricted with the following rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>The division operator <code>'/'</code> represents real division, not integer division.
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>4 / (1 - 2 / 3) = 4 / (1 / 3) = 12</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Every operation done is between two numbers. In particular, we cannot use <code>'-'</code> as a unary operator.
|
||||
<ul>
|
||||
<li>For example, if <code>cards = [1, 1, 1, 1]</code>, the expression <code>"-1 - 1 - 1 - 1"</code> is <strong>not allowed</strong>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>You cannot concatenate numbers together
|
||||
<ul>
|
||||
<li>For example, if <code>cards = [1, 2, 1, 2]</code>, the expression <code>"12 + 12"</code> is not valid.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <code>true</code> if you can get such expression that evaluates to <code>24</code>, and <code>false</code> otherwise.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cards = [4,1,8,7]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> (8-4) * (7-1) = 24
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> cards = [1,2,1,2]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>cards.length == 4</code></li>
|
||||
<li><code>1 <= cards[i] <= 9</code></li>
|
||||
</ul>
|
||||
30
leetcode/problem/3sum-closest.html
Normal file
30
leetcode/problem/3sum-closest.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an integer array <code>nums</code> of length <code>n</code> and an integer <code>target</code>, find three integers in <code>nums</code> such that the sum is closest to <code>target</code>.</p>
|
||||
|
||||
<p>Return <em>the sum of the three integers</em>.</p>
|
||||
|
||||
<p>You may assume that each input would have exactly one solution.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,2,1,-4], target = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,0], target = 1
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 1000</code></li>
|
||||
<li><code>-1000 <= nums[i] <= 1000</code></li>
|
||||
<li><code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/3sum-with-multiplicity.html
Normal file
37
leetcode/problem/3sum-with-multiplicity.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given an integer array <code>arr</code>, and an integer <code>target</code>, return the number of tuples <code>i, j, k</code> such that <code>i < j < k</code> and <code>arr[i] + arr[j] + arr[k] == target</code>.</p>
|
||||
|
||||
<p>As the answer can be very 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> arr = [1,1,2,2,3,3,4,4,5,5], target = 8
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation: </strong>
|
||||
Enumerating by the values (arr[i], arr[j], arr[k]):
|
||||
(1, 2, 5) occurs 8 times;
|
||||
(1, 3, 4) occurs 8 times;
|
||||
(2, 2, 4) occurs 2 times;
|
||||
(2, 3, 3) occurs 2 times.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,1,2,2,2,2], target = 5
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation: </strong>
|
||||
arr[i] = 1, arr[j] = arr[k] = 2 occurs 12 times:
|
||||
We choose one 1 from [1,1] in 2 ways,
|
||||
and two 2s from [2,2,2,2] in 6 ways.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= arr.length <= 3000</code></li>
|
||||
<li><code>0 <= arr[i] <= 100</code></li>
|
||||
<li><code>0 <= target <= 300</code></li>
|
||||
</ul>
|
||||
22
leetcode/problem/3sum.html
Normal file
22
leetcode/problem/3sum.html
Normal file
@@ -0,0 +1,22 @@
|
||||
<p>Given an integer array nums, return all the triplets <code>[nums[i], nums[j], nums[k]]</code> such that <code>i != j</code>, <code>i != k</code>, and <code>j != k</code>, and <code>nums[i] + nums[j] + nums[k] == 0</code>.</p>
|
||||
|
||||
<p>Notice that the solution set must not contain duplicate triplets.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
|
||||
<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = []
|
||||
<strong>Output:</strong> []
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [0]
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= nums.length <= 3000</code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/4sum-ii.html
Normal file
37
leetcode/problem/4sum-ii.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= i, j, k, l < n</code></li>
|
||||
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
The two tuples are:
|
||||
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
|
||||
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums1.length</code></li>
|
||||
<li><code>n == nums2.length</code></li>
|
||||
<li><code>n == nums3.length</code></li>
|
||||
<li><code>n == nums4.length</code></li>
|
||||
<li><code>1 <= n <= 200</code></li>
|
||||
<li><code>-2<sup>28</sup> <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2<sup>28</sup></code></li>
|
||||
</ul>
|
||||
33
leetcode/problem/4sum.html
Normal file
33
leetcode/problem/4sum.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= a, b, c, d < n</code></li>
|
||||
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
|
||||
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
|
||||
</ul>
|
||||
|
||||
<p>You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
|
||||
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
|
||||
<strong>Output:</strong> [[2,2,2,2]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 200</code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/a-number-after-a-double-reversal.html
Normal file
39
leetcode/problem/a-number-after-a-double-reversal.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p><strong>Reversing</strong> an integer means to reverse all its digits.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, reversing <code>2021</code> gives <code>1202</code>. Reversing <code>12300</code> gives <code>321</code> as the <strong>leading zeros are not retained</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer <code>num</code>, <strong>reverse</strong> <code>num</code> to get <code>reversed1</code>, <strong>then reverse</strong> <code>reversed1</code> to get <code>reversed2</code>. Return <code>true</code> <em>if</em> <code>reversed2</code> <em>equals</em> <code>num</code>. Otherwise return <code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 526
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Reverse num to get 625, then reverse 625 to get 526, which equals num.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 1800
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> Reverse num to get 81, then reverse 81 to get 18, which does not equal num.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 0
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Reverse num to get 0, then reverse 0 to get 0, which equals num.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= num <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
62
leetcode/problem/abbreviating-the-product-of-a-range.html
Normal file
62
leetcode/problem/abbreviating-the-product-of-a-range.html
Normal file
@@ -0,0 +1,62 @@
|
||||
<p>You are given two positive integers <code>left</code> and <code>right</code> with <code>left <= right</code>. Calculate the <strong>product</strong> of all integers in the <strong>inclusive</strong> range <code>[left, right]</code>.</p>
|
||||
|
||||
<p>Since the product may be very large, you will <strong>abbreviate</strong> it following these steps:</p>
|
||||
|
||||
<ol>
|
||||
<li>Count all <strong>trailing</strong> zeros in the product and <strong>remove</strong> them. Let us denote this count as <code>C</code>.
|
||||
|
||||
<ul>
|
||||
<li>For example, there are <code>3</code> trailing zeros in <code>1000</code>, and there are <code>0</code> trailing zeros in <code>546</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Denote the remaining number of digits in the product as <code>d</code>. If <code>d > 10</code>, then express the product as <code><pre>...<suf></code> where <code><pre></code> denotes the <strong>first</strong> <code>5</code> digits of the product, and <code><suf></code> denotes the <strong>last</strong> <code>5</code> digits of the product <strong>after</strong> removing all trailing zeros. If <code>d <= 10</code>, we keep it unchanged.
|
||||
<ul>
|
||||
<li>For example, we express <code>1234567654321</code> as <code>12345...54321</code>, but <code>1234567</code> is represented as <code>1234567</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Finally, represent the product as a <strong>string</strong> <code>"<pre>...<suf>eC"</code>.
|
||||
<ul>
|
||||
<li>For example, <code>12345678987600000</code> will be represented as <code>"12345...89876e5"</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>a string denoting the <strong>abbreviated product</strong> of all integers in the <strong>inclusive</strong> range</em> <code>[left, right]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 1, right = 4
|
||||
<strong>Output:</strong> "24e0"
|
||||
<strong>Explanation:</strong> The product is 1 × 2 × 3 × 4 = 24.
|
||||
There are no trailing zeros, so 24 remains the same. The abbreviation will end with "e0".
|
||||
Since the number of digits is 2, which is less than 10, we do not have to abbreviate it further.
|
||||
Thus, the final representation is "24e0".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 2, right = 11
|
||||
<strong>Output:</strong> "399168e2"
|
||||
<strong>Explanation:</strong> The product is 39916800.
|
||||
There are 2 trailing zeros, which we remove to get 399168. The abbreviation will end with "e2".
|
||||
The number of digits after removing the trailing zeros is 6, so we do not abbreviate it further.
|
||||
Hence, the abbreviated product is "399168e2".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> left = 371, right = 375
|
||||
<strong>Output:</strong> "7219856259e3"
|
||||
<strong>Explanation:</strong> The product is 7219856259000.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= left <= right <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
36
leetcode/problem/accounts-merge.html
Normal file
36
leetcode/problem/accounts-merge.html
Normal file
@@ -0,0 +1,36 @@
|
||||
<p>Given a list of <code>accounts</code> where each element <code>accounts[i]</code> is a list of strings, where the first element <code>accounts[i][0]</code> is a name, and the rest of the elements are <strong>emails</strong> representing emails of the account.</p>
|
||||
|
||||
<p>Now, we would like to merge these accounts. Two accounts definitely belong to the same person if there is some common email to both accounts. Note that even if two accounts have the same name, they may belong to different people as people could have the same name. A person can have any number of accounts initially, but all of their accounts definitely have the same name.</p>
|
||||
|
||||
<p>After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails <strong>in sorted order</strong>. The accounts themselves can be returned in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> accounts = [["John","johnsmith@mail.com","john_newyork@mail.com"],["John","johnsmith@mail.com","john00@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]
|
||||
<strong>Output:</strong> [["John","john00@mail.com","john_newyork@mail.com","johnsmith@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]
|
||||
<strong>Explanation:</strong>
|
||||
The first and second John's are the same person as they have the common email "johnsmith@mail.com".
|
||||
The third John and Mary are different people as none of their email addresses are used by other accounts.
|
||||
We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'],
|
||||
['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> accounts = [["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]]
|
||||
<strong>Output:</strong> [["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"],["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= accounts.length <= 1000</code></li>
|
||||
<li><code>2 <= accounts[i].length <= 10</code></li>
|
||||
<li><code>1 <= accounts[i][j] <= 30</code></li>
|
||||
<li><code>accounts[i][0]</code> consists of English letters.</li>
|
||||
<li><code>accounts[i][j] (for j > 0)</code> is a valid email.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>Table: <code>ActorDirector</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| actor_id | int |
|
||||
| director_id | int |
|
||||
| timestamp | int |
|
||||
+-------------+---------+
|
||||
timestamp is the primary key column for this table.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write a SQL query for a report that provides the pairs <code>(actor_id, director_id)</code> where the actor has cooperated with the director at least three times.</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
ActorDirector table:
|
||||
+-------------+-------------+-------------+
|
||||
| actor_id | director_id | timestamp |
|
||||
+-------------+-------------+-------------+
|
||||
| 1 | 1 | 0 |
|
||||
| 1 | 1 | 1 |
|
||||
| 1 | 1 | 2 |
|
||||
| 1 | 2 | 3 |
|
||||
| 1 | 2 | 4 |
|
||||
| 2 | 1 | 5 |
|
||||
| 2 | 1 | 6 |
|
||||
+-------------+-------------+-------------+
|
||||
<strong>Output:</strong>
|
||||
+-------------+-------------+
|
||||
| actor_id | director_id |
|
||||
+-------------+-------------+
|
||||
| 1 | 1 |
|
||||
+-------------+-------------+
|
||||
<strong>Explanation:</strong> The only pair is (1, 1) where they cooperated exactly 3 times.
|
||||
</pre>
|
||||
18
leetcode/problem/add-binary.html
Normal file
18
leetcode/problem/add-binary.html
Normal file
@@ -0,0 +1,18 @@
|
||||
<p>Given two binary strings <code>a</code> and <code>b</code>, return <em>their sum as a binary string</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> a = "11", b = "1"
|
||||
<strong>Output:</strong> "100"
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> a = "1010", b = "1011"
|
||||
<strong>Output:</strong> "10101"
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= a.length, b.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>a</code> and <code>b</code> consist only of <code>'0'</code> or <code>'1'</code> characters.</li>
|
||||
<li>Each string does not contain leading zeros except for the zero itself.</li>
|
||||
</ul>
|
||||
30
leetcode/problem/add-digits.html
Normal file
30
leetcode/problem/add-digits.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an integer <code>num</code>, repeatedly add all its digits until the result has only one digit, and return it.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 38
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The process is
|
||||
38 --> 3 + 8 --> 11
|
||||
11 --> 1 + 1 --> 2
|
||||
Since 2 has only one digit, return it.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = 0
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= num <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Could you do it without any loop/recursion in <code>O(1)</code> runtime?</p>
|
||||
47
leetcode/problem/add-minimum-number-of-rungs.html
Normal file
47
leetcode/problem/add-minimum-number-of-rungs.html
Normal file
@@ -0,0 +1,47 @@
|
||||
<p>You are given a <strong>strictly increasing</strong> integer array <code>rungs</code> that represents the <strong>height</strong> of rungs on a ladder. You are currently on the <strong>floor</strong> at height <code>0</code>, and you want to reach the last rung.</p>
|
||||
|
||||
<p>You are also given an integer <code>dist</code>. You can only climb to the next highest rung if the distance between where you are currently at (the floor or on a rung) and the next rung is <strong>at most</strong> <code>dist</code>. You are able to insert rungs at any positive <strong>integer</strong> height if a rung is not already there.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of rungs that must be added to the ladder in order for you to climb to the last rung.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rungs = [1,3,5,10], dist = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:
|
||||
</strong>You currently cannot reach the last rung.
|
||||
Add rungs at heights 7 and 8 to climb this ladder.
|
||||
The ladder will now have rungs at [1,3,5,<u>7</u>,<u>8</u>,10].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rungs = [3,6,8,10], dist = 3
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong>
|
||||
This ladder can be climbed without adding additional rungs.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rungs = [3,4,6,7], dist = 2
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
You currently cannot reach the first rung from the ground.
|
||||
Add a rung at height 1 to climb this ladder.
|
||||
The ladder will now have rungs at [<u>1</u>,3,4,6,7].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= rungs.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= rungs[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= dist <= 10<sup>9</sup></code></li>
|
||||
<li><code>rungs</code> is <strong>strictly increasing</strong>.</li>
|
||||
</ul>
|
||||
38
leetcode/problem/add-one-row-to-tree.html
Normal file
38
leetcode/problem/add-one-row-to-tree.html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p>Given the <code>root</code> of a binary tree and two integers <code>val</code> and <code>depth</code>, add a row of nodes with value <code>val</code> at the given depth <code>depth</code>.</p>
|
||||
|
||||
<p>Note that the <code>root</code> node is at depth <code>1</code>.</p>
|
||||
|
||||
<p>The adding rule is:</p>
|
||||
|
||||
<ul>
|
||||
<li>Given the integer <code>depth</code>, for each not null tree node <code>cur</code> at the depth <code>depth - 1</code>, create two tree nodes with value <code>val</code> as <code>cur</code>'s left subtree root and right subtree root.</li>
|
||||
<li><code>cur</code>'s original left subtree should be the left subtree of the new left subtree root.</li>
|
||||
<li><code>cur</code>'s original right subtree should be the right subtree of the new right subtree root.</li>
|
||||
<li>If <code>depth == 1</code> that means there is no depth <code>depth - 1</code> at all, then create a tree node with value <code>val</code> as the new root of the whole original tree, and the original tree is the new root's left subtree.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/15/addrow-tree.jpg" style="width: 500px; height: 231px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [4,2,6,3,1,5], val = 1, depth = 2
|
||||
<strong>Output:</strong> [4,1,1,2,null,null,6,3,1,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/11/add2-tree.jpg" style="width: 500px; height: 277px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [4,2,null,3,1], val = 1, depth = 3
|
||||
<strong>Output:</strong> [4,2,null,1,1,3,null,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, 10<sup>4</sup>]</code>.</li>
|
||||
<li>The depth of the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li><code>-10<sup>5</sup> <= val <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= depth <= the depth of tree + 1</code></li>
|
||||
</ul>
|
||||
34
leetcode/problem/add-strings.html
Normal file
34
leetcode/problem/add-strings.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>Given two non-negative integers, <code>num1</code> and <code>num2</code> represented as string, return <em>the sum of</em> <code>num1</code> <em>and</em> <code>num2</code> <em>as a string</em>.</p>
|
||||
|
||||
<p>You must solve the problem without using any built-in library for handling large integers (such as <code>BigInteger</code>). You must also not convert the inputs to integers directly.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num1 = "11", num2 = "123"
|
||||
<strong>Output:</strong> "134"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num1 = "456", num2 = "77"
|
||||
<strong>Output:</strong> "533"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num1 = "0", num2 = "0"
|
||||
<strong>Output:</strong> "0"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num1.length, num2.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>num1</code> and <code>num2</code> consist of only digits.</li>
|
||||
<li><code>num1</code> and <code>num2</code> don't have any leading zeros except for the zero itself.</li>
|
||||
</ul>
|
||||
42
leetcode/problem/add-to-array-form-of-integer.html
Normal file
42
leetcode/problem/add-to-array-form-of-integer.html
Normal file
@@ -0,0 +1,42 @@
|
||||
<p>The <strong>array-form</strong> of an integer <code>num</code> is an array representing its digits in left to right order.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, for <code>num = 1321</code>, the array form is <code>[1,3,2,1]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given <code>num</code>, the <strong>array-form</strong> of an integer, and an integer <code>k</code>, return <em>the <strong>array-form</strong> of the integer</em> <code>num + k</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = [1,2,0,0], k = 34
|
||||
<strong>Output:</strong> [1,2,3,4]
|
||||
<strong>Explanation:</strong> 1200 + 34 = 1234
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = [2,7,4], k = 181
|
||||
<strong>Output:</strong> [4,5,5]
|
||||
<strong>Explanation:</strong> 274 + 181 = 455
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = [2,1,5], k = 806
|
||||
<strong>Output:</strong> [1,0,2,1]
|
||||
<strong>Explanation:</strong> 215 + 806 = 1021
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= num[i] <= 9</code></li>
|
||||
<li><code>num</code> does not contain any leading zeros except for the zero itself.</li>
|
||||
<li><code>1 <= k <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/add-two-numbers-ii.html
Normal file
37
leetcode/problem/add-two-numbers-ii.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>You are given two <strong>non-empty</strong> linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.</p>
|
||||
|
||||
<p>You may assume the two numbers do not contain any leading zero, except the number 0 itself.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/sumii-linked-list.jpg" style="width: 523px; height: 342px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [7,2,4,3], l2 = [5,6,4]
|
||||
<strong>Output:</strong> [7,8,0,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [2,4,3], l2 = [5,6,4]
|
||||
<strong>Output:</strong> [8,0,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [0], l2 = [0]
|
||||
<strong>Output:</strong> [0]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in each linked list is in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li>It is guaranteed that the list represents a number that does not have leading zeros.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Could you solve it without reversing the input lists?</p>
|
||||
35
leetcode/problem/add-two-numbers.html
Normal file
35
leetcode/problem/add-two-numbers.html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>You are given two <strong>non-empty</strong> linked lists representing two non-negative integers. The digits are stored in <strong>reverse order</strong>, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.</p>
|
||||
|
||||
<p>You may assume the two numbers do not contain any leading zero, except the number 0 itself.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg" style="width: 483px; height: 342px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [2,4,3], l2 = [5,6,4]
|
||||
<strong>Output:</strong> [7,0,8]
|
||||
<strong>Explanation:</strong> 342 + 465 = 807.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [0], l2 = [0]
|
||||
<strong>Output:</strong> [0]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
|
||||
<strong>Output:</strong> [8,9,9,9,0,0,0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in each linked list is in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li>It is guaranteed that the list represents a number that does not have leading zeros.</li>
|
||||
</ul>
|
||||
48
leetcode/problem/adding-spaces-to-a-string.html
Normal file
48
leetcode/problem/adding-spaces-to-a-string.html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>s</code> and a <strong>0-indexed</strong> integer array <code>spaces</code> that describes the indices in the original string where spaces will be added. Each space should be inserted <strong>before</strong> the character at the given index.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, given <code>s = "EnjoyYourCoffee"</code> and <code>spaces = [5, 9]</code>, we place spaces before <code>'Y'</code> and <code>'C'</code>, which are at indices <code>5</code> and <code>9</code> respectively. Thus, we obtain <code>"Enjoy <strong><u>Y</u></strong>our <u><strong>C</strong></u>offee"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return<strong> </strong><em>the modified string <strong>after</strong> the spaces have been added.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "LeetcodeHelpsMeLearn", spaces = [8,13,15]
|
||||
<strong>Output:</strong> "Leetcode Helps Me Learn"
|
||||
<strong>Explanation:</strong>
|
||||
The indices 8, 13, and 15 correspond to the underlined characters in "Leetcode<u><strong>H</strong></u>elps<u><strong>M</strong></u>e<u><strong>L</strong></u>earn".
|
||||
We then place spaces before those characters.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "icodeinpython", spaces = [1,5,7,9]
|
||||
<strong>Output:</strong> "i code in py thon"
|
||||
<strong>Explanation:</strong>
|
||||
The indices 1, 5, 7, and 9 correspond to the underlined characters in "i<u><strong>c</strong></u>ode<u><strong>i</strong></u>n<u><strong>p</strong></u>y<u><strong>t</strong></u>hon".
|
||||
We then place spaces before those characters.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "spacing", spaces = [0,1,2,3,4,5,6]
|
||||
<strong>Output:</strong> " s p a c i n g"
|
||||
<strong>Explanation:</strong>
|
||||
We are also able to place spaces before the first character of the string.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists only of lowercase and uppercase English letters.</li>
|
||||
<li><code>1 <= spaces.length <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= spaces[i] <= s.length - 1</code></li>
|
||||
<li>All the values of <code>spaces</code> are <strong>strictly increasing</strong>.</li>
|
||||
</ul>
|
||||
37
leetcode/problem/adding-two-negabinary-numbers.html
Normal file
37
leetcode/problem/adding-two-negabinary-numbers.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given two numbers <code>arr1</code> and <code>arr2</code> in base <strong>-2</strong>, return the result of adding them together.</p>
|
||||
|
||||
<p>Each number is given in <em>array format</em>: as an array of 0s and 1s, from most significant bit to least significant bit. For example, <code>arr = [1,1,0,1]</code> represents the number <code>(-2)^3 + (-2)^2 + (-2)^0 = -3</code>. A number <code>arr</code> in <em>array, format</em> is also guaranteed to have no leading zeros: either <code>arr == [0]</code> or <code>arr[0] == 1</code>.</p>
|
||||
|
||||
<p>Return the result of adding <code>arr1</code> and <code>arr2</code> in the same format: as an array of 0s and 1s with no leading zeros.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [1,1,1,1,1], arr2 = [1,0,1]
|
||||
<strong>Output:</strong> [1,0,0,0,0]
|
||||
<strong>Explanation: </strong>arr1 represents 11, arr2 represents 5, the output represents 16.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [0], arr2 = [0]
|
||||
<strong>Output:</strong> [0]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr1 = [0], arr2 = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr1.length, arr2.length <= 1000</code></li>
|
||||
<li><code>arr1[i]</code> and <code>arr2[i]</code> are <code>0</code> or <code>1</code></li>
|
||||
<li><code>arr1</code> and <code>arr2</code> have no leading zeros</li>
|
||||
</ul>
|
||||
39
leetcode/problem/additive-number.html
Normal file
39
leetcode/problem/additive-number.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>An <strong>additive number</strong> is a string whose digits can form an <strong>additive sequence</strong>.</p>
|
||||
|
||||
<p>A valid <strong>additive sequence</strong> should contain <strong>at least</strong> three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.</p>
|
||||
|
||||
<p>Given a string containing only digits, return <code>true</code> if it is an <strong>additive number</strong> or <code>false</code> otherwise.</p>
|
||||
|
||||
<p><strong>Note:</strong> Numbers in the additive sequence <strong>cannot</strong> have leading zeros, so sequence <code>1, 2, 03</code> or <code>1, 02, 3</code> is invalid.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> "112358"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong>
|
||||
The digits can form an additive sequence: 1, 1, 2, 3, 5, 8.
|
||||
1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> "199100199"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong>
|
||||
The additive sequence is: 1, 99, 100, 199.
|
||||
1 + 99 = 100, 99 + 100 = 199
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num.length <= 35</code></li>
|
||||
<li><code>num</code> consists only of digits.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> How would you handle overflow for very large input integers?</p>
|
||||
20
leetcode/problem/advantage-shuffle.html
Normal file
20
leetcode/problem/advantage-shuffle.html
Normal file
@@ -0,0 +1,20 @@
|
||||
<p>You are given two integer arrays <code>nums1</code> and <code>nums2</code> both of the same length. The <strong>advantage</strong> of <code>nums1</code> with respect to <code>nums2</code> is the number of indices <code>i</code> for which <code>nums1[i] > nums2[i]</code>.</p>
|
||||
|
||||
<p>Return <em>any permutation of </em><code>nums1</code><em> that maximizes its <strong>advantage</strong> with respect to </em><code>nums2</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums1 = [2,7,11,15], nums2 = [1,10,4,11]
|
||||
<strong>Output:</strong> [2,11,7,15]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums1 = [12,24,8,32], nums2 = [13,25,32,11]
|
||||
<strong>Output:</strong> [24,32,8,12]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>nums2.length == nums1.length</code></li>
|
||||
<li><code>0 <= nums1[i], nums2[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/airplane-seat-assignment-probability.html
Normal file
31
leetcode/problem/airplane-seat-assignment-probability.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p><code>n</code> passengers board an airplane with exactly <code>n</code> seats. The first passenger has lost the ticket and picks a seat randomly. But after that, the rest of the passengers will:</p>
|
||||
|
||||
<ul>
|
||||
<li>Take their own seat if it is still available, and</li>
|
||||
<li>Pick other seats randomly when they find their seat occupied</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the probability that the </em><code>n<sup>th</sup></code><em> person gets his own seat</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1.00000
|
||||
<strong>Explanation: </strong>The first person can only get the first seat.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> 0.50000
|
||||
<strong>Explanation: </strong>The second person has a probability of 0.5 to get the second seat (when first person gets the first seat).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>LeetCode company workers use key-cards to unlock office doors. Each time a worker uses their key-card, the security system saves the worker's name and the time when it was used. The system emits an <strong>alert</strong> if any worker uses the key-card <strong>three or more times</strong> in a one-hour period.</p>
|
||||
|
||||
<p>You are given a list of strings <code>keyName</code> and <code>keyTime</code> where <code>[keyName[i], keyTime[i]]</code> corresponds to a person's name and the time when their key-card was used <strong>in a</strong> <strong>single day</strong>.</p>
|
||||
|
||||
<p>Access times are given in the <strong>24-hour time format "HH:MM"</strong>, such as <code>"23:51"</code> and <code>"09:49"</code>.</p>
|
||||
|
||||
<p>Return a <em>list of unique worker names who received an alert for frequent keycard use</em>. Sort the names in <strong>ascending order alphabetically</strong>.</p>
|
||||
|
||||
<p>Notice that <code>"10:00"</code> - <code>"11:00"</code> is considered to be within a one-hour period, while <code>"22:51"</code> - <code>"23:52"</code> is not considered to be within a one-hour period.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> keyName = ["daniel","daniel","daniel","luis","luis","luis","luis"], keyTime = ["10:00","10:40","11:00","09:00","11:00","13:00","15:00"]
|
||||
<strong>Output:</strong> ["daniel"]
|
||||
<strong>Explanation:</strong> "daniel" used the keycard 3 times in a one-hour period ("10:00","10:40", "11:00").
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> keyName = ["alice","alice","alice","bob","bob","bob","bob"], keyTime = ["12:01","12:00","18:00","21:00","21:20","21:30","23:00"]
|
||||
<strong>Output:</strong> ["bob"]
|
||||
<strong>Explanation:</strong> "bob" used the keycard 3 times in a one-hour period ("21:00","21:20", "21:30").
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= keyName.length, keyTime.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>keyName.length == keyTime.length</code></li>
|
||||
<li><code>keyTime[i]</code> is in the format <strong>"HH:MM"</strong>.</li>
|
||||
<li><code>[keyName[i], keyTime[i]]</code> is <strong>unique</strong>.</li>
|
||||
<li><code>1 <= keyName[i].length <= 10</code></li>
|
||||
<li><code>keyName[i] contains only lowercase English letters.</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>You are given a positive integer <code>n</code> representing the number of nodes of a <strong>Directed Acyclic Graph</strong> (DAG). The nodes are numbered from <code>0</code> to <code>n - 1</code> (<strong>inclusive</strong>).</p>
|
||||
|
||||
<p>You are also given a 2D integer array <code>edges</code>, where <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>]</code> denotes that there is a <strong>unidirectional</strong> edge from <code>from<sub>i</sub></code> to <code>to<sub>i</sub></code> in the graph.</p>
|
||||
|
||||
<p>Return <em>a list</em> <code>answer</code><em>, where </em><code>answer[i]</code><em> is the <strong>list of ancestors</strong> of the</em> <code>i<sup>th</sup></code> <em>node, sorted in <strong>ascending order</strong></em>.</p>
|
||||
|
||||
<p>A node <code>u</code> is an <strong>ancestor</strong> of another node <code>v</code> if <code>u</code> can reach <code>v</code> via a set of edges.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/12/e1.png" style="width: 322px; height: 265px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 8, edgeList = [[0,3],[0,4],[1,3],[2,4],[2,7],[3,5],[3,6],[3,7],[4,6]]
|
||||
<strong>Output:</strong> [[],[],[],[0,1],[0,2],[0,1,3],[0,1,2,3,4],[0,1,2,3]]
|
||||
<strong>Explanation:</strong>
|
||||
The above diagram represents the input graph.
|
||||
- Nodes 0, 1, and 2 do not have any ancestors.
|
||||
- Node 3 has two ancestors 0 and 1.
|
||||
- Node 4 has two ancestors 0 and 2.
|
||||
- Node 5 has three ancestors 0, 1, and 3.
|
||||
- Node 6 has five ancestors 0, 1, 2, 3, and 4.
|
||||
- Node 7 has four ancestors 0, 1, 2, and 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/12/e2.png" style="width: 343px; height: 299px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, edgeList = [[0,1],[0,2],[0,3],[0,4],[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
|
||||
<strong>Output:</strong> [[],[0],[0,1],[0,1,2],[0,1,2,3]]
|
||||
<strong>Explanation:</strong>
|
||||
The above diagram represents the input graph.
|
||||
- Node 0 does not have any ancestor.
|
||||
- Node 1 has one ancestor 0.
|
||||
- Node 2 has two ancestors 0 and 1.
|
||||
- Node 3 has three ancestors 0, 1, and 2.
|
||||
- Node 4 has four ancestors 0, 1, 2, and 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>0 <= edges.length <= min(2000, n * (n - 1) / 2)</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>0 <= from<sub>i</sub>, to<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>from<sub>i</sub> != to<sub>i</sub></code></li>
|
||||
<li>There are no duplicate edges.</li>
|
||||
<li>The graph is <strong>directed</strong> and <strong>acyclic</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,60 @@
|
||||
<p>You are given a <strong>0-indexed</strong> binary array <code>nums</code> of length <code>n</code>. <code>nums</code> can be divided at index <code>i</code> (where <code>0 <= i <= n)</code> into two arrays (possibly empty) <code>nums<sub>left</sub></code> and <code>nums<sub>right</sub></code>:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>nums<sub>left</sub></code> has all the elements of <code>nums</code> between index <code>0</code> and <code>i - 1</code> <strong>(inclusive)</strong>, while <code>nums<sub>right</sub></code> has all the elements of nums between index <code>i</code> and <code>n - 1</code> <strong>(inclusive)</strong>.</li>
|
||||
<li>If <code>i == 0</code>, <code>nums<sub>left</sub></code> is <strong>empty</strong>, while <code>nums<sub>right</sub></code> has all the elements of <code>nums</code>.</li>
|
||||
<li>If <code>i == n</code>, <code>nums<sub>left</sub></code> has all the elements of nums, while <code>nums<sub>right</sub></code> is <strong>empty</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>division score</strong> of an index <code>i</code> is the <strong>sum</strong> of the number of <code>0</code>'s in <code>nums<sub>left</sub></code> and the number of <code>1</code>'s in <code>nums<sub>right</sub></code>.</p>
|
||||
|
||||
<p>Return <em><strong>all distinct indices</strong> that have the <strong>highest</strong> possible <strong>division score</strong></em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,1,0]
|
||||
<strong>Output:</strong> [2,4]
|
||||
<strong>Explanation:</strong> Division at index
|
||||
- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [0,0,<u><strong>1</strong></u>,0]. The score is 0 + 1 = 1.
|
||||
- 1: nums<sub>left</sub> is [<u><strong>0</strong></u>]. nums<sub>right</sub> is [0,<u><strong>1</strong></u>,0]. The score is 1 + 1 = 2.
|
||||
- 2: nums<sub>left</sub> is [<u><strong>0</strong></u>,<u><strong>0</strong></u>]. nums<sub>right</sub> is [<u><strong>1</strong></u>,0]. The score is 2 + 1 = 3.
|
||||
- 3: nums<sub>left</sub> is [<u><strong>0</strong></u>,<u><strong>0</strong></u>,1]. nums<sub>right</sub> is [0]. The score is 2 + 0 = 2.
|
||||
- 4: nums<sub>left</sub> is [<u><strong>0</strong></u>,<u><strong>0</strong></u>,1,<u><strong>0</strong></u>]. nums<sub>right</sub> is []. The score is 3 + 0 = 3.
|
||||
Indices 2 and 4 both have the highest possible division score 3.
|
||||
Note the answer [4,2] would also be accepted.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,0]
|
||||
<strong>Output:</strong> [3]
|
||||
<strong>Explanation:</strong> Division at index
|
||||
- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [0,0,0]. The score is 0 + 0 = 0.
|
||||
- 1: nums<sub>left</sub> is [<u><strong>0</strong></u>]. nums<sub>right</sub> is [0,0]. The score is 1 + 0 = 1.
|
||||
- 2: nums<sub>left</sub> is [<u><strong>0</strong></u>,<u><strong>0</strong></u>]. nums<sub>right</sub> is [0]. The score is 2 + 0 = 2.
|
||||
- 3: nums<sub>left</sub> is [<u><strong>0</strong></u>,<u><strong>0</strong></u>,<u><strong>0</strong></u>]. nums<sub>right</sub> is []. The score is 3 + 0 = 3.
|
||||
Only index 3 has the highest possible division score 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1]
|
||||
<strong>Output:</strong> [0]
|
||||
<strong>Explanation:</strong> Division at index
|
||||
- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [<u><strong>1</strong></u>,<u><strong>1</strong></u>]. The score is 0 + 2 = 2.
|
||||
- 1: nums<sub>left</sub> is [1]. nums<sub>right</sub> is [<u><strong>1</strong></u>]. The score is 0 + 1 = 1.
|
||||
- 2: nums<sub>left</sub> is [1,1]. nums<sub>right</sub> is []. The score is 0 + 0 = 0.
|
||||
Only index 0 has the highest possible division score 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</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>
|
||||
30
leetcode/problem/all-nodes-distance-k-in-binary-tree.html
Normal file
30
leetcode/problem/all-nodes-distance-k-in-binary-tree.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given the <code>root</code> of a binary tree, the value of a target node <code>target</code>, and an integer <code>k</code>, return <em>an array of the values of all nodes that have a distance </em><code>k</code><em> from the target node.</em></p>
|
||||
|
||||
<p>You can return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/06/28/sketch0.png" style="width: 500px; height: 429px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2
|
||||
<strong>Output:</strong> [7,4,1]
|
||||
Explanation: The nodes that are a distance 2 from the target node (with value 5) have values 7, 4, and 1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1], target = 1, k = 3
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 500]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 500</code></li>
|
||||
<li>All the values <code>Node.val</code> are <strong>unique</strong>.</li>
|
||||
<li><code>target</code> is the value of one of the nodes in the tree.</li>
|
||||
<li><code>0 <= k <= 1000</code></li>
|
||||
</ul>
|
||||
42
leetcode/problem/all-oone-data-structure.html
Normal file
42
leetcode/problem/all-oone-data-structure.html
Normal file
@@ -0,0 +1,42 @@
|
||||
<p>Design a data structure to store the strings' count with the ability to return the strings with minimum and maximum counts.</p>
|
||||
|
||||
<p>Implement the <code>AllOne</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>AllOne()</code> Initializes the object of the data structure.</li>
|
||||
<li><code>inc(String key)</code> Increments the count of the string <code>key</code> by <code>1</code>. If <code>key</code> does not exist in the data structure, insert it with count <code>1</code>.</li>
|
||||
<li><code>dec(String key)</code> Decrements the count of the string <code>key</code> by <code>1</code>. If the count of <code>key</code> is <code>0</code> after the decrement, remove it from the data structure. It is guaranteed that <code>key</code> exists in the data structure before the decrement.</li>
|
||||
<li><code>getMaxKey()</code> Returns one of the keys with the maximal count. If no element exists, return an empty string <code>""</code>.</li>
|
||||
<li><code>getMinKey()</code> Returns one of the keys with the minimum count. If no element exists, return an empty string <code>""</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["AllOne", "inc", "inc", "getMaxKey", "getMinKey", "inc", "getMaxKey", "getMinKey"]
|
||||
[[], ["hello"], ["hello"], [], [], ["leet"], [], []]
|
||||
<strong>Output</strong>
|
||||
[null, null, null, "hello", "hello", null, "hello", "leet"]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
AllOne allOne = new AllOne();
|
||||
allOne.inc("hello");
|
||||
allOne.inc("hello");
|
||||
allOne.getMaxKey(); // return "hello"
|
||||
allOne.getMinKey(); // return "hello"
|
||||
allOne.inc("leet");
|
||||
allOne.getMaxKey(); // return "hello"
|
||||
allOne.getMinKey(); // return "leet"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= key.length <= 10</code></li>
|
||||
<li><code>key</code> consists of lowercase English letters.</li>
|
||||
<li>It is guaranteed that for each call to <code>dec</code>, <code>key</code> is existing in the data structure.</li>
|
||||
<li>At most <code>5 * 10<sup>4</sup></code> calls will be made to <code>inc</code>, <code>dec</code>, <code>getMaxKey</code>, and <code>getMinKey</code>.</li>
|
||||
</ul>
|
||||
31
leetcode/problem/all-paths-from-source-to-target.html
Normal file
31
leetcode/problem/all-paths-from-source-to-target.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given a directed acyclic graph (<strong>DAG</strong>) of <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>, find all possible paths from node <code>0</code> to node <code>n - 1</code> and return them in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The graph is given as follows: <code>graph[i]</code> is a list of all nodes you can visit from node <code>i</code> (i.e., there is a directed edge from node <code>i</code> to node <code>graph[i][j]</code>).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_1.jpg" style="width: 242px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> graph = [[1,2],[3],[3],[]]
|
||||
<strong>Output:</strong> [[0,1,3],[0,2,3]]
|
||||
<strong>Explanation:</strong> There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_2.jpg" style="width: 423px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> graph = [[4,3,1],[3,2,4],[3],[4],[]]
|
||||
<strong>Output:</strong> [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == graph.length</code></li>
|
||||
<li><code>2 <= n <= 15</code></li>
|
||||
<li><code>0 <= graph[i][j] < n</code></li>
|
||||
<li><code>graph[i][j] != i</code> (i.e., there will be no self-loops).</li>
|
||||
<li>All the elements of <code>graph[i]</code> are <strong>unique</strong>.</li>
|
||||
<li>The input graph is <strong>guaranteed</strong> to be a <strong>DAG</strong>.</li>
|
||||
</ul>
|
||||
27
leetcode/problem/all-possible-full-binary-trees.html
Normal file
27
leetcode/problem/all-possible-full-binary-trees.html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>Given an integer <code>n</code>, return <em>a list of all possible <strong>full binary trees</strong> with</em> <code>n</code> <em>nodes</em>. Each node of each tree in the answer must have <code>Node.val == 0</code>.</p>
|
||||
|
||||
<p>Each element of the answer is the root node of one possible tree. You may return the final list of trees in <strong>any order</strong>.</p>
|
||||
|
||||
<p>A <strong>full binary tree</strong> is a binary tree where each node has exactly <code>0</code> or <code>2</code> children.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/08/22/fivetrees.png" style="width: 700px; height: 400px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7
|
||||
<strong>Output:</strong> [[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> [[0,0,0]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 20</code></li>
|
||||
</ul>
|
||||
33
leetcode/problem/allocate-mailboxes.html
Normal file
33
leetcode/problem/allocate-mailboxes.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Given the array <code>houses</code> where <code>houses[i]</code> is the location of the <code>i<sup>th</sup></code> house along a street and an integer <code>k</code>, allocate <code>k</code> mailboxes in the street.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> total distance between each house and its nearest mailbox</em>.</p>
|
||||
|
||||
<p>The test cases are generated so that the answer fits in a 32-bit integer.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/05/07/sample_11_1816.png" style="width: 454px; height: 154px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> houses = [1,4,8,10,20], k = 3
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> Allocate mailboxes in position 3, 9 and 20.
|
||||
Minimum total distance from each houses to nearest mailboxes is |3-1| + |4-3| + |9-8| + |10-9| + |20-20| = 5
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/05/07/sample_2_1816.png" style="width: 433px; height: 154px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> houses = [2,3,5,12,18], k = 2
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Allocate mailboxes in position 3 and 14.
|
||||
Minimum total distance from each houses to nearest mailboxes is |2-3| + |3-3| + |5-3| + |12-14| + |18-14| = 9.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= houses.length <= 100</code></li>
|
||||
<li><code>1 <= houses[i] <= 10<sup>4</sup></code></li>
|
||||
<li>All the integers of <code>houses</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
35
leetcode/problem/alphabet-board-path.html
Normal file
35
leetcode/problem/alphabet-board-path.html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>On an alphabet board, we start at position <code>(0, 0)</code>, corresponding to character <code>board[0][0]</code>.</p>
|
||||
|
||||
<p>Here, <code>board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"]</code>, as shown in the diagram below.</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/07/28/azboard.png" style="width: 250px; height: 317px;" /></p>
|
||||
|
||||
<p>We may make the following moves:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>'U'</code> moves our position up one row, if the position exists on the board;</li>
|
||||
<li><code>'D'</code> moves our position down one row, if the position exists on the board;</li>
|
||||
<li><code>'L'</code> moves our position left one column, if the position exists on the board;</li>
|
||||
<li><code>'R'</code> moves our position right one column, if the position exists on the board;</li>
|
||||
<li><code>'!'</code> adds the character <code>board[r][c]</code> at our current position <code>(r, c)</code> to the answer.</li>
|
||||
</ul>
|
||||
|
||||
<p>(Here, the only positions that exist on the board are positions with letters on them.)</p>
|
||||
|
||||
<p>Return a sequence of moves that makes our answer equal to <code>target</code> in the minimum number of moves. You may return any path that does so.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> target = "leet"
|
||||
<strong>Output:</strong> "DDR!UURRR!!DDD!"
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> target = "code"
|
||||
<strong>Output:</strong> "RR!DDRR!UUL!R!"
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= target.length <= 100</code></li>
|
||||
<li><code>target</code> consists only of English lowercase letters.</li>
|
||||
</ul>
|
||||
43
leetcode/problem/ambiguous-coordinates.html
Normal file
43
leetcode/problem/ambiguous-coordinates.html
Normal file
@@ -0,0 +1,43 @@
|
||||
<p>We had some 2-dimensional coordinates, like <code>"(1, 3)"</code> or <code>"(2, 0.5)"</code>. Then, we removed all commas, decimal points, and spaces and ended up with the string s.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"(1, 3)"</code> becomes <code>s = "(13)"</code> and <code>"(2, 0.5)"</code> becomes <code>s = "(205)"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>a list of strings representing all possibilities for what our original coordinates could have been</em>.</p>
|
||||
|
||||
<p>Our original representation never had extraneous zeroes, so we never started with numbers like <code>"00"</code>, <code>"0.0"</code>, <code>"0.00"</code>, <code>"1.0"</code>, <code>"001"</code>, <code>"00.01"</code>, or any other number that can be represented with fewer digits. Also, a decimal point within a number never occurs without at least one digit occurring before it, so we never started with numbers like <code>".1"</code>.</p>
|
||||
|
||||
<p>The final answer list can be returned in any order. All coordinates in the final answer have exactly one space between them (occurring after the comma.)</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(123)"
|
||||
<strong>Output:</strong> ["(1, 2.3)","(1, 23)","(1.2, 3)","(12, 3)"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(0123)"
|
||||
<strong>Output:</strong> ["(0, 1.23)","(0, 12.3)","(0, 123)","(0.1, 2.3)","(0.1, 23)","(0.12, 3)"]
|
||||
<strong>Explanation:</strong> 0.0, 00, 0001 or 00.01 are not allowed.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(00011)"
|
||||
<strong>Output:</strong> ["(0, 0.011)","(0.001, 1)"]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>4 <= s.length <= 12</code></li>
|
||||
<li><code>s[0] == '('</code> and <code>s[s.length - 1] == ')'</code>.</li>
|
||||
<li>The rest of <code>s</code> are digits.</li>
|
||||
</ul>
|
||||
33
leetcode/problem/angle-between-hands-of-a-clock.html
Normal file
33
leetcode/problem/angle-between-hands-of-a-clock.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Given two numbers, <code>hour</code> and <code>minutes</code>, return <em>the smaller angle (in degrees) formed between the </em><code>hour</code><em> and the </em><code>minute</code><em> hand</em>.</p>
|
||||
|
||||
<p>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>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/26/sample_1_1673.png" style="width: 300px; height: 296px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> hour = 12, minutes = 30
|
||||
<strong>Output:</strong> 165
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/26/sample_2_1673.png" style="width: 300px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> hour = 3, minutes = 30
|
||||
<strong>Output:</strong> 75
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/12/26/sample_3_1673.png" style="width: 300px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> hour = 3, minutes = 15
|
||||
<strong>Output:</strong> 7.5
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= hour <= 12</code></li>
|
||||
<li><code>0 <= minutes <= 59</code></li>
|
||||
</ul>
|
||||
32
leetcode/problem/append-k-integers-with-minimal-sum.html
Normal file
32
leetcode/problem/append-k-integers-with-minimal-sum.html
Normal file
@@ -0,0 +1,32 @@
|
||||
<p>You are given an integer array <code>nums</code> and an integer <code>k</code>. Append <code>k</code> <strong>unique positive</strong> integers that do <strong>not</strong> appear in <code>nums</code> to <code>nums</code> such that the resulting total sum is <strong>minimum</strong>.</p>
|
||||
|
||||
<p>Return<em> the sum of the</em> <code>k</code> <em>integers appended to</em> <code>nums</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,25,10,25], k = 2
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The two unique positive integers that do not appear in nums which we append are 2 and 3.
|
||||
The resulting sum of nums is 1 + 4 + 25 + 10 + 25 + 2 + 3 = 70, which is the minimum.
|
||||
The sum of the two integers appended is 2 + 3 = 5, so we return 5.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,6], k = 6
|
||||
<strong>Output:</strong> 25
|
||||
<strong>Explanation:</strong> The six unique positive integers that do not appear in nums which we append are 1, 2, 3, 4, 7, and 8.
|
||||
The resulting sum of nums is 5 + 6 + 1 + 2 + 3 + 4 + 7 + 8 = 36, which is the minimum.
|
||||
The sum of the six integers appended is 1 + 2 + 3 + 4 + 7 + 8 = 25, so we return 25.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>8</sup></code></li>
|
||||
</ul>
|
||||
58
leetcode/problem/apply-discount-every-n-orders.html
Normal file
58
leetcode/problem/apply-discount-every-n-orders.html
Normal file
@@ -0,0 +1,58 @@
|
||||
<p>There is a supermarket that is frequented by many customers. The products sold at the supermarket are represented as two parallel integer arrays <code>products</code> and <code>prices</code>, where the <code>i<sup>th</sup></code> product has an ID of <code>products[i]</code> and a price of <code>prices[i]</code>.</p>
|
||||
|
||||
<p>When a customer is paying, their bill is represented as two parallel integer arrays <code>product</code> and <code>amount</code>, where the <code>j<sup>th</sup></code> product they purchased has an ID of <code>product[j]</code>, and <code>amount[j]</code> is how much of the product they bought. Their subtotal is calculated as the sum of each <code>amount[j] * (price of the j<sup>th</sup> product)</code>.</p>
|
||||
|
||||
<p>The supermarket decided to have a sale. Every <code>n<sup>th</sup></code> customer paying for their groceries will be given a <strong>percentage discount</strong>. The discount amount is given by <code>discount</code>, where they will be given <code>discount</code> percent off their subtotal. More formally, if their subtotal is <code>bill</code>, then they would actually pay <code>bill * ((100 - discount) / 100)</code>.</p>
|
||||
|
||||
<p>Implement the <code>Cashier</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Cashier(int n, int discount, int[] products, int[] prices)</code> Initializes the object with <code>n</code>, the <code>discount</code>, and the <code>products</code> and their <code>prices</code>.</li>
|
||||
<li><code>double getBill(int[] product, int[] amount)</code> Returns the final total of the bill with the discount applied (if any). Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["Cashier","getBill","getBill","getBill","getBill","getBill","getBill","getBill"]
|
||||
[[3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]],[[1,2],[1,2]],[[3,7],[10,10]],[[1,2,3,4,5,6,7],[1,1,1,1,1,1,1]],[[4],[10]],[[7,3],[10,10]],[[7,5,3,1,6,4,2],[10,10,10,9,9,9,7]],[[2,3,5],[5,3,2]]]
|
||||
<strong>Output</strong>
|
||||
[null,500.0,4000.0,800.0,4000.0,4000.0,7350.0,2500.0]
|
||||
<strong>Explanation</strong>
|
||||
Cashier cashier = new Cashier(3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]);
|
||||
cashier.getBill([1,2],[1,2]); // return 500.0. 1<sup>st</sup> customer, no discount.
|
||||
// bill = 1 * 100 + 2 * 200 = 500.
|
||||
cashier.getBill([3,7],[10,10]); // return 4000.0. 2<sup>nd</sup> customer, no discount.
|
||||
// bill = 10 * 300 + 10 * 100 = 4000.
|
||||
cashier.getBill([1,2,3,4,5,6,7],[1,1,1,1,1,1,1]); // return 800.0. 3<sup>rd</sup> customer, 50% discount.
|
||||
// Original bill = 1600
|
||||
// Actual bill = 1600 * ((100 - 50) / 100) = 800.
|
||||
cashier.getBill([4],[10]); // return 4000.0. 4<sup>th</sup> customer, no discount.
|
||||
cashier.getBill([7,3],[10,10]); // return 4000.0. 5<sup>th</sup> customer, no discount.
|
||||
cashier.getBill([7,5,3,1,6,4,2],[10,10,10,9,9,9,7]); // return 7350.0. 6<sup>th</sup> customer, 50% discount.
|
||||
// Original bill = 14700, but with
|
||||
// Actual bill = 14700 * ((100 - 50) / 100) = 7350.
|
||||
cashier.getBill([2,3,5],[5,3,2]); // return 2500.0. 6<sup>th</sup> customer, no discount.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= discount <= 100</code></li>
|
||||
<li><code>1 <= products.length <= 200</code></li>
|
||||
<li><code>prices.length == products.length</code></li>
|
||||
<li><code>1 <= products[i] <= 200</code></li>
|
||||
<li><code>1 <= prices[i] <= 1000</code></li>
|
||||
<li>The elements in <code>products</code> are <strong>unique</strong>.</li>
|
||||
<li><code>1 <= product.length <= products.length</code></li>
|
||||
<li><code>amount.length == product.length</code></li>
|
||||
<li><code>product[j]</code> exists in <code>products</code>.</li>
|
||||
<li><code>1 <= amount[j] <= 1000</code></li>
|
||||
<li>The elements of <code>product</code> are <strong>unique</strong>.</li>
|
||||
<li>At most <code>1000</code> calls will be made to <code>getBill</code>.</li>
|
||||
<li>Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</li>
|
||||
</ul>
|
||||
48
leetcode/problem/arithmetic-slices-ii-subsequence.html
Normal file
48
leetcode/problem/arithmetic-slices-ii-subsequence.html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>Given an integer array <code>nums</code>, return <em>the number of all the <strong>arithmetic subsequences</strong> of</em> <code>nums</code>.</p>
|
||||
|
||||
<p>A sequence of numbers is called arithmetic if it consists of <strong>at least three elements</strong> and if the difference between any two consecutive elements is the same.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>[1, 3, 5, 7, 9]</code>, <code>[7, 7, 7, 7]</code>, and <code>[3, -1, -5, -9]</code> are arithmetic sequences.</li>
|
||||
<li>For example, <code>[1, 1, 2, 5, 7]</code> is not an arithmetic sequence.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>subsequence</strong> of an array is a sequence that can be formed by removing some elements (possibly none) of the array.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>[2,5,10]</code> is a subsequence of <code>[1,2,1,<strong><u>2</u></strong>,4,1,<u><strong>5</strong></u>,<u><strong>10</strong></u>]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The test cases are generated so that the answer fits in <strong>32-bit</strong> integer.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,4,6,8,10]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> All arithmetic subsequence slices are:
|
||||
[2,4,6]
|
||||
[4,6,8]
|
||||
[6,8,10]
|
||||
[2,4,6,8]
|
||||
[4,6,8,10]
|
||||
[2,4,6,8,10]
|
||||
[2,6,10]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [7,7,7,7,7]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> Any subsequence of this array is arithmetic.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
33
leetcode/problem/arithmetic-slices.html
Normal file
33
leetcode/problem/arithmetic-slices.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>An integer array is called arithmetic if it consists of <strong>at least three elements</strong> and if the difference between any two consecutive elements is the same.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>[1,3,5,7,9]</code>, <code>[7,7,7,7]</code>, and <code>[3,-1,-5,-9]</code> are arithmetic sequences.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer array <code>nums</code>, return <em>the number of arithmetic <strong>subarrays</strong> of</em> <code>nums</code>.</p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous subsequence of the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 5000</code></li>
|
||||
<li><code>-1000 <= nums[i] <= 1000</code></li>
|
||||
</ul>
|
||||
48
leetcode/problem/arithmetic-subarrays.html
Normal file
48
leetcode/problem/arithmetic-subarrays.html
Normal file
@@ -0,0 +1,48 @@
|
||||
<p>A sequence of numbers is called <strong>arithmetic</strong> if it consists of at least two elements, and the difference between every two consecutive elements is the same. More formally, a sequence <code>s</code> is arithmetic if and only if <code>s[i+1] - s[i] == s[1] - s[0] </code>for all valid <code>i</code>.</p>
|
||||
|
||||
<p>For example, these are <strong>arithmetic</strong> sequences:</p>
|
||||
|
||||
<pre>
|
||||
1, 3, 5, 7, 9
|
||||
7, 7, 7, 7
|
||||
3, -1, -5, -9</pre>
|
||||
|
||||
<p>The following sequence is not <strong>arithmetic</strong>:</p>
|
||||
|
||||
<pre>
|
||||
1, 1, 2, 5, 7</pre>
|
||||
|
||||
<p>You are given an array of <code>n</code> integers, <code>nums</code>, and two arrays of <code>m</code> integers each, <code>l</code> and <code>r</code>, representing the <code>m</code> range queries, where the <code>i<sup>th</sup></code> query is the range <code>[l[i], r[i]]</code>. All the arrays are <strong>0-indexed</strong>.</p>
|
||||
|
||||
<p>Return <em>a list of </em><code>boolean</code> <em>elements</em> <code>answer</code><em>, where</em> <code>answer[i]</code> <em>is</em> <code>true</code> <em>if the subarray</em> <code>nums[l[i]], nums[l[i]+1], ... , nums[r[i]]</code><em> can be <strong>rearranged</strong> to form an <strong>arithmetic</strong> sequence, and</em> <code>false</code> <em>otherwise.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = <code>[4,6,5,9,3,7]</code>, l = <code>[0,0,2]</code>, r = <code>[2,3,5]</code>
|
||||
<strong>Output:</strong> <code>[true,false,true]</code>
|
||||
<strong>Explanation:</strong>
|
||||
In the 0<sup>th</sup> query, the subarray is [4,6,5]. This can be rearranged as [6,5,4], which is an arithmetic sequence.
|
||||
In the 1<sup>st</sup> query, the subarray is [4,6,5,9]. This cannot be rearranged as an arithmetic sequence.
|
||||
In the 2<sup>nd</sup> query, the subarray is <code>[5,9,3,7]. This</code> can be rearranged as <code>[3,5,7,9]</code>, which is an arithmetic sequence.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-12,-9,-3,-12,-6,15,20,-25,-20,-15,-10], l = [0,1,6,4,8,7], r = [4,4,9,7,9,10]
|
||||
<strong>Output:</strong> [false,true,false,false,true,true]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>m == l.length</code></li>
|
||||
<li><code>m == r.length</code></li>
|
||||
<li><code>2 <= n <= 500</code></li>
|
||||
<li><code>1 <= m <= 500</code></li>
|
||||
<li><code>0 <= l[i] < r[i] < n</code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
27
leetcode/problem/arranging-coins.html
Normal file
27
leetcode/problem/arranging-coins.html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>You have <code>n</code> coins and you want to build a staircase with these coins. The staircase consists of <code>k</code> rows where the <code>i<sup>th</sup></code> row has exactly <code>i</code> coins. The last row of the staircase <strong>may be</strong> incomplete.</p>
|
||||
|
||||
<p>Given the integer <code>n</code>, return <em>the number of <strong>complete rows</strong> of the staircase you will build</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/arrangecoins1-grid.jpg" style="width: 253px; height: 253px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Because the 3<sup>rd</sup> row is incomplete, we return 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/arrangecoins2-grid.jpg" style="width: 333px; height: 333px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 8
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Because the 4<sup>th</sup> row is incomplete, we return 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/array-nesting.html
Normal file
39
leetcode/problem/array-nesting.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>You are given an integer array <code>nums</code> of length <code>n</code> where <code>nums</code> is a permutation of the numbers in the range <code>[0, n - 1]</code>.</p>
|
||||
|
||||
<p>You should build a set <code>s[k] = {nums[k], nums[nums[k]], nums[nums[nums[k]]], ... }</code> subjected to the following rule:</p>
|
||||
|
||||
<ul>
|
||||
<li>The first element in <code>s[k]</code> starts with the selection of the element <code>nums[k]</code> of <code>index = k</code>.</li>
|
||||
<li>The next element in <code>s[k]</code> should be <code>nums[nums[k]]</code>, and then <code>nums[nums[nums[k]]]</code>, and so on.</li>
|
||||
<li>We stop adding right before a duplicate element occurs in <code>s[k]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the longest length of a set</em> <code>s[k]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,4,0,3,1,6,2]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong>
|
||||
nums[0] = 5, nums[1] = 4, nums[2] = 0, nums[3] = 3, nums[4] = 1, nums[5] = 6, nums[6] = 2.
|
||||
One of the longest sets s[k]:
|
||||
s[0] = {nums[0], nums[5], nums[6], nums[2]} = {5, 6, 2, 0}
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1,2]
|
||||
<strong>Output:</strong> 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] < nums.length</code></li>
|
||||
<li>All the values of <code>nums</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
33
leetcode/problem/array-of-doubled-pairs.html
Normal file
33
leetcode/problem/array-of-doubled-pairs.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Given an integer array of even length <code>arr</code>, return <code>true</code><em> if it is possible to reorder </em><code>arr</code><em> such that </em><code>arr[2 * i + 1] = 2 * arr[2 * i]</code><em> for every </em><code>0 <= i < len(arr) / 2</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [3,1,3,6]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [2,1,2,6]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [4,-2,2,-4]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> We can take two groups, [-2,-4] and [2,4] to form [-2,-4,2,4] or [2,4,-2,-4].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= arr.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>arr.length</code> is even.</li>
|
||||
<li><code>-10<sup>5</sup> <= arr[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
30
leetcode/problem/array-partition-i.html
Normal file
30
leetcode/problem/array-partition-i.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an integer array <code>nums</code> of <code>2n</code> integers, group these integers into <code>n</code> pairs <code>(a<sub>1</sub>, b<sub>1</sub>), (a<sub>2</sub>, b<sub>2</sub>), ..., (a<sub>n</sub>, b<sub>n</sub>)</code> such that the sum of <code>min(a<sub>i</sub>, b<sub>i</sub>)</code> for all <code>i</code> is <strong>maximized</strong>. Return<em> the maximized sum</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,3,2]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> All possible pairings (ignoring the ordering of elements) are:
|
||||
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
|
||||
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
|
||||
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
|
||||
So the maximum possible sum is 4.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [6,2,6,5,1,2]
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>nums.length == 2 * n</code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of <strong>distinct</strong> integers. You want to rearrange the elements in the array such that every element in the rearranged array is <strong>not</strong> equal to the <strong>average</strong> of its neighbors.</p>
|
||||
|
||||
<p>More formally, the rearranged array should have the property such that for every <code>i</code> in the range <code>1 <= i < nums.length - 1</code>, <code>(nums[i-1] + nums[i+1]) / 2</code> is <strong>not</strong> equal to <code>nums[i]</code>.</p>
|
||||
|
||||
<p>Return <em><strong>any</strong> rearrangement of </em><code>nums</code><em> that meets the requirements</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5]
|
||||
<strong>Output:</strong> [1,2,4,5,3]
|
||||
<strong>Explanation:</strong>
|
||||
When i=1, nums[i] = 2, and the average of its neighbors is (1+4) / 2 = 2.5.
|
||||
When i=2, nums[i] = 4, and the average of its neighbors is (2+5) / 2 = 3.5.
|
||||
When i=3, nums[i] = 5, and the average of its neighbors is (4+3) / 2 = 3.5.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [6,2,0,9,7]
|
||||
<strong>Output:</strong> [9,7,6,2,0]
|
||||
<strong>Explanation:</strong>
|
||||
When i=1, nums[i] = 7, and the average of its neighbors is (9+6) / 2 = 7.5.
|
||||
When i=2, nums[i] = 6, and the average of its neighbors is (7+2) / 2 = 4.5.
|
||||
When i=3, nums[i] = 2, and the average of its neighbors is (6+0) / 2 = 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
49
leetcode/problem/article-views-i.html
Normal file
49
leetcode/problem/article-views-i.html
Normal file
@@ -0,0 +1,49 @@
|
||||
<p>Table: <code>Views</code></p>
|
||||
|
||||
<pre>
|
||||
+---------------+---------+
|
||||
| Column Name | Type |
|
||||
+---------------+---------+
|
||||
| article_id | int |
|
||||
| author_id | int |
|
||||
| viewer_id | int |
|
||||
| view_date | date |
|
||||
+---------------+---------+
|
||||
There is no primary key for this table, it may have duplicate rows.
|
||||
Each row of this table indicates that some viewer viewed an article (written by some author) on some date.
|
||||
Note that equal author_id and viewer_id indicate the same person.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to find all the authors that viewed at least one of their own articles.</p>
|
||||
|
||||
<p>Return the result table sorted by <code>id</code> in ascending order.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Views table:
|
||||
+------------+-----------+-----------+------------+
|
||||
| article_id | author_id | viewer_id | view_date |
|
||||
+------------+-----------+-----------+------------+
|
||||
| 1 | 3 | 5 | 2019-08-01 |
|
||||
| 1 | 3 | 6 | 2019-08-02 |
|
||||
| 2 | 7 | 7 | 2019-08-01 |
|
||||
| 2 | 7 | 6 | 2019-08-02 |
|
||||
| 4 | 7 | 1 | 2019-07-22 |
|
||||
| 3 | 4 | 4 | 2019-07-21 |
|
||||
| 3 | 4 | 4 | 2019-07-21 |
|
||||
+------------+-----------+-----------+------------+
|
||||
<strong>Output:</strong>
|
||||
+------+
|
||||
| id |
|
||||
+------+
|
||||
| 4 |
|
||||
| 7 |
|
||||
+------+
|
||||
</pre>
|
||||
30
leetcode/problem/as-far-from-land-as-possible.html
Normal file
30
leetcode/problem/as-far-from-land-as-possible.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an <code>n x n</code> <code>grid</code> containing only values <code>0</code> and <code>1</code>, where <code>0</code> represents water and <code>1</code> represents land, find a water cell such that its distance to the nearest land cell is maximized, and return the distance. If no land or water exists in the grid, return <code>-1</code>.</p>
|
||||
|
||||
<p>The distance used in this problem is the Manhattan distance: the distance between two cells <code>(x0, y0)</code> and <code>(x1, y1)</code> is <code>|x0 - x1| + |y0 - y1|</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/05/03/1336_ex1.JPG" style="width: 185px; height: 87px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,0,1],[0,0,0],[1,0,1]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The cell (1, 1) is as far as possible from all the land with distance 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/05/03/1336_ex2.JPG" style="width: 184px; height: 87px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,0,0],[0,0,0],[0,0,0]]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The cell (2, 2) is as far as possible from all the land with distance 4.
|
||||
</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]</code> is <code>0</code> or <code>1</code></li>
|
||||
</ul>
|
||||
33
leetcode/problem/assign-cookies.html
Normal file
33
leetcode/problem/assign-cookies.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie.</p>
|
||||
|
||||
<p>Each child <code>i</code> has a greed factor <code>g[i]</code>, which is the minimum size of a cookie that the child will be content with; and each cookie <code>j</code> has a size <code>s[j]</code>. If <code>s[j] >= g[i]</code>, we can assign the cookie <code>j</code> to the child <code>i</code>, and the child <code>i</code> will be content. Your goal is to maximize the number of your content children and output the maximum number.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> g = [1,2,3], s = [1,1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3.
|
||||
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
|
||||
You need to output 1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> g = [1,2], s = [1,2,3]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
|
||||
You have 3 cookies and their sizes are big enough to gratify all of the children,
|
||||
You need to output 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= g.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= s.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= g[i], s[j] <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/asteroid-collision.html
Normal file
39
leetcode/problem/asteroid-collision.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>We are given an array <code>asteroids</code> of integers representing asteroids in a row.</p>
|
||||
|
||||
<p>For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.</p>
|
||||
|
||||
<p>Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> asteroids = [5,10,-5]
|
||||
<strong>Output:</strong> [5,10]
|
||||
<strong>Explanation:</strong> The 10 and -5 collide resulting in 10. The 5 and 10 never collide.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> asteroids = [8,-8]
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> The 8 and -8 collide exploding each other.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> asteroids = [10,2,-5]
|
||||
<strong>Output:</strong> [10]
|
||||
<strong>Explanation:</strong> The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= asteroids.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-1000 <= asteroids[i] <= 1000</code></li>
|
||||
<li><code>asteroids[i] != 0</code></li>
|
||||
</ul>
|
||||
40
leetcode/problem/available-captures-for-rook.html
Normal file
40
leetcode/problem/available-captures-for-rook.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>On an <code>8 x 8</code> chessboard, there is <strong>exactly one</strong> white rook <code>'R'</code> and some number of white bishops <code>'B'</code>, black pawns <code>'p'</code>, and empty squares <code>'.'</code>.</p>
|
||||
|
||||
<p>When the rook moves, it chooses one of four cardinal directions (north, east, south, or west), then moves in that direction until it chooses to stop, reaches the edge of the board, captures a black pawn, or is blocked by a white bishop. A rook is considered <strong>attacking</strong> a pawn if the rook can capture the pawn on the rook's turn. The <strong>number of available captures</strong> for the white rook is the number of pawns that the rook is <strong>attacking</strong>.</p>
|
||||
|
||||
<p>Return <em>the <strong>number of available captures</strong> for the white rook</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/02/20/1253_example_1_improved.PNG" style="width: 300px; height: 305px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> board = [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> In this example, the rook is attacking all the pawns.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/02/19/1253_example_2_improved.PNG" style="width: 300px; height: 306px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> board = [[".",".",".",".",".",".",".","."],[".","p","p","p","p","p",".","."],[".","p","p","B","p","p",".","."],[".","p","B","R","B","p",".","."],[".","p","p","B","p","p",".","."],[".","p","p","p","p","p",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The bishops are blocking the rook from attacking any of the pawns.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/02/20/1253_example_3_improved.PNG" style="width: 300px; height: 305px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> board = [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","p",".",".",".","."],["p","p",".","R",".","p","B","."],[".",".",".",".",".",".",".","."],[".",".",".","B",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The rook is attacking the pawns at positions b5, d6, and f5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>board.length == 8</code></li>
|
||||
<li><code>board[i].length == 8</code></li>
|
||||
<li><code>board[i][j]</code> is either <code>'R'</code>, <code>'.'</code>, <code>'B'</code>, or <code>'p'</code></li>
|
||||
<li>There is exactly one cell with <code>board[i][j] == 'R'</code></li>
|
||||
</ul>
|
||||
25
leetcode/problem/average-of-levels-in-binary-tree.html
Normal file
25
leetcode/problem/average-of-levels-in-binary-tree.html
Normal file
@@ -0,0 +1,25 @@
|
||||
Given the <code>root</code> of a binary tree, return <em>the average value of the nodes on each level in the form of an array</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [3.00000,14.50000,11.00000]
|
||||
Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
|
||||
Hence return [3, 14.5, 11].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg" style="width: 292px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,15,7]
|
||||
<strong>Output:</strong> [3.00000,14.50000,11.00000]
|
||||
</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>4</sup>]</code>.</li>
|
||||
<li><code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code></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>
|
||||
45
leetcode/problem/average-waiting-time.html
Normal file
45
leetcode/problem/average-waiting-time.html
Normal file
@@ -0,0 +1,45 @@
|
||||
<p>There is a restaurant with a single chef. You are given an array <code>customers</code>, where <code>customers[i] = [arrival<sub>i</sub>, time<sub>i</sub>]:</code></p>
|
||||
|
||||
<ul>
|
||||
<li><code>arrival<sub>i</sub></code> is the arrival time of the <code>i<sup>th</sup></code> customer. The arrival times are sorted in <strong>non-decreasing</strong> order.</li>
|
||||
<li><code>time<sub>i</sub></code> is the time needed to prepare the order of the <code>i<sup>th</sup></code> customer.</li>
|
||||
</ul>
|
||||
|
||||
<p>When a customer arrives, he gives the chef his order, and the chef starts preparing it once he is idle. The customer waits till the chef finishes preparing his order. The chef does not prepare food for more than one customer at a time. The chef prepares food for customers <strong>in the order they were given in the input</strong>.</p>
|
||||
|
||||
<p>Return <em>the <strong>average</strong> waiting time of all customers</em>. Solutions within <code>10<sup>-5</sup></code> from the actual answer are considered accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> customers = [[1,2],[2,5],[4,3]]
|
||||
<strong>Output:</strong> 5.00000
|
||||
<strong>Explanation:
|
||||
</strong>1) The first customer arrives at time 1, the chef takes his order and starts preparing it immediately at time 1, and finishes at time 3, so the waiting time of the first customer is 3 - 1 = 2.
|
||||
2) The second customer arrives at time 2, the chef takes his order and starts preparing it at time 3, and finishes at time 8, so the waiting time of the second customer is 8 - 2 = 6.
|
||||
3) The third customer arrives at time 4, the chef takes his order and starts preparing it at time 8, and finishes at time 11, so the waiting time of the third customer is 11 - 4 = 7.
|
||||
So the average waiting time = (2 + 6 + 7) / 3 = 5.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> customers = [[5,2],[5,4],[10,3],[20,1]]
|
||||
<strong>Output:</strong> 3.25000
|
||||
<strong>Explanation:
|
||||
</strong>1) The first customer arrives at time 5, the chef takes his order and starts preparing it immediately at time 5, and finishes at time 7, so the waiting time of the first customer is 7 - 5 = 2.
|
||||
2) The second customer arrives at time 5, the chef takes his order and starts preparing it at time 7, and finishes at time 11, so the waiting time of the second customer is 11 - 5 = 6.
|
||||
3) The third customer arrives at time 10, the chef takes his order and starts preparing it at time 11, and finishes at time 14, so the waiting time of the third customer is 14 - 10 = 4.
|
||||
4) The fourth customer arrives at time 20, the chef takes his order and starts preparing it immediately at time 20, and finishes at time 21, so the waiting time of the fourth customer is 21 - 20 = 1.
|
||||
So the average waiting time = (2 + 6 + 4 + 1) / 4 = 3.25.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= customers.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= arrival<sub>i</sub>, time<sub>i</sub> <= 10<sup>4</sup></code></li>
|
||||
<li><code>arrival<sub>i </sub><= arrival<sub>i+1</sub></code></li>
|
||||
</ul>
|
||||
64
leetcode/problem/avoid-flood-in-the-city.html
Normal file
64
leetcode/problem/avoid-flood-in-the-city.html
Normal file
@@ -0,0 +1,64 @@
|
||||
<p>Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the <code>nth</code> lake, the <code>nth</code> lake becomes full of water. If it rains over a lake which is <strong>full of water</strong>, there will be a <strong>flood</strong>. Your goal is to avoid the flood in any lake.</p>
|
||||
|
||||
<p>Given an integer array <code>rains</code> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>rains[i] > 0</code> means there will be rains over the <code>rains[i]</code> lake.</li>
|
||||
<li><code>rains[i] == 0</code> means there are no rains this day and you can choose <strong>one lake</strong> this day and <strong>dry it</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array <code>ans</code></em> where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>ans.length == rains.length</code></li>
|
||||
<li><code>ans[i] == -1</code> if <code>rains[i] > 0</code>.</li>
|
||||
<li><code>ans[i]</code> is the lake you choose to dry in the <code>ith</code> day if <code>rains[i] == 0</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>If there are multiple valid answers return <strong>any</strong> of them. If it is impossible to avoid flood return <strong>an empty array</strong>.</p>
|
||||
|
||||
<p>Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes. (see example 4)</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rains = [1,2,3,4]
|
||||
<strong>Output:</strong> [-1,-1,-1,-1]
|
||||
<strong>Explanation:</strong> After the first day full lakes are [1]
|
||||
After the second day full lakes are [1,2]
|
||||
After the third day full lakes are [1,2,3]
|
||||
After the fourth day full lakes are [1,2,3,4]
|
||||
There's no day to dry any lake and there is no flood in any lake.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rains = [1,2,0,0,2,1]
|
||||
<strong>Output:</strong> [-1,-1,2,1,-1,-1]
|
||||
<strong>Explanation:</strong> After the first day full lakes are [1]
|
||||
After the second day full lakes are [1,2]
|
||||
After the third day, we dry lake 2. Full lakes are [1]
|
||||
After the fourth day, we dry lake 1. There is no full lakes.
|
||||
After the fifth day, full lakes are [2].
|
||||
After the sixth day, full lakes are [1,2].
|
||||
It is easy that this scenario is flood-free. [-1,-1,1,2,-1,-1] is another acceptable scenario.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> rains = [1,2,0,1,2]
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> After the second day, full lakes are [1,2]. We have to dry one lake in the third day.
|
||||
After that, it will rain over lakes [1,2]. It's easy to prove that no matter which lake you choose to dry in the 3rd day, the other one will flood.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= rains.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= rains[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/backspace-string-compare.html
Normal file
39
leetcode/problem/backspace-string-compare.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code> <em>if they are equal when both are typed into empty text editors</em>. <code>'#'</code> means a backspace character.</p>
|
||||
|
||||
<p>Note that after backspacing an empty text, the text will continue empty.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ab#c", t = "ad#c"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Both s and t become "ac".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ab##", t = "c#d#"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Both s and t become "".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "a#c", t = "b"
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> s becomes "c" while t becomes "b".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code><span>1 <= s.length, t.length <= 200</span></code></li>
|
||||
<li><span><code>s</code> and <code>t</code> only contain lowercase letters and <code>'#'</code> characters.</span></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Can you solve it in <code>O(n)</code> time and <code>O(1)</code> space?</p>
|
||||
50
leetcode/problem/bag-of-tokens.html
Normal file
50
leetcode/problem/bag-of-tokens.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>You have an initial <strong>power</strong> of <code>power</code>, an initial <strong>score</strong> of <code>0</code>, and a bag of <code>tokens</code> where <code>tokens[i]</code> is the value of the <code>i<sup>th</sup></code> token (0-indexed).</p>
|
||||
|
||||
<p>Your goal is to maximize your total <strong>score</strong> by potentially playing each token in one of two ways:</p>
|
||||
|
||||
<ul>
|
||||
<li>If your current <strong>power</strong> is at least <code>tokens[i]</code>, you may play the <code>i<sup>th</sup></code> token face up, losing <code>tokens[i]</code> <strong>power</strong> and gaining <code>1</code> <strong>score</strong>.</li>
|
||||
<li>If your current <strong>score</strong> is at least <code>1</code>, you may play the <code>i<sup>th</sup></code> token face down, gaining <code>tokens[i]</code> <strong>power</strong> and losing <code>1</code> <strong>score</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Each token may be played <strong>at most</strong> once and <strong>in any order</strong>. You do <strong>not</strong> have to play all the tokens.</p>
|
||||
|
||||
<p>Return <em>the largest possible <strong>score</strong> you can achieve after playing any number of tokens</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tokens = [100], power = 50
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation</strong><strong>:</strong> Playing the only token in the bag is impossible because you either have too little power or too little score.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tokens = [100,200], power = 150
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Play the 0<sup>th</sup> token (100) face up, your power becomes 50 and score becomes 1.
|
||||
There is no need to play the 1<sup>st</sup> token since you cannot play it face up to add to your score.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> tokens = [100,200,300,400], power = 200
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Play the tokens in this order to get a score of 2:
|
||||
1. Play the 0<sup>th</sup> token (100) face up, your power becomes 100 and score becomes 1.
|
||||
2. Play the 3<sup>rd</sup> token (400) face down, your power becomes 500 and score becomes 0.
|
||||
3. Play the 1<sup>st</sup> token (200) face up, your power becomes 300 and score becomes 1.
|
||||
4. Play the 2<sup>nd </sup>token (300) face up, your power becomes 0 and score becomes 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= tokens.length <= 1000</code></li>
|
||||
<li><code>0 <= tokens[i], power < 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
27
leetcode/problem/balance-a-binary-search-tree.html
Normal file
27
leetcode/problem/balance-a-binary-search-tree.html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>Given the <code>root</code> of a binary search tree, return <em>a <strong>balanced</strong> binary search tree with the same node values</em>. If there is more than one answer, return <strong>any of them</strong>.</p>
|
||||
|
||||
<p>A binary search tree is <strong>balanced</strong> if the depth of the two subtrees of every node never differs by more than <code>1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balance1-tree.jpg" style="width: 500px; height: 319px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,null,3,null,4,null,null]
|
||||
<strong>Output:</strong> [2,1,3,null,null,null,4]
|
||||
<b>Explanation:</b> This is not the only correct answer, [3,1,4,null,2] is also correct.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balanced2-tree.jpg" style="width: 224px; height: 145px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,1,3]
|
||||
<strong>Output:</strong> [2,1,3]
|
||||
</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>4</sup>]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/balanced-binary-tree.html
Normal file
37
leetcode/problem/balanced-binary-tree.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given a binary tree, determine if it is height-balanced.</p>
|
||||
|
||||
<p>For this problem, a height-balanced binary tree is defined as:</p>
|
||||
|
||||
<blockquote>
|
||||
<p>a binary tree in which the left and right subtrees of <em>every</em> node differ in height by no more than 1.</p>
|
||||
</blockquote>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg" style="width: 342px; height: 221px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg" style="width: 452px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,2,3,3,null,null,4,4]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 5000]</code>.</li>
|
||||
<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
76
leetcode/problem/bank-account-summary-ii.html
Normal file
76
leetcode/problem/bank-account-summary-ii.html
Normal file
@@ -0,0 +1,76 @@
|
||||
<p>Table: <code>Users</code></p>
|
||||
|
||||
<pre>
|
||||
+--------------+---------+
|
||||
| Column Name | Type |
|
||||
+--------------+---------+
|
||||
| account | int |
|
||||
| name | varchar |
|
||||
+--------------+---------+
|
||||
account is the primary key for this table.
|
||||
Each row of this table contains the account number of each user in the bank.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Table: <code>Transactions</code></p>
|
||||
|
||||
<pre>
|
||||
+---------------+---------+
|
||||
| Column Name | Type |
|
||||
+---------------+---------+
|
||||
| trans_id | int |
|
||||
| account | int |
|
||||
| amount | int |
|
||||
| transacted_on | date |
|
||||
+---------------+---------+
|
||||
trans_id is the primary key for this table.
|
||||
Each row of this table contains all changes made to all accounts.
|
||||
amount is positive if the user received money and negative if they transferred money.
|
||||
All accounts start with a balance of 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to report the name and balance of users with a balance higher than <code>10000</code>. The balance of an account is equal to the sum of the amounts of all transactions involving that account.</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Users table:
|
||||
+------------+--------------+
|
||||
| account | name |
|
||||
+------------+--------------+
|
||||
| 900001 | Alice |
|
||||
| 900002 | Bob |
|
||||
| 900003 | Charlie |
|
||||
+------------+--------------+
|
||||
Transactions table:
|
||||
+------------+------------+------------+---------------+
|
||||
| trans_id | account | amount | transacted_on |
|
||||
+------------+------------+------------+---------------+
|
||||
| 1 | 900001 | 7000 | 2020-08-01 |
|
||||
| 2 | 900001 | 7000 | 2020-09-01 |
|
||||
| 3 | 900001 | -3000 | 2020-09-02 |
|
||||
| 4 | 900002 | 1000 | 2020-09-12 |
|
||||
| 5 | 900003 | 6000 | 2020-08-07 |
|
||||
| 6 | 900003 | 6000 | 2020-09-07 |
|
||||
| 7 | 900003 | -4000 | 2020-09-11 |
|
||||
+------------+------------+------------+---------------+
|
||||
<strong>Output:</strong>
|
||||
+------------+------------+
|
||||
| name | balance |
|
||||
+------------+------------+
|
||||
| Alice | 11000 |
|
||||
+------------+------------+
|
||||
<strong>Explanation:</strong>
|
||||
Alice's balance is (7000 + 7000 - 3000) = 11000.
|
||||
Bob's balance is 1000.
|
||||
Charlie's balance is (6000 + 6000 - 4000) = 8000.
|
||||
</pre>
|
||||
16
leetcode/problem/base-7.html
Normal file
16
leetcode/problem/base-7.html
Normal file
@@ -0,0 +1,16 @@
|
||||
<p>Given an integer <code>num</code>, return <em>a string of its <strong>base 7</strong> representation</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> num = 100
|
||||
<strong>Output:</strong> "202"
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> num = -7
|
||||
<strong>Output:</strong> "-10"
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-10<sup>7</sup> <= num <= 10<sup>7</sup></code></li>
|
||||
</ul>
|
||||
61
leetcode/problem/baseball-game.html
Normal file
61
leetcode/problem/baseball-game.html
Normal file
@@ -0,0 +1,61 @@
|
||||
<p>You are keeping score for a baseball game with strange rules. The game consists of several rounds, where the scores of past rounds may affect future rounds' scores.</p>
|
||||
|
||||
<p>At the beginning of the game, you start with an empty record. You are given a list of strings <code>ops</code>, where <code>ops[i]</code> is the <code>i<sup>th</sup></code> operation you must apply to the record and is one of the following:</p>
|
||||
|
||||
<ol>
|
||||
<li>An integer <code>x</code> - Record a new score of <code>x</code>.</li>
|
||||
<li><code>"+"</code> - Record a new score that is the sum of the previous two scores. It is guaranteed there will always be two previous scores.</li>
|
||||
<li><code>"D"</code> - Record a new score that is double the previous score. It is guaranteed there will always be a previous score.</li>
|
||||
<li><code>"C"</code> - Invalidate the previous score, removing it from the record. It is guaranteed there will always be a previous score.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>the sum of all the scores on the record</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> ops = ["5","2","C","D","+"]
|
||||
<strong>Output:</strong> 30
|
||||
<strong>Explanation:</strong>
|
||||
"5" - Add 5 to the record, record is now [5].
|
||||
"2" - Add 2 to the record, record is now [5, 2].
|
||||
"C" - Invalidate and remove the previous score, record is now [5].
|
||||
"D" - Add 2 * 5 = 10 to the record, record is now [5, 10].
|
||||
"+" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15].
|
||||
The total sum is 5 + 10 + 15 = 30.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> ops = ["5","-2","4","C","D","9","+","+"]
|
||||
<strong>Output:</strong> 27
|
||||
<strong>Explanation:</strong>
|
||||
"5" - Add 5 to the record, record is now [5].
|
||||
"-2" - Add -2 to the record, record is now [5, -2].
|
||||
"4" - Add 4 to the record, record is now [5, -2, 4].
|
||||
"C" - Invalidate and remove the previous score, record is now [5, -2].
|
||||
"D" - Add 2 * -2 = -4 to the record, record is now [5, -2, -4].
|
||||
"9" - Add 9 to the record, record is now [5, -2, -4, 9].
|
||||
"+" - Add -4 + 9 = 5 to the record, record is now [5, -2, -4, 9, 5].
|
||||
"+" - Add 9 + 5 = 14 to the record, record is now [5, -2, -4, 9, 5, 14].
|
||||
The total sum is 5 + -2 + -4 + 9 + 5 + 14 = 27.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> ops = ["1"]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= ops.length <= 1000</code></li>
|
||||
<li><code>ops[i]</code> is <code>"C"</code>, <code>"D"</code>, <code>"+"</code>, or a string representing an integer in the range <code>[-3 * 10<sup>4</sup>, 3 * 10<sup>4</sup>]</code>.</li>
|
||||
<li>For operation <code>"+"</code>, there will always be at least two previous scores on the record.</li>
|
||||
<li>For operations <code>"C"</code> and <code>"D"</code>, there will always be at least one previous score on the record.</li>
|
||||
</ul>
|
||||
29
leetcode/problem/basic-calculator-ii.html
Normal file
29
leetcode/problem/basic-calculator-ii.html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>Given a string <code>s</code> which represents an expression, <em>evaluate this expression and return its value</em>. </p>
|
||||
|
||||
<p>The integer division should truncate toward zero.</p>
|
||||
|
||||
<p>You may assume that the given expression is always valid. All intermediate results will be in the range of <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>.</p>
|
||||
|
||||
<p><strong>Note:</strong> You are not allowed to use any built-in function which evaluates strings as mathematical expressions, such as <code>eval()</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "3+2*2"
|
||||
<strong>Output:</strong> 7
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> s = " 3/2 "
|
||||
<strong>Output:</strong> 1
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> s = " 3+5 / 2 "
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists of integers and operators <code>('+', '-', '*', '/')</code> separated by some number of spaces.</li>
|
||||
<li><code>s</code> represents <strong>a valid expression</strong>.</li>
|
||||
<li>All the integers in the expression are non-negative integers in the range <code>[0, 2<sup>31</sup> - 1]</code>.</li>
|
||||
<li>The answer is <strong>guaranteed</strong> to fit in a <strong>32-bit integer</strong>.</li>
|
||||
</ul>
|
||||
72
leetcode/problem/basic-calculator-iv.html
Normal file
72
leetcode/problem/basic-calculator-iv.html
Normal file
@@ -0,0 +1,72 @@
|
||||
<p>Given an expression such as <code>expression = "e + 8 - a + 5"</code> and an evaluation map such as <code>{"e": 1}</code> (given in terms of <code>evalvars = ["e"]</code> and <code>evalints = [1]</code>), return a list of tokens representing the simplified expression, such as <code>["-1*a","14"]</code></p>
|
||||
|
||||
<ul>
|
||||
<li>An expression alternates chunks and symbols, with a space separating each chunk and symbol.</li>
|
||||
<li>A chunk is either an expression in parentheses, a variable, or a non-negative integer.</li>
|
||||
<li>A variable is a string of lowercase letters (not including digits.) Note that variables can be multiple letters, and note that variables never have a leading coefficient or unary operator like <code>"2x"</code> or <code>"-x"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Expressions are evaluated in the usual order: brackets first, then multiplication, then addition and subtraction.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>expression = "1 + 2 * 3"</code> has an answer of <code>["7"]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The format of the output is as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>For each term of free variables with a non-zero coefficient, we write the free variables within a term in sorted order lexicographically.
|
||||
<ul>
|
||||
<li>For example, we would never write a term like <code>"b*a*c"</code>, only <code>"a*b*c"</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Terms have degrees equal to the number of free variables being multiplied, counting multiplicity. We write the largest degree terms of our answer first, breaking ties by lexicographic order ignoring the leading coefficient of the term.
|
||||
<ul>
|
||||
<li>For example, <code>"a*a*b*c"</code> has degree <code>4</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>The leading coefficient of the term is placed directly to the left with an asterisk separating it from the variables (if they exist.) A leading coefficient of 1 is still printed.</li>
|
||||
<li>An example of a well-formatted answer is <code>["-2*a*a*a", "3*a*a*b", "3*b*b", "4*a", "5*c", "-6"]</code>.</li>
|
||||
<li>Terms (including constant terms) with coefficient <code>0</code> are not included.
|
||||
<ul>
|
||||
<li>For example, an expression of <code>"0"</code> has an output of <code>[]</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "e + 8 - a + 5", evalvars = ["e"], evalints = [1]
|
||||
<strong>Output:</strong> ["-1*a","14"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "e - 8 + temperature - pressure", evalvars = ["e", "temperature"], evalints = [1, 12]
|
||||
<strong>Output:</strong> ["-1*pressure","5"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "(e + 8) * (e - 8)", evalvars = [], evalints = []
|
||||
<strong>Output:</strong> ["1*e*e","-64"]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= expression.length <= 250</code></li>
|
||||
<li><code>expression</code> consists of lowercase English letters, digits, <code>'+'</code>, <code>'-'</code>, <code>'*'</code>, <code>'('</code>, <code>')'</code>, <code>' '</code>.</li>
|
||||
<li><code>expression</code> does not contain any leading or trailing spaces.</li>
|
||||
<li>All the tokens in <code>expression</code> are separated by a single space.</li>
|
||||
<li><code>0 <= evalvars.length <= 100</code></li>
|
||||
<li><code>1 <= evalvars[i].length <= 20</code></li>
|
||||
<li><code>evalvars[i]</code> consists of lowercase English letters.</li>
|
||||
<li><code>evalints.length == evalvars.length</code></li>
|
||||
<li><code>-100 <= evalints[i] <= 100</code></li>
|
||||
</ul>
|
||||
38
leetcode/problem/basic-calculator.html
Normal file
38
leetcode/problem/basic-calculator.html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p>Given a string <code>s</code> representing a valid expression, implement a basic calculator to evaluate it, and return <em>the result of the evaluation</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> You are <strong>not</strong> allowed to use any built-in function which evaluates strings as mathematical expressions, such as <code>eval()</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "1 + 1"
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = " 2-1 + 2 "
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(1+(4+5+2)-3)+(6+8)"
|
||||
<strong>Output:</strong> 23
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consists of digits, <code>'+'</code>, <code>'-'</code>, <code>'('</code>, <code>')'</code>, and <code>' '</code>.</li>
|
||||
<li><code>s</code> represents a valid expression.</li>
|
||||
<li><code>'+'</code> is <strong>not</strong> used as a unary operation (i.e., <code>"+1"</code> and <code>"+(2 + 3)"</code> is invalid).</li>
|
||||
<li><code>'-'</code> could be used as a unary operation (i.e., <code>"-1"</code> and <code>"-(2 + 3)"</code> is valid).</li>
|
||||
<li>There will be no two consecutive operators in the input.</li>
|
||||
<li>Every number and running calculation will fit in a signed 32-bit integer.</li>
|
||||
</ul>
|
||||
31
leetcode/problem/battleships-in-a-board.html
Normal file
31
leetcode/problem/battleships-in-a-board.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given an <code>m x n</code> matrix <code>board</code> where each cell is a battleship <code>'X'</code> or empty <code>'.'</code>, return <em>the number of the <strong>battleships</strong> on</em> <code>board</code>.</p>
|
||||
|
||||
<p><strong>Battleships</strong> can only be placed horizontally or vertically on <code>board</code>. In other words, they can only be made of the shape <code>1 x k</code> (<code>1</code> row, <code>k</code> columns) or <code>k x 1</code> (<code>k</code> rows, <code>1</code> column), where <code>k</code> can be of any size. At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/10/battelship-grid.jpg" style="width: 333px; height: 333px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> board = [["."]]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == board.length</code></li>
|
||||
<li><code>n == board[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 200</code></li>
|
||||
<li><code>board[i][j]</code> is either <code>'.'</code> or <code>'X'</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Could you do it in one-pass, using only <code>O(1)</code> extra memory and without modifying the values <code>board</code>?</p>
|
||||
31
leetcode/problem/beautiful-arrangement-ii.html
Normal file
31
leetcode/problem/beautiful-arrangement-ii.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given two integers <code>n</code> and <code>k</code>, construct a list <code>answer</code> that contains <code>n</code> different positive integers ranging from <code>1</code> to <code>n</code> and obeys the following requirement:</p>
|
||||
|
||||
<ul>
|
||||
<li>Suppose this list is <code>answer = [a<sub>1</sub>, a<sub>2</sub>, a<sub>3</sub>, ... , a<sub>n</sub>]</code>, then the list <code>[|a<sub>1</sub> - a<sub>2</sub>|, |a<sub>2</sub> - a<sub>3</sub>|, |a<sub>3</sub> - a<sub>4</sub>|, ... , |a<sub>n-1</sub> - a<sub>n</sub>|]</code> has exactly <code>k</code> distinct integers.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the list</em> <code>answer</code>. If there multiple valid answers, return <strong>any of them</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, k = 1
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
Explanation: The [1,2,3] has three different positive integers ranging from 1 to 3, and the [1,1] has exactly 1 distinct integer: 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, k = 2
|
||||
<strong>Output:</strong> [1,3,2]
|
||||
Explanation: The [1,3,2] has three different positive integers ranging from 1 to 3, and the [2,1] has exactly 2 distinct integers: 1 and 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k < n <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
37
leetcode/problem/beautiful-arrangement.html
Normal file
37
leetcode/problem/beautiful-arrangement.html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Suppose you have <code>n</code> integers labeled <code>1</code> through <code>n</code>. A permutation of those <code>n</code> integers <code>perm</code> (<strong>1-indexed</strong>) is considered a <strong>beautiful arrangement</strong> if for every <code>i</code> (<code>1 <= i <= n</code>), <strong>either</strong> of the following is true:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>perm[i]</code> is divisible by <code>i</code>.</li>
|
||||
<li><code>i</code> is divisible by <code>perm[i]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>the <strong>number</strong> of the <strong>beautiful arrangements</strong> that you can construct</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> 2
|
||||
<b>Explanation:</b>
|
||||
The first beautiful arrangement is [1,2]:
|
||||
- perm[1] = 1 is divisible by i = 1
|
||||
- perm[2] = 2 is divisible by i = 2
|
||||
The second beautiful arrangement is [2,1]:
|
||||
- perm[1] = 2 is divisible by i = 1
|
||||
- i = 2 is divisible by perm[2] = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 15</code></li>
|
||||
</ul>
|
||||
23
leetcode/problem/beautiful-array.html
Normal file
23
leetcode/problem/beautiful-array.html
Normal file
@@ -0,0 +1,23 @@
|
||||
<p>An array <code>nums</code> of length <code>n</code> is <strong>beautiful</strong> if:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>nums</code> is a permutation of the integers in the range <code>[1, n]</code>.</li>
|
||||
<li>For every <code>0 <= i < j < n</code>, there is no index <code>k</code> with <code>i < k < j</code> where <code>2 * nums[k] == nums[i] + nums[j]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given the integer <code>n</code>, return <em>any <strong>beautiful</strong> array </em><code>nums</code><em> of length </em><code>n</code>. There will be at least one valid answer for the given <code>n</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> [2,1,4,3]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> [3,1,2,5,4]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
</ul>
|
||||
33
leetcode/problem/best-position-for-a-service-centre.html
Normal file
33
leetcode/problem/best-position-for-a-service-centre.html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>A delivery company wants to build a new service center in a new city. The company knows the positions of all the customers in this city on a 2D-Map and wants to build the new center in a position such that <strong>the sum of the euclidean distances to all customers is minimum</strong>.</p>
|
||||
|
||||
<p>Given an array <code>positions</code> where <code>positions[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> is the position of the <code>ith</code> customer on the map, return <em>the minimum sum of the euclidean distances</em> to all customers.</p>
|
||||
|
||||
<p>In other words, you need to choose the position of the service center <code>[x<sub>centre</sub>, y<sub>centre</sub>]</code> such that the following formula is minimized:</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/06/25/q4_edited.jpg" />
|
||||
<p>Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/06/25/q4_e1.jpg" style="width: 377px; height: 362px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> positions = [[0,1],[1,0],[1,2],[2,1]]
|
||||
<strong>Output:</strong> 4.00000
|
||||
<strong>Explanation:</strong> As shown, you can see that choosing [x<sub>centre</sub>, y<sub>centre</sub>] = [1, 1] will make the distance to each customer = 1, the sum of all distances is 4 which is the minimum possible we can achieve.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/06/25/q4_e3.jpg" style="width: 419px; height: 419px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> positions = [[1,1],[3,3]]
|
||||
<strong>Output:</strong> 2.82843
|
||||
<strong>Explanation:</strong> The minimum possible sum of distances = sqrt(2) + sqrt(2) = 2.82843
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= positions.length <= 50</code></li>
|
||||
<li><code>positions[i].length == 2</code></li>
|
||||
<li><code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 100</code></li>
|
||||
</ul>
|
||||
29
leetcode/problem/best-sightseeing-pair.html
Normal file
29
leetcode/problem/best-sightseeing-pair.html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>You are given an integer array <code>values</code> where values[i] represents the value of the <code>i<sup>th</sup></code> sightseeing spot. Two sightseeing spots <code>i</code> and <code>j</code> have a <strong>distance</strong> <code>j - i</code> between them.</p>
|
||||
|
||||
<p>The score of a pair (<code>i < j</code>) of sightseeing spots is <code>values[i] + values[j] + i - j</code>: the sum of the values of the sightseeing spots, minus the distance between them.</p>
|
||||
|
||||
<p>Return <em>the maximum score of a pair of sightseeing spots</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> values = [8,1,5,2,6]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> values = [1,2]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= values.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= values[i] <= 1000</code></li>
|
||||
</ul>
|
||||
40
leetcode/problem/best-team-with-no-conflicts.html
Normal file
40
leetcode/problem/best-team-with-no-conflicts.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>You are the manager of a basketball team. For the upcoming tournament, you want to choose the team with the highest overall score. The score of the team is the <strong>sum</strong> of scores of all the players in the team.</p>
|
||||
|
||||
<p>However, the basketball team is not allowed to have <strong>conflicts</strong>. A <strong>conflict</strong> exists if a younger player has a <strong>strictly higher</strong> score than an older player. A conflict does <strong>not</strong> occur between players of the same age.</p>
|
||||
|
||||
<p>Given two lists, <code>scores</code> and <code>ages</code>, where each <code>scores[i]</code> and <code>ages[i]</code> represents the score and age of the <code>i<sup>th</sup></code> player, respectively, return <em>the highest overall score of all possible basketball teams</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> scores = [1,3,5,10,15], ages = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 34
|
||||
<strong>Explanation:</strong> You can choose all the players.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> scores = [4,5,6,5], ages = [2,1,2,1]
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> It is best to choose the last 3 players. Notice that you are allowed to choose multiple people of the same age.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> scores = [1,2,3,5], ages = [8,9,10,1]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> It is best to choose the first 3 players.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= scores.length, ages.length <= 1000</code></li>
|
||||
<li><code>scores.length == ages.length</code></li>
|
||||
<li><code>1 <= scores[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= ages[i] <= 1000</code></li>
|
||||
</ul>
|
||||
41
leetcode/problem/best-time-to-buy-and-sell-stock-ii.html
Normal file
41
leetcode/problem/best-time-to-buy-and-sell-stock-ii.html
Normal file
@@ -0,0 +1,41 @@
|
||||
<p>You are given an integer array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>On each day, you may decide to buy and/or sell the stock. You can only hold <strong>at most one</strong> share of the stock at any time. However, you can buy it then immediately sell it on the <strong>same day</strong>.</p>
|
||||
|
||||
<p>Find and return <em>the <strong>maximum</strong> profit you can achieve</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,1,5,3,6,4]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
|
||||
Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
|
||||
Total profit is 4 + 3 = 7.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
|
||||
Total profit is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
39
leetcode/problem/best-time-to-buy-and-sell-stock-iii.html
Normal file
39
leetcode/problem/best-time-to-buy-and-sell-stock-iii.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete <strong>at most two transactions</strong>.</p>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [3,3,5,0,0,3,1,4]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
|
||||
Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
|
||||
Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> In this case, no transaction is done, i.e. max profit = 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/best-time-to-buy-and-sell-stock-iv.html
Normal file
31
leetcode/problem/best-time-to-buy-and-sell-stock-iv.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>You are given an integer array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer <code>k</code>.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete at most <code>k</code> transactions.</p>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, prices = [2,4,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, prices = [3,2,6,5,0,3]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= k <= 100</code></li>
|
||||
<li><code>0 <= prices.length <= 1000</code></li>
|
||||
<li><code>0 <= prices[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:</p>
|
||||
|
||||
<ul>
|
||||
<li>After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,3,0,2]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> transactions = [buy, sell, cooldown, buy, sell]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1]
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 5000</code></li>
|
||||
<li><code>0 <= prices[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer <code>fee</code> representing a transaction fee.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.</p>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,3,2,8,4,9], fee = 2
|
||||
<strong>Output:</strong> 8
|
||||
<strong>Explanation:</strong> The maximum profit can be achieved by:
|
||||
- Buying at prices[0] = 1
|
||||
- Selling at prices[3] = 8
|
||||
- Buying at prices[4] = 4
|
||||
- Selling at prices[5] = 9
|
||||
The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,3,7,5,10,3], fee = 3
|
||||
<strong>Output:</strong> 6
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= prices[i] < 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= fee < 5 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/best-time-to-buy-and-sell-stock.html
Normal file
31
leetcode/problem/best-time-to-buy-and-sell-stock.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>You want to maximize your profit by choosing a <strong>single day</strong> to buy one stock and choosing a <strong>different day in the future</strong> to sell that stock.</p>
|
||||
|
||||
<p>Return <em>the maximum profit you can achieve from this transaction</em>. If you cannot achieve any profit, return <code>0</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,1,5,3,6,4]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
|
||||
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> In this case, no transactions are done and the max profit = 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
54
leetcode/problem/big-countries.html
Normal file
54
leetcode/problem/big-countries.html
Normal file
@@ -0,0 +1,54 @@
|
||||
<p>Table: <code>World</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| name | varchar |
|
||||
| continent | varchar |
|
||||
| area | int |
|
||||
| population | int |
|
||||
| gdp | int |
|
||||
+-------------+---------+
|
||||
name is the primary key column for this table.
|
||||
Each row of this table gives information about the name of a country, the continent to which it belongs, its area, the population, and its GDP value.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>A country is <strong>big</strong> if:</p>
|
||||
|
||||
<ul>
|
||||
<li>it has an area of at least three million (i.e., <code>3000000 km<sup>2</sup></code>), or</li>
|
||||
<li>it has a population of at least twenty-five million (i.e., <code>25000000</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p>Write an SQL query to report the name, population, and area of the <strong>big countries</strong>.</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
World table:
|
||||
+-------------+-----------+---------+------------+--------------+
|
||||
| name | continent | area | population | gdp |
|
||||
+-------------+-----------+---------+------------+--------------+
|
||||
| Afghanistan | Asia | 652230 | 25500100 | 20343000000 |
|
||||
| Albania | Europe | 28748 | 2831741 | 12960000000 |
|
||||
| Algeria | Africa | 2381741 | 37100000 | 188681000000 |
|
||||
| Andorra | Europe | 468 | 78115 | 3712000000 |
|
||||
| Angola | Africa | 1246700 | 20609294 | 100990000000 |
|
||||
+-------------+-----------+---------+------------+--------------+
|
||||
<strong>Output:</strong>
|
||||
+-------------+------------+---------+
|
||||
| name | population | area |
|
||||
+-------------+------------+---------+
|
||||
| Afghanistan | 25500100 | 652230 |
|
||||
| Algeria | 37100000 | 2381741 |
|
||||
+-------------+------------+---------+
|
||||
</pre>
|
||||
40
leetcode/problem/binary-gap.html
Normal file
40
leetcode/problem/binary-gap.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>Given a positive integer <code>n</code>, find and return <em>the <strong>longest distance</strong> between any two <strong>adjacent</strong> </em><code>1</code><em>'s in the binary representation of </em><code>n</code><em>. If there are no two adjacent </em><code>1</code><em>'s, return </em><code>0</code><em>.</em></p>
|
||||
|
||||
<p>Two <code>1</code>'s are <strong>adjacent</strong> if there are only <code>0</code>'s separating them (possibly no <code>0</code>'s). The <b>distance</b> between two <code>1</code>'s is the absolute difference between their bit positions. For example, the two <code>1</code>'s in <code>"1001"</code> have a distance of 3.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 22
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> 22 in binary is "10110".
|
||||
The first adjacent pair of 1's is "<u>1</u>0<u>1</u>10" with a distance of 2.
|
||||
The second adjacent pair of 1's is "10<u>11</u>0" with a distance of 1.
|
||||
The answer is the largest of these two distances, which is 2.
|
||||
Note that "<u>1</u>01<u>1</u>0" is not a valid pair since there is a 1 separating the two 1's underlined.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 8
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> 8 in binary is "1000".
|
||||
There are not any adjacent pairs of 1's in the binary representation of 8, so we return 0.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> 5 in binary is "101".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/binary-number-with-alternating-bits.html
Normal file
31
leetcode/problem/binary-number-with-alternating-bits.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> The binary representation of 5 is: 101
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> The binary representation of 7 is: 111.</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 11
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> The binary representation of 11 is: 1011.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
34
leetcode/problem/binary-prefix-divisible-by-5.html
Normal file
34
leetcode/problem/binary-prefix-divisible-by-5.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>You are given a binary array <code>nums</code> (<strong>0-indexed</strong>).</p>
|
||||
|
||||
<p>We define <code>x<sub>i</sub></code> as the number whose binary representation is the subarray <code>nums[0..i]</code> (from most-significant-bit to least-significant-bit).</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, if <code>nums = [1,0,1]</code>, then <code>x<sub>0</sub> = 1</code>, <code>x<sub>1</sub> = 2</code>, and <code>x<sub>2</sub> = 5</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array of booleans </em><code>answer</code><em> where </em><code>answer[i]</code><em> is </em><code>true</code><em> if </em><code>x<sub>i</sub></code><em> is divisible by </em><code>5</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1,1]
|
||||
<strong>Output:</strong> [true,false,false]
|
||||
<strong>Explanation:</strong> The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10.
|
||||
Only the first number is divisible by 5, so answer[0] is true.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1]
|
||||
<strong>Output:</strong> [false,false,false]
|
||||
</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>
|
||||
50
leetcode/problem/binary-search-tree-iterator.html
Normal file
50
leetcode/problem/binary-search-tree-iterator.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>Implement the <code>BSTIterator</code> class that represents an iterator over the <strong><a href="https://en.wikipedia.org/wiki/Tree_traversal#In-order_(LNR)" target="_blank">in-order traversal</a></strong> of a binary search tree (BST):</p>
|
||||
|
||||
<ul>
|
||||
<li><code>BSTIterator(TreeNode root)</code> Initializes an object of the <code>BSTIterator</code> class. The <code>root</code> of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.</li>
|
||||
<li><code>boolean hasNext()</code> Returns <code>true</code> if there exists a number in the traversal to the right of the pointer, otherwise returns <code>false</code>.</li>
|
||||
<li><code>int next()</code> Moves the pointer to the right, then returns the number at the pointer.</li>
|
||||
</ul>
|
||||
|
||||
<p>Notice that by initializing the pointer to a non-existent smallest number, the first call to <code>next()</code> will return the smallest element in the BST.</p>
|
||||
|
||||
<p>You may assume that <code>next()</code> calls will always be valid. That is, there will be at least a next number in the in-order traversal when <code>next()</code> is called.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png" style="width: 189px; height: 178px;" />
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
|
||||
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
<strong>Output</strong>
|
||||
[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
bSTIterator.next(); // return 3
|
||||
bSTIterator.next(); // return 7
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 9
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 15
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 20
|
||||
bSTIterator.hasNext(); // return False
|
||||
</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>0 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li>At most <code>10<sup>5</sup></code> calls will be made to <code>hasNext</code>, and <code>next</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Could you implement <code>next()</code> and <code>hasNext()</code> to run in average <code>O(1)</code> time and use <code>O(h)</code> memory, where <code>h</code> is the height of the tree?</li>
|
||||
</ul>
|
||||
36
leetcode/problem/binary-search-tree-to-greater-sum-tree.html
Normal file
36
leetcode/problem/binary-search-tree-to-greater-sum-tree.html
Normal file
@@ -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>
|
||||
30
leetcode/problem/binary-search.html
Normal file
30
leetcode/problem/binary-search.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>Given an array of integers <code>nums</code> which is sorted in ascending order, and an integer <code>target</code>, write a function to search <code>target</code> in <code>nums</code>. If <code>target</code> exists, then return its index. Otherwise, return <code>-1</code>.</p>
|
||||
|
||||
<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 9
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> 9 exists in nums and its index is 4
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 2
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> 2 does not exist in nums so return -1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> < nums[i], target < 10<sup>4</sup></code></li>
|
||||
<li>All the integers in <code>nums</code> are <strong>unique</strong>.</li>
|
||||
<li><code>nums</code> is sorted in ascending order.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,20 @@
|
||||
<p>Given a binary string <code>s</code> and a positive integer <code>n</code>, return <code>true</code><em> if the binary representation of all the integers in the range </em><code>[1, n]</code><em> are <strong>substrings</strong> of </em><code>s</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
|
||||
|
||||
<p>A <strong>substring</strong> is a contiguous sequence of characters within a string.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "0110", n = 3
|
||||
<strong>Output:</strong> true
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "0110", n = 4
|
||||
<strong>Output:</strong> false
|
||||
</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>'0'</code> or <code>'1'</code>.</li>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
32
leetcode/problem/binary-subarrays-with-sum.html
Normal file
32
leetcode/problem/binary-subarrays-with-sum.html
Normal file
@@ -0,0 +1,32 @@
|
||||
<p>Given a binary array <code>nums</code> and an integer <code>goal</code>, return <em>the number of non-empty <strong>subarrays</strong> with a sum</em> <code>goal</code>.</p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous part of the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,0,1,0,1], goal = 2
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The 4 subarrays are bolded and underlined below:
|
||||
[<u><strong>1,0,1</strong></u>,0,1]
|
||||
[<u><strong>1,0,1,0</strong></u>,1]
|
||||
[1,<u><strong>0,1,0,1</strong></u>]
|
||||
[1,0,<u><strong>1,0,1</strong></u>]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,0,0,0], goal = 0
|
||||
<strong>Output:</strong> 15
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li><code>0 <= goal <= nums.length</code></li>
|
||||
</ul>
|
||||
28
leetcode/problem/binary-tree-cameras.html
Normal file
28
leetcode/problem/binary-tree-cameras.html
Normal file
@@ -0,0 +1,28 @@
|
||||
<p>You are given the <code>root</code> of a binary tree. We install cameras on the tree nodes where each camera at a node can monitor its parent, itself, and its immediate children.</p>
|
||||
|
||||
<p>Return <em>the minimum number of cameras needed to monitor all nodes of the tree</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/29/bst_cameras_01.png" style="width: 138px; height: 163px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [0,0,null,0,0]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> One camera is enough to monitor all nodes if placed as shown.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/29/bst_cameras_02.png" style="width: 139px; height: 312px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [0,0,null,0,null,0,null,null,0]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> At least two cameras are needed to monitor all nodes of the tree. The above image shows one of the valid configurations of camera placement.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
|
||||
<li><code>Node.val == 0</code></li>
|
||||
</ul>
|
||||
36
leetcode/problem/binary-tree-coloring-game.html
Normal file
36
leetcode/problem/binary-tree-coloring-game.html
Normal file
@@ -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>
|
||||
34
leetcode/problem/binary-tree-inorder-traversal.html
Normal file
34
leetcode/problem/binary-tree-inorder-traversal.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the inorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 125px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<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>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
|
||||
31
leetcode/problem/binary-tree-level-order-traversal-ii.html
Normal file
31
leetcode/problem/binary-tree-level-order-traversal-ii.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the bottom-up level order traversal of its nodes' values</em>. (i.e., from left to right, level by level from leaf to root).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [[15,7],[9,20],[3]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/binary-tree-level-order-traversal.html
Normal file
31
leetcode/problem/binary-tree-level-order-traversal.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the level order traversal of its nodes' values</em>. (i.e., from left to right, level by level).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [[3],[9,20],[15,7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
30
leetcode/problem/binary-tree-maximum-path-sum.html
Normal file
30
leetcode/problem/binary-tree-maximum-path-sum.html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>A <strong>path</strong> in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence <strong>at most once</strong>. Note that the path does not need to pass through the root.</p>
|
||||
|
||||
<p>The <strong>path sum</strong> of a path is the sum of the node's values in the path.</p>
|
||||
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the maximum <strong>path sum</strong> of any <strong>non-empty</strong> path</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg" style="width: 322px; height: 182px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [-10,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> 42
|
||||
<strong>Explanation:</strong> The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
26
leetcode/problem/binary-tree-paths.html
Normal file
26
leetcode/problem/binary-tree-paths.html
Normal file
@@ -0,0 +1,26 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>all root-to-leaf paths in <strong>any order</strong></em>.</p>
|
||||
|
||||
<p>A <strong>leaf</strong> is a node with no children.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/12/paths-tree.jpg" style="width: 207px; height: 293px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,null,5]
|
||||
<strong>Output:</strong> ["1->2->5","1->3"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<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, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
34
leetcode/problem/binary-tree-postorder-traversal.html
Normal file
34
leetcode/problem/binary-tree-postorder-traversal.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the postorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre1.jpg" style="width: 127px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [3,2,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
|
||||
34
leetcode/problem/binary-tree-preorder-traversal.html
Normal file
34
leetcode/problem/binary-tree-preorder-traversal.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the preorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 125px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<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>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
|
||||
36
leetcode/problem/binary-tree-pruning.html
Normal file
36
leetcode/problem/binary-tree-pruning.html
Normal file
@@ -0,0 +1,36 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the same tree where every subtree (of the given tree) not containing a </em><code>1</code><em> has been removed</em>.</p>
|
||||
|
||||
<p>A subtree of a node <code>node</code> is <code>node</code> plus every node that is a descendant of <code>node</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_2.png" style="width: 500px; height: 140px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,0,0,1]
|
||||
<strong>Output:</strong> [1,null,0,null,1]
|
||||
<strong>Explanation:</strong>
|
||||
Only the red nodes satisfy the property "every subtree not containing a 1".
|
||||
The diagram on the right represents the answer.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_1.png" style="width: 500px; height: 115px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,0,1,0,0,0,1]
|
||||
<strong>Output:</strong> [1,null,1,null,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/05/1028.png" style="width: 500px; height: 134px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,1,0,1,1,0,1,0]
|
||||
<strong>Output:</strong> [1,1,0,1,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, 200]</code>.</li>
|
||||
<li><code>Node.val</code> is either <code>0</code> or <code>1</code>.</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