mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 14:12:17 +08:00
update
This commit is contained in:
@@ -0,0 +1,54 @@
|
||||
<p>A concert hall has <code>n</code> rows numbered from <code>0</code> to <code>n - 1</code>, each with <code>m</code> seats, numbered from <code>0</code> to <code>m - 1</code>. You need to design a ticketing system that can allocate seats in the following cases:</p>
|
||||
|
||||
<ul>
|
||||
<li>If a group of <code>k</code> spectators can sit <strong>together</strong> in a row.</li>
|
||||
<li>If <strong>every</strong> member of a group of <code>k</code> spectators can get a seat. They may or <strong>may not</strong> sit together.</li>
|
||||
</ul>
|
||||
|
||||
<p>Note that the spectators are very picky. Hence:</p>
|
||||
|
||||
<ul>
|
||||
<li>They will book seats only if each member of their group can get a seat with row number <strong>less than or equal</strong> to <code>maxRow</code>. <code>maxRow</code> can <strong>vary</strong> from group to group.</li>
|
||||
<li>In case there are multiple rows to choose from, the row with the <strong>smallest</strong> number is chosen. If there are multiple seats to choose in the same row, the seat with the <strong>smallest</strong> number is chosen.</li>
|
||||
</ul>
|
||||
|
||||
<p>Implement the <code>BookMyShow</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>BookMyShow(int n, int m)</code> Initializes the object with <code>n</code> as number of rows and <code>m</code> as number of seats per row.</li>
|
||||
<li><code>int[] gather(int k, int maxRow)</code> Returns an array of length <code>2</code> denoting the row and seat number (respectively) of the <strong>first seat</strong> being allocated to the <code>k</code> members of the group, who must sit <strong>together</strong>. In other words, it returns the smallest possible <code>r</code> and <code>c</code> such that all <code>[c, c + k - 1]</code> seats are valid and empty in row <code>r</code>, and <code>r <= maxRow</code>. Returns <code>[]</code> in case it is <strong>not possible</strong> to allocate seats to the group.</li>
|
||||
<li><code>boolean scatter(int k, int maxRow)</code> Returns <code>true</code> if all <code>k</code> members of the group can be allocated seats in rows <code>0</code> to <code>maxRow</code>, who may or <strong>may not</strong> sit together. If the seats can be allocated, it allocates <code>k</code> seats to the group with the <strong>smallest</strong> row numbers, and the smallest possible seat numbers in each row. Otherwise, returns <code>false</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["BookMyShow", "gather", "gather", "scatter", "scatter"]
|
||||
[[2, 5], [4, 0], [2, 0], [5, 1], [5, 1]]
|
||||
<strong>Output</strong>
|
||||
[null, [0, 0], [], true, false]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
BookMyShow bms = new BookMyShow(2, 5); // There are 2 rows with 5 seats each
|
||||
bms.gather(4, 0); // return [0, 0]
|
||||
// The group books seats [0, 3] of row 0.
|
||||
bms.gather(2, 0); // return []
|
||||
// There is only 1 seat left in row 0,
|
||||
// so it is not possible to book 2 consecutive seats.
|
||||
bms.scatter(5, 1); // return True
|
||||
// The group books seat 4 of row 0 and seats [0, 3] of row 1.
|
||||
bms.scatter(5, 1); // return False
|
||||
// There is only one seat left in the hall.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= m, k <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= maxRow <= n - 1</code></li>
|
||||
<li>At most <code>5 * 10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>gather</code> and <code>scatter</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>A <strong>sentence</strong> is a string of single-space separated words where each word can contain digits, lowercase letters, and the dollar sign <code>'$'</code>. A word represents a <strong>price</strong> if it is a sequence of digits preceded by a dollar sign.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"$100"</code>, <code>"$23"</code>, and <code>"$6"</code> represent prices while <code>"100"</code>, <code>"$"</code>, and <code>"$1e5"</code> do not.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given a string <code>sentence</code> representing a sentence and an integer <code>discount</code>. For each word representing a price, apply a discount of <code>discount%</code> on the price and <strong>update</strong> the word in the sentence. All updated prices should be represented with <strong>exactly two</strong> decimal places.</p>
|
||||
|
||||
<p>Return <em>a string representing the modified sentence</em>.</p>
|
||||
|
||||
<p>Note that all prices will contain <strong>at most</strong> <code>10</code> digits.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> sentence = "there are $1 $2 and 5$ candies in the shop", discount = 50
|
||||
<strong>Output:</strong> "there are $0.50 $1.00 and 5$ candies in the shop"
|
||||
<strong>Explanation:</strong>
|
||||
The words which represent prices are "$1" and "$2".
|
||||
- A 50% discount on "$1" yields "$0.50", so "$1" is replaced by "$0.50".
|
||||
- A 50% discount on "$2" yields "$1". Since we need to have exactly 2 decimal places after a price, we replace "$2" with "$1.00".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> sentence = "1 2 $3 4 $5 $6 7 8$ $9 $10$", discount = 100
|
||||
<strong>Output:</strong> "1 2 $0.00 4 $0.00 $0.00 7 8$ $0.00 $10$"
|
||||
<strong>Explanation:</strong>
|
||||
Applying a 100% discount on any price will result in 0.
|
||||
The words representing prices are "$3", "$5", "$6", and "$9".
|
||||
Each of them is replaced by "$0.00".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= sentence.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>sentence</code> consists of lowercase English letters, digits, <code>' '</code>, and <code>'$'</code>.</li>
|
||||
<li><code>sentence</code> does not have leading or trailing spaces.</li>
|
||||
<li>All words in <code>sentence</code> are separated by a single space.</li>
|
||||
<li>All prices will be <strong>positive</strong> integers without leading zeros.</li>
|
||||
<li>All prices will have <strong>at most</strong> <code>10</code> digits.</li>
|
||||
<li><code>0 <= discount <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>. In one step, <strong>remove</strong> all elements <code>nums[i]</code> where <code>nums[i - 1] > nums[i]</code> for all <code>0 < i < nums.length</code>.</p>
|
||||
|
||||
<p>Return <em>the number of steps performed until </em><code>nums</code><em> becomes a <strong>non-decreasing</strong> array</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,3,4,4,7,3,6,11,8,5,11]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The following are the steps performed:
|
||||
- Step 1: [5,<strong><u>3</u></strong>,4,4,7,<u><strong>3</strong></u>,6,11,<u><strong>8</strong></u>,<u><strong>5</strong></u>,11] becomes [5,4,4,7,6,11,11]
|
||||
- Step 2: [5,<u><strong>4</strong></u>,4,7,<u><strong>6</strong></u>,11,11] becomes [5,4,7,11,11]
|
||||
- Step 3: [5,<u><strong>4</strong></u>,7,11,11] becomes [5,7,11,11]
|
||||
[5,7,11,11] is a non-decreasing array. Therefore, we return 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,5,7,7,13]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> nums is already a non-decreasing array. Therefore, we return 0.
|
||||
</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,52 @@
|
||||
<p>You are given an integer array <code>nums</code> and an integer <code>k</code>. You may partition <code>nums</code> into one or more <strong>subsequences</strong> such that each element in <code>nums</code> appears in <strong>exactly</strong> one of the subsequences.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum </strong>number of subsequences needed such that the difference between the maximum and minimum values in each subsequence is <strong>at most</strong> </em><code>k</code><em>.</em></p>
|
||||
|
||||
<p>A <strong>subsequence</strong> is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,6,1,2,5], k = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
We can partition nums into the two subsequences [3,1,2] and [6,5].
|
||||
The difference between the maximum and minimum value in the first subsequence is 3 - 1 = 2.
|
||||
The difference between the maximum and minimum value in the second subsequence is 6 - 5 = 1.
|
||||
Since two subsequences were created, we return 2. It can be shown that 2 is the minimum number of subsequences needed.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3], k = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
We can partition nums into the two subsequences [1,2] and [3].
|
||||
The difference between the maximum and minimum value in the first subsequence is 2 - 1 = 1.
|
||||
The difference between the maximum and minimum value in the second subsequence is 3 - 3 = 0.
|
||||
Since two subsequences were created, we return 2. Note that another optimal solution is to partition nums into the two subsequences [1] and [2,3].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,2,4,5], k = 0
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
We can partition nums into the three subsequences [2,2], [4], and [5].
|
||||
The difference between the maximum and minimum value in the first subsequences is 2 - 2 = 0.
|
||||
The difference between the maximum and minimum value in the second subsequences is 4 - 4 = 0.
|
||||
The difference between the maximum and minimum value in the third subsequences is 5 - 5 = 0.
|
||||
Since three subsequences were created, we return 3. It can be shown that 3 is the minimum number of subsequences needed.
|
||||
</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] <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>num</code> of length <code>n</code> consisting of digits.</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if for <strong>every</strong> index </em><code>i</code><em> in the range </em><code>0 <= i < n</code><em>, the digit </em><code>i</code><em> occurs </em><code>num[i]</code><em> times in </em><code>num</code><em>, otherwise return </em><code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "1210"
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong>
|
||||
num[0] = '1'. The digit 0 occurs once in num.
|
||||
num[1] = '2'. The digit 1 occurs twice in num.
|
||||
num[2] = '1'. The digit 2 occurs once in num.
|
||||
num[3] = '0'. The digit 3 occurs zero times in num.
|
||||
The condition holds true for every index in "1210", so return true.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "030"
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong>
|
||||
num[0] = '0'. The digit 0 should occur zero times, but actually occurs twice in num.
|
||||
num[1] = '3'. The digit 1 should occur three times, but actually occurs zero times in num.
|
||||
num[2] = '0'. The digit 2 occurs zero times in num.
|
||||
The indices 0 and 1 both violate the condition, so return false.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == num.length</code></li>
|
||||
<li><code>1 <= n <= 10</code></li>
|
||||
<li><code>num</code> consists of digits.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D integer array <code>grid</code> of size <code>m x n</code>. Each cell has one of two values:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0</code> represents an <strong>empty</strong> cell,</li>
|
||||
<li><code>1</code> represents an <strong>obstacle</strong> that may be removed.</li>
|
||||
</ul>
|
||||
|
||||
<p>You can move up, down, left, or right from and to an empty cell.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of <strong>obstacles</strong> to <strong>remove</strong> so you can move from the upper left corner </em><code>(0, 0)</code><em> to the lower right corner </em><code>(m - 1, n - 1)</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/04/06/example1drawio-1.png" style="width: 605px; height: 246px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,1,1],[1,1,0],[1,1,0]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can remove the obstacles at (0, 1) and (0, 2) to create a path from (0, 0) to (2, 2).
|
||||
It can be shown that we need to remove at least 2 obstacles, so we return 2.
|
||||
Note that there may be other ways to remove 2 obstacles to create a path.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/04/06/example1drawio.png" style="width: 405px; height: 246px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> We can move from (0, 0) to (2, 4) without removing any obstacles, so we return 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 10<sup>5</sup></code></li>
|
||||
<li><code>2 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>grid[i][j]</code> is either <code>0</code> <strong>or</strong> <code>1</code>.</li>
|
||||
<li><code>grid[0][0] == grid[m - 1][n - 1] == 0</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> that consists of <code>n</code> <strong>distinct</strong> positive integers. Apply <code>m</code> operations to this array, where in the <code>i<sup>th</sup></code> operation you replace the number <code>operations[i][0]</code> with <code>operations[i][1]</code>.</p>
|
||||
|
||||
<p>It is guaranteed that in the <code>i<sup>th</sup></code> operation:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>operations[i][0]</code> <strong>exists</strong> in <code>nums</code>.</li>
|
||||
<li><code>operations[i][1]</code> does <strong>not</strong> exist in <code>nums</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the array obtained after applying all the operations</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,4,6], operations = [[1,3],[4,7],[6,1]]
|
||||
<strong>Output:</strong> [3,2,7,1]
|
||||
<strong>Explanation:</strong> We perform the following operations on nums:
|
||||
- Replace the number 1 with 3. nums becomes [<u><strong>3</strong></u>,2,4,6].
|
||||
- Replace the number 4 with 7. nums becomes [3,2,<u><strong>7</strong></u>,6].
|
||||
- Replace the number 6 with 1. nums becomes [3,2,7,<u><strong>1</strong></u>].
|
||||
We return the final array [3,2,7,1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2], operations = [[1,3],[2,1],[3,2]]
|
||||
<strong>Output:</strong> [2,1]
|
||||
<strong>Explanation:</strong> We perform the following operations to nums:
|
||||
- Replace the number 1 with 3. nums becomes [<u><strong>3</strong></u>,2].
|
||||
- Replace the number 2 with 1. nums becomes [3,<u><strong>1</strong></u>].
|
||||
- Replace the number 3 with 2. nums becomes [<u><strong>2</strong></u>,1].
|
||||
We return the array [2,1].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>m == operations.length</code></li>
|
||||
<li><code>1 <= n, m <= 10<sup>5</sup></code></li>
|
||||
<li>All the values of <code>nums</code> are <strong>distinct</strong>.</li>
|
||||
<li><code>operations[i].length == 2</code></li>
|
||||
<li><code>1 <= nums[i], operations[i][0], operations[i][1] <= 10<sup>6</sup></code></li>
|
||||
<li><code>operations[i][0]</code> will exist in <code>nums</code> when applying the <code>i<sup>th</sup></code> operation.</li>
|
||||
<li><code>operations[i][1]</code> will not exist in <code>nums</code> when applying the <code>i<sup>th</sup></code> operation.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You have a chat log of <code>n</code> messages. You are given two string arrays <code>messages</code> and <code>senders</code> where <code>messages[i]</code> is a <strong>message</strong> sent by <code>senders[i]</code>.</p>
|
||||
|
||||
<p>A <strong>message</strong> is list of <strong>words</strong> that are separated by a single space with no leading or trailing spaces. The <strong>word count</strong> of a sender is the total number of <strong>words</strong> sent by the sender. Note that a sender may send more than one message.</p>
|
||||
|
||||
<p>Return <em>the sender with the <strong>largest</strong> word count</em>. If there is more than one sender with the largest word count, return <em>the one with the <strong>lexicographically largest</strong> name</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Uppercase letters come before lowercase letters in lexicographical order.</li>
|
||||
<li><code>"Alice"</code> and <code>"alice"</code> are distinct.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> messages = ["Hello userTwooo","Hi userThree","Wonderful day Alice","Nice day userThree"], senders = ["Alice","userTwo","userThree","Alice"]
|
||||
<strong>Output:</strong> "Alice"
|
||||
<strong>Explanation:</strong> Alice sends a total of 2 + 3 = 5 words.
|
||||
userTwo sends a total of 2 words.
|
||||
userThree sends a total of 3 words.
|
||||
Since Alice has the largest word count, we return "Alice".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> messages = ["How is leetcode for everyone","Leetcode is useful for practice"], senders = ["Bob","Charlie"]
|
||||
<strong>Output:</strong> "Charlie"
|
||||
<strong>Explanation:</strong> Bob sends a total of 5 words.
|
||||
Charlie sends a total of 5 words.
|
||||
Since there is a tie for the largest word count, we return the sender with the lexicographically larger name, Charlie.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == messages.length == senders.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= messages[i].length <= 100</code></li>
|
||||
<li><code>1 <= senders[i].length <= 10</code></li>
|
||||
<li><code>messages[i]</code> consists of uppercase and lowercase English letters and <code>' '</code>.</li>
|
||||
<li>All the words in <code>messages[i]</code> are separated by <strong>a single space</strong>.</li>
|
||||
<li><code>messages[i]</code> does not have leading or trailing spaces.</li>
|
||||
<li><code>senders[i]</code> consists of uppercase and lowercase English letters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> whose length is a power of <code>2</code>.</p>
|
||||
|
||||
<p>Apply the following algorithm on <code>nums</code>:</p>
|
||||
|
||||
<ol>
|
||||
<li>Let <code>n</code> be the length of <code>nums</code>. If <code>n == 1</code>, <strong>end</strong> the process. Otherwise, <strong>create</strong> a new <strong>0-indexed</strong> integer array <code>newNums</code> of length <code>n / 2</code>.</li>
|
||||
<li>For every <strong>even</strong> index <code>i</code> where <code>0 <= i < n / 2</code>, <strong>assign</strong> the value of <code>newNums[i]</code> as <code>min(nums[2 * i], nums[2 * i + 1])</code>.</li>
|
||||
<li>For every <strong>odd</strong> index <code>i</code> where <code>0 <= i < n / 2</code>, <strong>assign</strong> the value of <code>newNums[i]</code> as <code>max(nums[2 * i], nums[2 * i + 1])</code>.</li>
|
||||
<li><strong>Replace</strong> the array <code>nums</code> with <code>newNums</code>.</li>
|
||||
<li><strong>Repeat</strong> the entire process starting from step 1.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>the last number that remains in </em><code>nums</code><em> after applying the algorithm.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/04/13/example1drawio-1.png" style="width: 500px; height: 240px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,5,2,4,8,2,2]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The following arrays are the results of applying the algorithm repeatedly.
|
||||
First: nums = [1,5,4,2]
|
||||
Second: nums = [1,4]
|
||||
Third: nums = [1]
|
||||
1 is the last remaining number, so we return 1.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> 3 is already the last remaining number, so we return 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1024</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>nums.length</code> is a power of <code>2</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,67 @@
|
||||
<p>Design a text editor with a cursor that can do the following:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Add</strong> text to where the cursor is.</li>
|
||||
<li><strong>Delete</strong> text from where the cursor is (simulating the backspace key).</li>
|
||||
<li><strong>Move</strong> the cursor either left or right.</li>
|
||||
</ul>
|
||||
|
||||
<p>When deleting text, only characters to the left of the cursor will be deleted. The cursor will also remain within the actual text and cannot be moved beyond it. More formally, we have that <code>0 <= cursor.position <= currentText.length</code> always holds.</p>
|
||||
|
||||
<p>Implement the <code>TextEditor</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>TextEditor()</code> Initializes the object with empty text.</li>
|
||||
<li><code>void addText(string text)</code> Appends <code>text</code> to where the cursor is. The cursor ends to the right of <code>text</code>.</li>
|
||||
<li><code>int deleteText(int k)</code> Deletes <code>k</code> characters to the left of the cursor. Returns the number of characters actually deleted.</li>
|
||||
<li><code>string cursorLeft(int k)</code> Moves the cursor to the left <code>k</code> times. Returns the last <code>min(10, len)</code> characters to the left of the cursor, where <code>len</code> is the number of characters to the left of the cursor.</li>
|
||||
<li><code>string cursorRight(int k)</code> Moves the cursor to the right <code>k</code> times. Returns the last <code>min(10, len)</code> characters to the left of the cursor, where <code>len</code> is the number of characters to the left of the cursor.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["TextEditor", "addText", "deleteText", "addText", "cursorRight", "cursorLeft", "deleteText", "cursorLeft", "cursorRight"]
|
||||
[[], ["leetcode"], [4], ["practice"], [3], [8], [10], [2], [6]]
|
||||
<strong>Output</strong>
|
||||
[null, null, 4, null, "etpractice", "leet", 4, "", "practi"]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
TextEditor textEditor = new TextEditor(); // The current text is "|". (The '|' character represents the cursor)
|
||||
textEditor.addText("leetcode"); // The current text is "leetcode|".
|
||||
textEditor.deleteText(4); // return 4
|
||||
// The current text is "leet|".
|
||||
// 4 characters were deleted.
|
||||
textEditor.addText("practice"); // The current text is "leetpractice|".
|
||||
textEditor.cursorRight(3); // return "etpractice"
|
||||
// The current text is "leetpractice|".
|
||||
// The cursor cannot be moved beyond the actual text and thus did not move.
|
||||
// "etpractice" is the last 10 characters to the left of the cursor.
|
||||
textEditor.cursorLeft(8); // return "leet"
|
||||
// The current text is "leet|practice".
|
||||
// "leet" is the last min(10, 4) = 4 characters to the left of the cursor.
|
||||
textEditor.deleteText(10); // return 4
|
||||
// The current text is "|practice".
|
||||
// Only 4 characters were deleted.
|
||||
textEditor.cursorLeft(2); // return ""
|
||||
// The current text is "|practice".
|
||||
// The cursor cannot be moved beyond the actual text and thus did not move.
|
||||
// "" is the last min(10, 0) = 0 characters to the left of the cursor.
|
||||
textEditor.cursorRight(6); // return "practi"
|
||||
// The current text is "practi|ce".
|
||||
// "practi" is the last min(10, 6) = 6 characters to the left of the cursor.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length, k <= 40</code></li>
|
||||
<li><code>text</code> consists of lowercase English letters.</li>
|
||||
<li>At most <code>2 * 10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>addText</code>, <code>deleteText</code>, <code>cursorLeft</code> and <code>cursorRight</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow-up:</strong> Could you find a solution with time complexity of <code>O(k)</code> per call?</p>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>You are given an integer <code>n</code> denoting the number of cities in a country. The cities are numbered from <code>0</code> to <code>n - 1</code>.</p>
|
||||
|
||||
<p>You are also given a 2D integer array <code>roads</code> where <code>roads[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists a <strong>bidirectional</strong> road connecting cities <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.</p>
|
||||
|
||||
<p>You need to assign each city with an integer value from <code>1</code> to <code>n</code>, where each value can only be used <strong>once</strong>. The <strong>importance</strong> of a road is then defined as the <strong>sum</strong> of the values of the two cities it connects.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum total importance</strong> of all roads possible after assigning the values optimally.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/04/07/ex1drawio.png" style="width: 290px; height: 215px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, roads = [[0,1],[1,2],[2,3],[0,2],[1,3],[2,4]]
|
||||
<strong>Output:</strong> 43
|
||||
<strong>Explanation:</strong> The figure above shows the country and the assigned values of [2,4,5,3,1].
|
||||
- The road (0,1) has an importance of 2 + 4 = 6.
|
||||
- The road (1,2) has an importance of 4 + 5 = 9.
|
||||
- The road (2,3) has an importance of 5 + 3 = 8.
|
||||
- The road (0,2) has an importance of 2 + 5 = 7.
|
||||
- The road (1,3) has an importance of 4 + 3 = 7.
|
||||
- The road (2,4) has an importance of 5 + 1 = 6.
|
||||
The total importance of all roads is 6 + 9 + 8 + 7 + 7 + 6 = 43.
|
||||
It can be shown that we cannot obtain a greater total importance than 43.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/04/07/ex2drawio.png" style="width: 281px; height: 151px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, roads = [[0,3],[2,4],[1,3]]
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation:</strong> The figure above shows the country and the assigned values of [4,3,2,5,1].
|
||||
- The road (0,3) has an importance of 4 + 5 = 9.
|
||||
- The road (2,4) has an importance of 2 + 1 = 3.
|
||||
- The road (1,3) has an importance of 3 + 5 = 8.
|
||||
The total importance of all roads is 9 + 3 + 8 = 20.
|
||||
It can be shown that we cannot obtain a greater total importance than 20.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= roads.length <= 5 * 10<sup>4</sup></code></li>
|
||||
<li><code>roads[i].length == 2</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
<li>There are no duplicate roads.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given two <strong>0-indexed</strong> strings <code>s</code> and <code>target</code>. You can take some letters from <code>s</code> and rearrange them to form new strings.</p>
|
||||
|
||||
<p>Return<em> the <strong>maximum</strong> number of copies of </em><code>target</code><em> that can be formed by taking letters from </em><code>s</code><em> and rearranging them.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ilovecodingonleetcode", target = "code"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong>
|
||||
For the first copy of "code", take the letters at indices 4, 5, 6, and 7.
|
||||
For the second copy of "code", take the letters at indices 17, 18, 19, and 20.
|
||||
The strings that are formed are "ecod" and "code" which can both be rearranged into "code".
|
||||
We can make at most two copies of "code", so we return 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcba", target = "abc"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
We can make one copy of "abc" by taking the letters at indices 0, 1, and 2.
|
||||
We can make at most one copy of "abc", so we return 1.
|
||||
Note that while there is an extra 'a' and 'b' at indices 3 and 4, we cannot reuse the letter 'c' at index 2, so we cannot make a second copy of "abc".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abbaccaddaeea", target = "aaaaa"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
We can make one copy of "aaaaa" by taking the letters at indices 0, 3, 6, 9, and 12.
|
||||
We can make at most one copy of "aaaaa", so we return 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>1 <= target.length <= 10</code></li>
|
||||
<li><code>s</code> and <code>target</code> consist of lowercase English letters.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user