mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,38 @@
|
||||
<p>You are given two <strong>0-indexed</strong> strings <code>word1</code> and <code>word2</code>.</p>
|
||||
|
||||
<p>A <strong>move</strong> consists of choosing two indices <code>i</code> and <code>j</code> such that <code>0 <= i < word1.length</code> and <code>0 <= j < word2.length</code> and swapping <code>word1[i]</code> with <code>word2[j]</code>.</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if it is possible to get the number of distinct characters in</em> <code>word1</code> <em>and</em> <code>word2</code> <em>to be equal with <strong>exactly one</strong> move. </em>Return <code>false</code> <em>otherwise</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word1 = "ac", word2 = "b"
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> Any pair of swaps would yield two distinct characters in the first string, and one in the second string.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word1 = "abcc", word2 = "aab"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> We swap index 2 of the first string with index 0 of the second string. The resulting strings are word1 = "abac" and word2 = "cab", which both have 3 distinct characters.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word1 = "abcde", word2 = "fghij"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Both resulting strings will have 5 distinct characters, regardless of which indices we swap.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word1.length, word2.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>word1</code> and <code>word2</code> consist of only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>. You have a <strong>starting score</strong> of <code>0</code>.</p>
|
||||
|
||||
<p>In one <strong>operation</strong>:</p>
|
||||
|
||||
<ol>
|
||||
<li>choose an index <code>i</code> such that <code>0 <= i < nums.length</code>,</li>
|
||||
<li>increase your <strong>score</strong> by <code>nums[i]</code>, and</li>
|
||||
<li>replace <code>nums[i]</code> with <code>ceil(nums[i] / 3)</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>the maximum possible <strong>score</strong> you can attain after applying <strong>exactly</strong></em> <code>k</code> <em>operations</em>.</p>
|
||||
|
||||
<p>The ceiling function <code>ceil(val)</code> is the least integer greater than or equal to <code>val</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,10,10,10,10], k = 5
|
||||
<strong>Output:</strong> 50
|
||||
<strong>Explanation:</strong> Apply the operation to each array element exactly once. The final score is 10 + 10 + 10 + 10 + 10 = 50.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,10,3,3,3], k = 3
|
||||
<strong>Output:</strong> 17
|
||||
<strong>Explanation: </strong>You can do the following operations:
|
||||
Operation 1: Select i = 1, so nums becomes [1,<strong><u>4</u></strong>,3,3,3]. Your score increases by 10.
|
||||
Operation 2: Select i = 1, so nums becomes [1,<strong><u>2</u></strong>,3,3,3]. Your score increases by 4.
|
||||
Operation 3: Select i = 2, so nums becomes [1,1,<u><strong>1</strong></u>,3,3]. Your score increases by 3.
|
||||
The final score is 10 + 4 + 3 = 17.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length, k <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>For a stream of integers, implement a data structure that checks if the last <code>k</code> integers parsed in the stream are <strong>equal</strong> to <code>value</code>.</p>
|
||||
|
||||
<p>Implement the <strong>DataStream</strong> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>DataStream(int value, int k)</code> Initializes the object with an empty integer stream and the two integers <code>value</code> and <code>k</code>.</li>
|
||||
<li><code>boolean consec(int num)</code> Adds <code>num</code> to the stream of integers. Returns <code>true</code> if the last <code>k</code> integers are equal to <code>value</code>, and <code>false</code> otherwise. If there are less than <code>k</code> integers, the condition does not hold true, so returns <code>false</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["DataStream", "consec", "consec", "consec", "consec"]
|
||||
[[4, 3], [4], [4], [4], [3]]
|
||||
<strong>Output</strong>
|
||||
[null, false, false, true, false]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
DataStream dataStream = new DataStream(4, 3); //value = 4, k = 3
|
||||
dataStream.consec(4); // Only 1 integer is parsed, so returns False.
|
||||
dataStream.consec(4); // Only 2 integers are parsed.
|
||||
// Since 2 is less than k, returns False.
|
||||
dataStream.consec(4); // The 3 integers parsed are all equal to value, so returns True.
|
||||
dataStream.consec(3); // The last k integers parsed in the stream are [4,4,3].
|
||||
// Since 3 is not equal to value, it returns False.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= value, num <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
<li>At most <code>10<sup>5</sup></code> calls will be made to <code>consec</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>stations</code> of length <code>n</code>, where <code>stations[i]</code> represents the number of power stations in the <code>i<sup>th</sup></code> city.</p>
|
||||
|
||||
<p>Each power station can provide power to every city in a fixed <strong>range</strong>. In other words, if the range is denoted by <code>r</code>, then a power station at city <code>i</code> can provide power to all cities <code>j</code> such that <code>|i - j| <= r</code> and <code>0 <= i, j <= n - 1</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>Note that <code>|x|</code> denotes <strong>absolute</strong> value. For example, <code>|7 - 5| = 2</code> and <code>|3 - 10| = 7</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>power</strong> of a city is the total number of power stations it is being provided power from.</p>
|
||||
|
||||
<p>The government has sanctioned building <code>k</code> more power stations, each of which can be built in any city, and have the same range as the pre-existing ones.</p>
|
||||
|
||||
<p>Given the two integers <code>r</code> and <code>k</code>, return <em>the <strong>maximum possible minimum power</strong> of a city, if the additional power stations are built optimally.</em></p>
|
||||
|
||||
<p><strong>Note</strong> that you can build the <code>k</code> power stations in multiple cities.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> stations = [1,2,4,5,0], r = 1, k = 2
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
One of the optimal ways is to install both the power stations at city 1.
|
||||
So stations will become [1,4,4,5,0].
|
||||
- City 0 is provided by 1 + 4 = 5 power stations.
|
||||
- City 1 is provided by 1 + 4 + 4 = 9 power stations.
|
||||
- City 2 is provided by 4 + 4 + 5 = 13 power stations.
|
||||
- City 3 is provided by 5 + 4 = 9 power stations.
|
||||
- City 4 is provided by 5 + 0 = 5 power stations.
|
||||
So the minimum power of a city is 5.
|
||||
Since it is not possible to obtain a larger power, we return 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> stations = [4,4,4,4], r = 0, k = 3
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong>
|
||||
It can be proved that we cannot make the minimum power of a city greater than 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == stations.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= stations[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= r <= n - 1</code></li>
|
||||
<li><code>0 <= k <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>The <strong>effective value</strong> of three indices <code>i</code>, <code>j</code>, and <code>k</code> is defined as <code>((nums[i] | nums[j]) & nums[k])</code>.</p>
|
||||
|
||||
<p>The <strong>xor-beauty</strong> of the array is the XORing of <strong>the effective values of all the possible triplets</strong> of indices <code>(i, j, k)</code> where <code>0 <= i, j, k < n</code>.</p>
|
||||
|
||||
<p>Return <em>the xor-beauty of</em> <code>nums</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>val1 | val2</code> is bitwise OR of <code>val1</code> and <code>val2</code>.</li>
|
||||
<li><code>val1 & val2</code> is bitwise AND of <code>val1</code> and <code>val2</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
The triplets and their corresponding effective values are listed below:
|
||||
- (0,0,0) with effective value ((1 | 1) & 1) = 1
|
||||
- (0,0,1) with effective value ((1 | 1) & 4) = 0
|
||||
- (0,1,0) with effective value ((1 | 4) & 1) = 1
|
||||
- (0,1,1) with effective value ((1 | 4) & 4) = 4
|
||||
- (1,0,0) with effective value ((4 | 1) & 1) = 1
|
||||
- (1,0,1) with effective value ((4 | 1) & 4) = 4
|
||||
- (1,1,0) with effective value ((4 | 4) & 1) = 0
|
||||
- (1,1,1) with effective value ((4 | 4) & 4) = 4
|
||||
Xor-beauty of array will be bitwise XOR of all beauties = 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [15,45,20,2,34,35,5,44,32,30]
|
||||
<strong>Output:</strong> 34
|
||||
<strong>Explanation:</strong> <code>The xor-beauty of the given array is 34.</code>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>Given four integers <code>length</code>, <code>width</code>, <code>height</code>, and <code>mass</code>, representing the dimensions and mass of a box, respectively, return <em>a string representing the <strong>category</strong> of the box</em>.</p>
|
||||
|
||||
<ul>
|
||||
<li>The box is <code>"Bulky"</code> if:
|
||||
|
||||
<ul>
|
||||
<li><strong>Any</strong> of the dimensions of the box is greater or equal to <code>10<sup>4</sup></code>.</li>
|
||||
<li>Or, the <strong>volume</strong> of the box is greater or equal to <code>10<sup>9</sup></code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>If the mass of the box is greater or equal to <code>100</code>, it is <code>"Heavy".</code></li>
|
||||
<li>If the box is both <code>"Bulky"</code> and <code>"Heavy"</code>, then its category is <code>"Both"</code>.</li>
|
||||
<li>If the box is neither <code>"Bulky"</code> nor <code>"Heavy"</code>, then its category is <code>"Neither"</code>.</li>
|
||||
<li>If the box is <code>"Bulky"</code> but not <code>"Heavy"</code>, then its category is <code>"Bulky"</code>.</li>
|
||||
<li>If the box is <code>"Heavy"</code> but not <code>"Bulky"</code>, then its category is <code>"Heavy"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note</strong> that the volume of the box is the product of its length, width and height.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> length = 1000, width = 35, height = 700, mass = 300
|
||||
<strong>Output:</strong> "Heavy"
|
||||
<strong>Explanation:</strong>
|
||||
None of the dimensions of the box is greater or equal to 10<sup>4</sup>.
|
||||
Its volume = 24500000 <= 10<sup>9</sup>. So it cannot be categorized as "Bulky".
|
||||
However mass >= 100, so the box is "Heavy".
|
||||
Since the box is not "Bulky" but "Heavy", we return "Heavy".</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> length = 200, width = 50, height = 800, mass = 50
|
||||
<strong>Output:</strong> "Neither"
|
||||
<strong>Explanation:</strong>
|
||||
None of the dimensions of the box is greater or equal to 10<sup>4</sup>.
|
||||
Its volume = 8 * 10<sup>6</sup> <= 10<sup>9</sup>. So it cannot be categorized as "Bulky".
|
||||
Its mass is also less than 100, so it cannot be categorized as "Heavy" either.
|
||||
Since its neither of the two above categories, we return "Neither".</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= length, width, height <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= mass <= 10<sup>3</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>Given an array <code>nums</code> sorted in <strong>non-decreasing</strong> order, return <em>the maximum between the number of positive integers and the number of negative integers.</em></p>
|
||||
|
||||
<ul>
|
||||
<li>In other words, if the number of positive integers in <code>nums</code> is <code>pos</code> and the number of negative integers is <code>neg</code>, then return the maximum of <code>pos</code> and <code>neg</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note</strong> that <code>0</code> is neither positive nor negative.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-2,-1,-1,1,2,3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> There are 3 positive integers and 3 negative integers. The maximum count among them is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-3,-2,-1,0,0,1,2]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> There are 2 positive integers and 3 negative integers. The maximum count among them is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,20,66,1314]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> There are 4 positive integers and 0 negative integers. The maximum count among them is 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2000</code></li>
|
||||
<li><code>-2000 <= nums[i] <= 2000</code></li>
|
||||
<li><code>nums</code> is sorted in a <strong>non-decreasing order</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Can you solve the problem in <code>O(log(n))</code> time complexity?</p>
|
||||
@@ -0,0 +1,72 @@
|
||||
<p>There are <code>k</code> workers who want to move <code>n</code> boxes from an old warehouse to a new one. You are given the two integers <code>n</code> and <code>k</code>, and a 2D integer array <code>time</code> of size <code>k x 4</code> where <code>time[i] = [leftToRight<sub>i</sub>, pickOld<sub>i</sub>, rightToLeft<sub>i</sub>, putNew<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>The warehouses are separated by a river and connected by a bridge. The old warehouse is on the right bank of the river, and the new warehouse is on the left bank of the river. Initially, all <code>k</code> workers are waiting on the left side of the bridge. To move the boxes, the <code>i<sup>th</sup></code> worker (<strong>0-indexed</strong>) can :</p>
|
||||
|
||||
<ul>
|
||||
<li>Cross the bridge from the left bank (new warehouse) to the right bank (old warehouse) in <code>leftToRight<sub>i</sub></code> minutes.</li>
|
||||
<li>Pick a box from the old warehouse and return to the bridge in <code>pickOld<sub>i</sub></code> minutes. Different workers can pick up their boxes simultaneously.</li>
|
||||
<li>Cross the bridge from the right bank (old warehouse) to the left bank (new warehouse) in <code>rightToLeft<sub>i</sub></code> minutes.</li>
|
||||
<li>Put the box in the new warehouse and return to the bridge in <code>putNew<sub>i</sub></code> minutes. Different workers can put their boxes simultaneously.</li>
|
||||
</ul>
|
||||
|
||||
<p>A worker <code>i</code> is <strong>less efficient</strong> than a worker <code>j</code> if either condition is met:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>leftToRight<sub>i</sub> + rightToLeft<sub>i</sub> > leftToRight<sub>j</sub> + rightToLeft<sub>j</sub></code></li>
|
||||
<li><code>leftToRight<sub>i</sub> + rightToLeft<sub>i</sub> == leftToRight<sub>j</sub> + rightToLeft<sub>j</sub></code> and <code>i > j</code></li>
|
||||
</ul>
|
||||
|
||||
<p>The following rules regulate the movement of the workers through the bridge :</p>
|
||||
|
||||
<ul>
|
||||
<li>If a worker <code>x</code> reaches the bridge while another worker <code>y</code> is crossing the bridge, <code>x</code> waits at their side of the bridge.</li>
|
||||
<li>If the bridge is free, the worker waiting on the right side of the bridge gets to cross the bridge. If more than one worker is waiting on the right side, the one with <strong>the lowest efficiency</strong> crosses first.</li>
|
||||
<li>If the bridge is free and no worker is waiting on the right side, and at least one box remains at the old warehouse, the worker on the left side of the river gets to cross the bridge. If more than one worker is waiting on the left side, the one with <strong>the lowest efficiency</strong> crosses first.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the instance of time at which the last worker <strong>reaches the left bank</strong> of the river after all n boxes have been put in the new warehouse</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1, k = 3, time = [[1,1,2,1],[1,1,3,1],[1,1,4,1]]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation: </strong>
|
||||
From 0 to 1: worker 2 crosses the bridge from the left bank to the right bank.
|
||||
From 1 to 2: worker 2 picks up a box from the old warehouse.
|
||||
From 2 to 6: worker 2 crosses the bridge from the right bank to the left bank.
|
||||
From 6 to 7: worker 2 puts a box at the new warehouse.
|
||||
The whole process ends after 7 minutes. We return 6 because the problem asks for the instance of time at which the last worker reaches the left bank.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, k = 2, time = [[1,9,1,8],[10,10,10,10]]
|
||||
<strong>Output:</strong> 50
|
||||
<strong>Explanation:</strong>
|
||||
From 0 to 10: worker 1 crosses the bridge from the left bank to the right bank.
|
||||
From 10 to 20: worker 1 picks up a box from the old warehouse.
|
||||
From 10 to 11: worker 0 crosses the bridge from the left bank to the right bank.
|
||||
From 11 to 20: worker 0 picks up a box from the old warehouse.
|
||||
From 20 to 30: worker 1 crosses the bridge from the right bank to the left bank.
|
||||
From 30 to 40: worker 1 puts a box at the new warehouse.
|
||||
From 30 to 31: worker 0 crosses the bridge from the right bank to the left bank.
|
||||
From 31 to 39: worker 0 puts a box at the new warehouse.
|
||||
From 39 to 40: worker 0 crosses the bridge from the left bank to the right bank.
|
||||
From 40 to 49: worker 0 picks up a box from the old warehouse.
|
||||
From 49 to 50: worker 0 crosses the bridge from the right bank to the left bank.
|
||||
From 50 to 58: worker 0 puts a box at the new warehouse.
|
||||
The whole process ends after 58 minutes. We return 50 because the problem asks for the instance of time at which the last worker reaches the left bank.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, k <= 10<sup>4</sup></code></li>
|
||||
<li><code>time.length == k</code></li>
|
||||
<li><code>time[i].length == 4</code></li>
|
||||
<li><code>1 <= leftToRight<sub>i</sub>, pickOld<sub>i</sub>, rightToLeft<sub>i</sub>, putNew<sub>i</sub> <= 1000</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user