task_id
stringlengths 33
83
| url
stringlengths 44
94
| title
stringlengths 14
64
| meta
dict | prompt
stringlengths 718
3.82k
| prompt_sft
stringlengths 780
3.89k
| test
stringlengths 8.25k
44.9k
| start_time
int64 1.69B
1.71B
|
|---|---|---|---|---|---|---|---|
weekly-contest-381-minimum-number-of-pushes-to-type-word-i | https://leetcode.com/problems/minimum-number-of-pushes-to-type-word-i | minimum-number-of-pushes-to-type-word-i | {
"questionId": "3275",
"questionFrontendId": "3014",
"title": "Minimum Number of Pushes to Type Word I",
"titleSlug": "minimum-number-of-pushes-to-type-word-i",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 39,
"dislikes": 7,
"categoryTitle": "Algorithms"
} | """
You are given a string word containing distinct lowercase English letters.
Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c" .
It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word.
Return the minimum number of pushes needed to type word after remapping the keys.
An example mapping of letters to keys on a telephone keypad is given below. Note that 1, *, #, and 0 do not map to any letters.
Example 1:
Input: word = "abcde"
Output: 5
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
It can be shown that no other mapping can provide a lower cost.
Example 2:
Input: word = "xycdefghij"
Output: 12
Explanation: The remapped keypad given in the image provides the minimum cost.
"x" -> one push on key 2
"y" -> two pushes on key 2
"c" -> one push on key 3
"d" -> two pushes on key 3
"e" -> one push on key 4
"f" -> one push on key 5
"g" -> one push on key 6
"h" -> one push on key 7
"i" -> one push on key 8
"j" -> one push on key 9
Total cost is 1 + 2 + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 = 12.
It can be shown that no other mapping can provide a lower cost.
Constraints:
1 <= word.length <= 26
word consists of lowercase English letters.
All letters in word are distinct.
"""
class Solution:
def minimumPushes(self, word: str) -> int:
| You are given a string word containing distinct lowercase English letters.
Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c" .
It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word.
Return the minimum number of pushes needed to type word after remapping the keys.
An example mapping of letters to keys on a telephone keypad is given below. Note that 1, *, #, and 0 do not map to any letters.
Example 1:
Input: word = "abcde"
Output: 5
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
It can be shown that no other mapping can provide a lower cost.
Example 2:
Input: word = "xycdefghij"
Output: 12
Explanation: The remapped keypad given in the image provides the minimum cost.
"x" -> one push on key 2
"y" -> two pushes on key 2
"c" -> one push on key 3
"d" -> two pushes on key 3
"e" -> one push on key 4
"f" -> one push on key 5
"g" -> one push on key 6
"h" -> one push on key 7
"i" -> one push on key 8
"j" -> one push on key 9
Total cost is 1 + 2 + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 = 12.
It can be shown that no other mapping can provide a lower cost.
Constraints:
1 <= word.length <= 26
word consists of lowercase English letters.
All letters in word are distinct.
Please complete the code below to solve above prblem:
```python
class Solution:
def minimumPushes(self, word: str) -> int:
``` |
my_solution = Solution()
test_input = { "word": "abcde" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "xycdefghij" }
assert my_solution.minimumPushes(**test_input) == 12
test_input = { "word": "b" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "d" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "e" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "f" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "g" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "h" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "i" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "k" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "n" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "o" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "q" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "u" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "v" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "w" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "x" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "bc" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "cu" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "dl" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "dn" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ev" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "gn" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "gq" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "hu" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "jr" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ln" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "lz" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "mv" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "mw" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "sw" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "wz" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "amw" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "bco" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "btx" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cgp" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cjq" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "clu" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "clx" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "crs" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "csz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "dfp" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "htv" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "iwz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "kux" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "nsv" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "svz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cfos" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "demr" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "dimo" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "dnpt" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "dorz" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "fgkn" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "fimn" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "hior" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "jkpy" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "jluv" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "knpv" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "kopu" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "lmpt" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "ltuw" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "qwxz" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "abhoz" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "aejwx" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "agjnr" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "aikmu" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "ajkmv" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "cflvx" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "dhstu" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "djmnx" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "dlovx" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "eglqy" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "ejntw" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "ekrsz" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "fopuz" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "jlnvz" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "jnstu" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "afikno" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "almsyz" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bcehov" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bdmprt" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bfhmnu" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bfhpty" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bfjstu" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "cdfjmw" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "dfilps" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "dmswyz" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "dpqruw" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "fhmprz" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "gjqrvy" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "ijopsv" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "lmqrtz" }
assert my_solution.minimumPushes(**test_input) == 6
test_input = { "word": "bxnqpha" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "ekbfqat" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "esoizcx" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "fmteczo" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "lrywetm" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "lvbornx" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "pesmonc" }
assert my_solution.minimumPushes(**test_input) == 7
test_input = { "word": "pudymjw" }
assert my_solution.minimumPushes(**test_input) == 7 | 1,705,804,200 |
weekly-contest-381-count-the-number-of-houses-at-a-certain-distance-i | https://leetcode.com/problems/count-the-number-of-houses-at-a-certain-distance-i | count-the-number-of-houses-at-a-certain-distance-i | {
"questionId": "3271",
"questionFrontendId": "3015",
"title": "Count the Number of Houses at a Certain Distance I",
"titleSlug": "count-the-number-of-houses-at-a-certain-distance-i",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 62,
"dislikes": 7,
"categoryTitle": "Algorithms"
} | """
You are given three positive integers n, x, and y.
In a city, there exist houses numbered 1 to n connected by n streets. There is a street connecting the house numbered i with the house numbered i + 1 for all 1 <= i <= n - 1 . An additional street connects the house numbered x with the house numbered y.
For each k, such that 1 <= k <= n, you need to find the number of pairs of houses (house1, house2) such that the minimum number of streets that need to be traveled to reach house2 from house1 is k.
Return a 1-indexed array result of length n where result[k] represents the total number of pairs of houses such that the minimum streets required to reach one house from the other is k.
Note that x and y can be equal.
Example 1:
Input: n = 3, x = 1, y = 3
Output: [6,0,0]
Explanation: Let's look at each pair of houses:
- For the pair (1, 2), we can go from house 1 to house 2 directly.
- For the pair (2, 1), we can go from house 2 to house 1 directly.
- For the pair (1, 3), we can go from house 1 to house 3 directly.
- For the pair (3, 1), we can go from house 3 to house 1 directly.
- For the pair (2, 3), we can go from house 2 to house 3 directly.
- For the pair (3, 2), we can go from house 3 to house 2 directly.
Example 2:
Input: n = 5, x = 2, y = 4
Output: [10,8,2,0,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
- For k == 3, the pairs are (1, 5), and (5, 1).
- For k == 4 and k == 5, there are no pairs.
Example 3:
Input: n = 4, x = 1, y = 1
Output: [6,4,2,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
- For k == 3, the pairs are (1, 4), and (4, 1).
- For k == 4, there are no pairs.
Constraints:
2 <= n <= 100
1 <= x, y <= n
"""
class Solution:
def countOfPairs(self, n: int, x: int, y: int) -> List[int]:
| You are given three positive integers n, x, and y.
In a city, there exist houses numbered 1 to n connected by n streets. There is a street connecting the house numbered i with the house numbered i + 1 for all 1 <= i <= n - 1 . An additional street connects the house numbered x with the house numbered y.
For each k, such that 1 <= k <= n, you need to find the number of pairs of houses (house1, house2) such that the minimum number of streets that need to be traveled to reach house2 from house1 is k.
Return a 1-indexed array result of length n where result[k] represents the total number of pairs of houses such that the minimum streets required to reach one house from the other is k.
Note that x and y can be equal.
Example 1:
Input: n = 3, x = 1, y = 3
Output: [6,0,0]
Explanation: Let's look at each pair of houses:
- For the pair (1, 2), we can go from house 1 to house 2 directly.
- For the pair (2, 1), we can go from house 2 to house 1 directly.
- For the pair (1, 3), we can go from house 1 to house 3 directly.
- For the pair (3, 1), we can go from house 3 to house 1 directly.
- For the pair (2, 3), we can go from house 2 to house 3 directly.
- For the pair (3, 2), we can go from house 3 to house 2 directly.
Example 2:
Input: n = 5, x = 2, y = 4
Output: [10,8,2,0,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
- For k == 3, the pairs are (1, 5), and (5, 1).
- For k == 4 and k == 5, there are no pairs.
Example 3:
Input: n = 4, x = 1, y = 1
Output: [6,4,2,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
- For k == 3, the pairs are (1, 4), and (4, 1).
- For k == 4, there are no pairs.
Constraints:
2 <= n <= 100
1 <= x, y <= n
Please complete the code below to solve above prblem:
```python
class Solution:
def countOfPairs(self, n: int, x: int, y: int) -> List[int]:
``` |
my_solution = Solution()
test_input = { "n": 3, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,0,0]
test_input = { "n": 5, "x": 2, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 4, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 2, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 3, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,0,0]
test_input = { "n": 3, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 4, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 3, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 4, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 4, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 5, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 1, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,10,0,0,0]
test_input = { "n": 5, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 2, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 3, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 3, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 4, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 4, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 4, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 5, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [10,10,0,0,0]
test_input = { "n": 5, "x": 5, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 5, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 5, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 5, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 6, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 1, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 1, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 2, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 2, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 3, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 3, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 3, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 4, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 4, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 4, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 5, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 5, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 5, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 5, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 5, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 5, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 6, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 6, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 6, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 6, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 6, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 6, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 7, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [14,10,8,6,4,0,0]
test_input = { "n": 7, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [14,12,8,6,2,0,0]
test_input = { "n": 7, "x": 1, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [14,16,8,4,0,0,0]
test_input = { "n": 7, "x": 1, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [14,16,10,2,0,0,0]
test_input = { "n": 7, "x": 1, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,14,14,0,0,0,0]
test_input = { "n": 7, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 2, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,16,10,2,0,0,0]
test_input = { "n": 7, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [14,10,8,6,4,0,0]
test_input = { "n": 7, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0] | 1,705,804,200 |
weekly-contest-381-minimum-number-of-pushes-to-type-word-ii | https://leetcode.com/problems/minimum-number-of-pushes-to-type-word-ii | minimum-number-of-pushes-to-type-word-ii | {
"questionId": "3276",
"questionFrontendId": "3016",
"title": "Minimum Number of Pushes to Type Word II",
"titleSlug": "minimum-number-of-pushes-to-type-word-ii",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 59,
"dislikes": 2,
"categoryTitle": "Algorithms"
} | """
You are given a string word containing lowercase English letters.
Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c" .
It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word.
Return the minimum number of pushes needed to type word after remapping the keys.
An example mapping of letters to keys on a telephone keypad is given below. Note that 1, *, #, and 0 do not map to any letters.
Example 1:
Input: word = "abcde"
Output: 5
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
It can be shown that no other mapping can provide a lower cost.
Example 2:
Input: word = "xyzxyzxyzxyz"
Output: 12
Explanation: The remapped keypad given in the image provides the minimum cost.
"x" -> one push on key 2
"y" -> one push on key 3
"z" -> one push on key 4
Total cost is 1 * 4 + 1 * 4 + 1 * 4 = 12
It can be shown that no other mapping can provide a lower cost.
Note that the key 9 is not mapped to any letter: it is not necessary to map letters to every key, but to map all the letters.
Example 3:
Input: word = "aabbccddeeffgghhiiiiii"
Output: 24
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
"f" -> one push on key 7
"g" -> one push on key 8
"h" -> two pushes on key 9
"i" -> one push on key 9
Total cost is 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 2 * 2 + 6 * 1 = 24.
It can be shown that no other mapping can provide a lower cost.
Constraints:
1 <= word.length <= 105
word consists of lowercase English letters.
"""
class Solution:
def minimumPushes(self, word: str) -> int:
| You are given a string word containing lowercase English letters.
Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c" .
It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word.
Return the minimum number of pushes needed to type word after remapping the keys.
An example mapping of letters to keys on a telephone keypad is given below. Note that 1, *, #, and 0 do not map to any letters.
Example 1:
Input: word = "abcde"
Output: 5
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
It can be shown that no other mapping can provide a lower cost.
Example 2:
Input: word = "xyzxyzxyzxyz"
Output: 12
Explanation: The remapped keypad given in the image provides the minimum cost.
"x" -> one push on key 2
"y" -> one push on key 3
"z" -> one push on key 4
Total cost is 1 * 4 + 1 * 4 + 1 * 4 = 12
It can be shown that no other mapping can provide a lower cost.
Note that the key 9 is not mapped to any letter: it is not necessary to map letters to every key, but to map all the letters.
Example 3:
Input: word = "aabbccddeeffgghhiiiiii"
Output: 24
Explanation: The remapped keypad given in the image provides the minimum cost.
"a" -> one push on key 2
"b" -> one push on key 3
"c" -> one push on key 4
"d" -> one push on key 5
"e" -> one push on key 6
"f" -> one push on key 7
"g" -> one push on key 8
"h" -> two pushes on key 9
"i" -> one push on key 9
Total cost is 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 2 * 2 + 6 * 1 = 24.
It can be shown that no other mapping can provide a lower cost.
Constraints:
1 <= word.length <= 105
word consists of lowercase English letters.
Please complete the code below to solve above prblem:
```python
class Solution:
def minimumPushes(self, word: str) -> int:
``` |
my_solution = Solution()
test_input = { "word": "abcde" }
assert my_solution.minimumPushes(**test_input) == 5
test_input = { "word": "xyzxyzxyzxyz" }
assert my_solution.minimumPushes(**test_input) == 12
test_input = { "word": "aabbccddeeffgghhiiiiii" }
assert my_solution.minimumPushes(**test_input) == 24
test_input = { "word": "a" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "f" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "h" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "i" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "l" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "o" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "q" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "s" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "t" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "u" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "x" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "y" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "z" }
assert my_solution.minimumPushes(**test_input) == 1
test_input = { "word": "at" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "aw" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "bd" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "bs" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ck" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "de" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ex" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "fy" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "fz" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "hu" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ir" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "iz" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "km" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "lr" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "lu" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "mz" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "ng" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "nu" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "oo" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "qc" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "rv" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "se" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "up" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "wb" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "xg" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "yg" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "zv" }
assert my_solution.minimumPushes(**test_input) == 2
test_input = { "word": "abx" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "amw" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "bem" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "bhs" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "blg" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "bwq" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cku" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cmo" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "cnr" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "dgh" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "dmh" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "dqf" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "eys" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "fff" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "foz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "fqw" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "fsh" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "gjz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "gpx" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "gqu" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "jcc" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "nmu" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "pzm" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "rdz" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "rvy" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "rya" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "sbn" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "szd" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "tbd" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "uqk" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "vbh" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "vgr" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "vxy" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "xbp" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "yex" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "ynx" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "yuv" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "zih" }
assert my_solution.minimumPushes(**test_input) == 3
test_input = { "word": "acpy" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "ainw" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "aluw" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "ayfb" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "bbmr" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "bgta" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "bitn" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "bwif" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "bwrz" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "cdcl" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "dglo" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "dxng" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "earx" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "feig" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "fgjk" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "flmd" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "fnfp" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "glms" }
assert my_solution.minimumPushes(**test_input) == 4
test_input = { "word": "glou" }
assert my_solution.minimumPushes(**test_input) == 4 | 1,705,804,200 |
weekly-contest-381-count-the-number-of-houses-at-a-certain-distance-ii | https://leetcode.com/problems/count-the-number-of-houses-at-a-certain-distance-ii | count-the-number-of-houses-at-a-certain-distance-ii | {
"questionId": "3310",
"questionFrontendId": "3017",
"title": "Count the Number of Houses at a Certain Distance II",
"titleSlug": "count-the-number-of-houses-at-a-certain-distance-ii",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 27,
"dislikes": 12,
"categoryTitle": "Algorithms"
} | """
You are given three positive integers n, x, and y.
In a city, there exist houses numbered 1 to n connected by n streets. There is a street connecting the house numbered i with the house numbered i + 1 for all 1 <= i <= n - 1 . An additional street connects the house numbered x with the house numbered y.
For each k, such that 1 <= k <= n, you need to find the number of pairs of houses (house1, house2) such that the minimum number of streets that need to be traveled to reach house2 from house1 is k.
Return a 1-indexed array result of length n where result[k] represents the total number of pairs of houses such that the minimum streets required to reach one house from the other is k.
Note that x and y can be equal.
Example 1:
Input: n = 3, x = 1, y = 3
Output: [6,0,0]
Explanation: Let's look at each pair of houses:
- For the pair (1, 2), we can go from house 1 to house 2 directly.
- For the pair (2, 1), we can go from house 2 to house 1 directly.
- For the pair (1, 3), we can go from house 1 to house 3 directly.
- For the pair (3, 1), we can go from house 3 to house 1 directly.
- For the pair (2, 3), we can go from house 2 to house 3 directly.
- For the pair (3, 2), we can go from house 3 to house 2 directly.
Example 2:
Input: n = 5, x = 2, y = 4
Output: [10,8,2,0,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
- For k == 3, the pairs are (1, 5), and (5, 1).
- For k == 4 and k == 5, there are no pairs.
Example 3:
Input: n = 4, x = 1, y = 1
Output: [6,4,2,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
- For k == 3, the pairs are (1, 4), and (4, 1).
- For k == 4, there are no pairs.
Constraints:
2 <= n <= 105
1 <= x, y <= n
"""
class Solution:
def countOfPairs(self, n: int, x: int, y: int) -> List[int]:
| You are given three positive integers n, x, and y.
In a city, there exist houses numbered 1 to n connected by n streets. There is a street connecting the house numbered i with the house numbered i + 1 for all 1 <= i <= n - 1 . An additional street connects the house numbered x with the house numbered y.
For each k, such that 1 <= k <= n, you need to find the number of pairs of houses (house1, house2) such that the minimum number of streets that need to be traveled to reach house2 from house1 is k.
Return a 1-indexed array result of length n where result[k] represents the total number of pairs of houses such that the minimum streets required to reach one house from the other is k.
Note that x and y can be equal.
Example 1:
Input: n = 3, x = 1, y = 3
Output: [6,0,0]
Explanation: Let's look at each pair of houses:
- For the pair (1, 2), we can go from house 1 to house 2 directly.
- For the pair (2, 1), we can go from house 2 to house 1 directly.
- For the pair (1, 3), we can go from house 1 to house 3 directly.
- For the pair (3, 1), we can go from house 3 to house 1 directly.
- For the pair (2, 3), we can go from house 2 to house 3 directly.
- For the pair (3, 2), we can go from house 3 to house 2 directly.
Example 2:
Input: n = 5, x = 2, y = 4
Output: [10,8,2,0,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
- For k == 3, the pairs are (1, 5), and (5, 1).
- For k == 4 and k == 5, there are no pairs.
Example 3:
Input: n = 4, x = 1, y = 1
Output: [6,4,2,0]
Explanation: For each distance k the pairs are:
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
- For k == 3, the pairs are (1, 4), and (4, 1).
- For k == 4, there are no pairs.
Constraints:
2 <= n <= 105
1 <= x, y <= n
Please complete the code below to solve above prblem:
```python
class Solution:
def countOfPairs(self, n: int, x: int, y: int) -> List[int]:
``` |
my_solution = Solution()
test_input = { "n": 3, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,0,0]
test_input = { "n": 5, "x": 2, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 4, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 2, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 2, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [2,0]
test_input = { "n": 3, "x": 1, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,0,0]
test_input = { "n": 3, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 3, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [4,2,0]
test_input = { "n": 4, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 2, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 2, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 3, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 3, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 3, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 4, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 4, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,4,0,0]
test_input = { "n": 4, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 4, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [6,4,2,0]
test_input = { "n": 5, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 2, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 2, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 3, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 4, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,2,0,0]
test_input = { "n": 5, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 5, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,6,4,0,0]
test_input = { "n": 5, "x": 5, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 5, "x": 5, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [8,6,4,2,0]
test_input = { "n": 6, "x": 1, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 1, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 1, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 3, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [12,10,6,2,0,0]
test_input = { "n": 6, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 4, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 4, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 5, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,12,6,0,0,0]
test_input = { "n": 6, "x": 5, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 6, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,14,4,0,0,0]
test_input = { "n": 6, "x": 6, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,8,6,4,0,0]
test_input = { "n": 6, "x": 6, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 6, "x": 6, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [10,8,6,4,2,0]
test_input = { "n": 7, "x": 1, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,14,14,0,0,0,0]
test_input = { "n": 7, "x": 2, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [14,18,10,0,0,0,0]
test_input = { "n": 7, "x": 3, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 3, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 3, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [14,14,10,4,0,0,0]
test_input = { "n": 7, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 4, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,12,8,6,2,0,0]
test_input = { "n": 7, "x": 5, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,4,2,0,0]
test_input = { "n": 7, "x": 5, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 5, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,10,8,6,4,0,0]
test_input = { "n": 7, "x": 6, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 6, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [12,10,8,6,4,2,0]
test_input = { "n": 7, "x": 7, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [14,12,8,6,2,0,0]
test_input = { "n": 8, "x": 1, "y": 2 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 2, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [16,20,16,4,0,0,0,0]
test_input = { "n": 8, "x": 3, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,8,4,2,0,0]
test_input = { "n": 8, "x": 3, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [16,16,14,8,2,0,0,0]
test_input = { "n": 8, "x": 4, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 4, "y": 8 }
assert my_solution.countOfPairs(**test_input) == [16,18,10,8,4,0,0,0]
test_input = { "n": 8, "x": 5, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,8,4,2,0,0]
test_input = { "n": 8, "x": 5, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [16,14,10,8,6,2,0,0]
test_input = { "n": 8, "x": 6, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [16,16,14,8,2,0,0,0]
test_input = { "n": 8, "x": 6, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 6, "y": 8 }
assert my_solution.countOfPairs(**test_input) == [16,12,10,8,6,4,0,0]
test_input = { "n": 8, "x": 7, "y": 8 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 8, "y": 1 }
assert my_solution.countOfPairs(**test_input) == [16,16,16,8,0,0,0,0]
test_input = { "n": 8, "x": 8, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 8, "x": 8, "y": 8 }
assert my_solution.countOfPairs(**test_input) == [14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 1, "y": 3 }
assert my_solution.countOfPairs(**test_input) == [18,14,12,10,8,6,4,0,0]
test_input = { "n": 9, "x": 4, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 4, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [18,16,14,12,6,4,2,0,0]
test_input = { "n": 9, "x": 4, "y": 9 }
assert my_solution.countOfPairs(**test_input) == [18,20,16,10,6,2,0,0,0]
test_input = { "n": 9, "x": 5, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 5, "y": 9 }
assert my_solution.countOfPairs(**test_input) == [18,20,12,10,8,4,0,0,0]
test_input = { "n": 9, "x": 6, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 7, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 8, "y": 4 }
assert my_solution.countOfPairs(**test_input) == [18,22,16,10,6,0,0,0,0]
test_input = { "n": 9, "x": 8, "y": 6 }
assert my_solution.countOfPairs(**test_input) == [18,16,12,10,8,6,2,0,0]
test_input = { "n": 9, "x": 8, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 8, "y": 9 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0]
test_input = { "n": 9, "x": 9, "y": 5 }
assert my_solution.countOfPairs(**test_input) == [18,20,12,10,8,4,0,0,0]
test_input = { "n": 9, "x": 9, "y": 7 }
assert my_solution.countOfPairs(**test_input) == [18,14,12,10,8,6,4,0,0]
test_input = { "n": 9, "x": 9, "y": 8 }
assert my_solution.countOfPairs(**test_input) == [16,14,12,10,8,6,4,2,0] | 1,705,804,200 |
biweekly-contest-122-divide-an-array-into-subarrays-with-minimum-cost-i | https://leetcode.com/problems/divide-an-array-into-subarrays-with-minimum-cost-i | divide-an-array-into-subarrays-with-minimum-cost-i | {
"questionId": "3263",
"questionFrontendId": "3010",
"title": "Divide an Array Into Subarrays With Minimum Cost I",
"titleSlug": "divide-an-array-into-subarrays-with-minimum-cost-i",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 40,
"dislikes": 2,
"categoryTitle": "Algorithms"
} | """
You are given an array of integers nums of length n.
The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3.
You need to divide nums into 3 disjoint contiguous subarrays.
Return the minimum possible sum of the cost of these subarrays.
Example 1:
Input: nums = [1,2,3,12]
Output: 6
Explanation: The best possible way to form 3 subarrays is: [1], [2], and [3,12] at a total cost of 1 + 2 + 3 = 6.
The other possible ways to form 3 subarrays are:
- [1], [2,3], and [12] at a total cost of 1 + 2 + 12 = 15.
- [1,2], [3], and [12] at a total cost of 1 + 3 + 12 = 16.
Example 2:
Input: nums = [5,4,3]
Output: 12
Explanation: The best possible way to form 3 subarrays is: [5], [4], and [3] at a total cost of 5 + 4 + 3 = 12.
It can be shown that 12 is the minimum cost achievable.
Example 3:
Input: nums = [10,3,1,1]
Output: 12
Explanation: The best possible way to form 3 subarrays is: [10,3], [1], and [1] at a total cost of 10 + 1 + 1 = 12.
It can be shown that 12 is the minimum cost achievable.
Constraints:
3 <= n <= 50
1 <= nums[i] <= 50
"""
class Solution:
def minimumCost(self, nums: List[int]) -> int:
| You are given an array of integers nums of length n.
The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3.
You need to divide nums into 3 disjoint contiguous subarrays.
Return the minimum possible sum of the cost of these subarrays.
Example 1:
Input: nums = [1,2,3,12]
Output: 6
Explanation: The best possible way to form 3 subarrays is: [1], [2], and [3,12] at a total cost of 1 + 2 + 3 = 6.
The other possible ways to form 3 subarrays are:
- [1], [2,3], and [12] at a total cost of 1 + 2 + 12 = 15.
- [1,2], [3], and [12] at a total cost of 1 + 3 + 12 = 16.
Example 2:
Input: nums = [5,4,3]
Output: 12
Explanation: The best possible way to form 3 subarrays is: [5], [4], and [3] at a total cost of 5 + 4 + 3 = 12.
It can be shown that 12 is the minimum cost achievable.
Example 3:
Input: nums = [10,3,1,1]
Output: 12
Explanation: The best possible way to form 3 subarrays is: [10,3], [1], and [1] at a total cost of 10 + 1 + 1 = 12.
It can be shown that 12 is the minimum cost achievable.
Constraints:
3 <= n <= 50
1 <= nums[i] <= 50
Please complete the code below to solve above prblem:
```python
class Solution:
def minimumCost(self, nums: List[int]) -> int:
``` |
my_solution = Solution()
test_input = { "nums": [1,2,3,12] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [5,4,3] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [10,3,1,1] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [1,1,1] }
assert my_solution.minimumCost(**test_input) == 3
test_input = { "nums": [1,1,2] }
assert my_solution.minimumCost(**test_input) == 4
test_input = { "nums": [1,1,3] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [1,1,4] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [1,1,5] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [1,2,1] }
assert my_solution.minimumCost(**test_input) == 4
test_input = { "nums": [1,2,2] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [1,2,3] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [1,2,4] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [1,2,5] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [1,3,1] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [1,3,2] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [1,3,3] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [1,3,4] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [1,3,5] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,4,1] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [1,4,2] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [1,4,3] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [1,4,4] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,4,5] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [1,5,1] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [1,5,2] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [1,5,3] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,4] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [1,5,5] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [2,1,1] }
assert my_solution.minimumCost(**test_input) == 4
test_input = { "nums": [2,1,2] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [2,1,3] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [2,1,4] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [2,1,5] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [2,2,1] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [2,2,2] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [2,2,3] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [2,2,4] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [2,2,5] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,3,1] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [2,3,2] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [2,3,3] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [2,3,4] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,3,5] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,4,1] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [2,4,2] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [2,4,3] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,4,4] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,4,5] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [2,5,1] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [2,5,2] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,5,3] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,5,4] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [2,5,5] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,1,1] }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [3,1,2] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [3,1,3] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [3,1,4] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,1,5] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [3,2,1] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [3,2,2] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [3,2,3] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,2,4] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [3,2,5] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [3,3,1] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [3,3,2] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,3,3] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [3,3,4] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [3,3,5] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,4,1] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,4,2] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [3,4,3] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [3,4,4] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,4,5] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,5,1] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [3,5,2] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [3,5,3] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,5,4] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,5,5] }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,1,1] }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [4,1,2] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [4,1,3] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [4,1,4] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,1,5] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,2,1] }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [4,2,2] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [4,2,3] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,2,4] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,2,5] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [4,3,1] }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [4,3,2] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,3,3] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,3,4] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [4,3,5] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,4,1] }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,4,2] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,4,3] }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [4,4,4] }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,4,5] }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,5,1] }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,5,2] }
assert my_solution.minimumCost(**test_input) == 11 | 1,705,761,000 |
biweekly-contest-122-find-if-array-can-be-sorted | https://leetcode.com/problems/find-if-array-can-be-sorted | find-if-array-can-be-sorted | {
"questionId": "3291",
"questionFrontendId": "3011",
"title": "Find if Array Can Be Sorted",
"titleSlug": "find-if-array-can-be-sorted",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 52,
"dislikes": 7,
"categoryTitle": "Algorithms"
} | """
You are given a 0-indexed array of positive integers nums.
In one operation, you can swap any two adjacent elements if they have the same number of set bits. You are allowed to do this operation any number of times (including zero).
Return true if you can sort the array, else return false.
Example 1:
Input: nums = [8,4,2,30,15]
Output: true
Explanation: Let's look at the binary representation of every element. The numbers 2, 4, and 8 have one set bit each with binary representation "10", "100", and "1000" respectively. The numbers 15 and 30 have four set bits each with binary representation "1111" and "11110".
We can sort the array using 4 operations:
- Swap nums[0] with nums[1]. This operation is valid because 8 and 4 have one set bit each. The array becomes [4,8,2,30,15].
- Swap nums[1] with nums[2]. This operation is valid because 8 and 2 have one set bit each. The array becomes [4,2,8,30,15].
- Swap nums[0] with nums[1]. This operation is valid because 4 and 2 have one set bit each. The array becomes [2,4,8,30,15].
- Swap nums[3] with nums[4]. This operation is valid because 30 and 15 have four set bits each. The array becomes [2,4,8,15,30].
The array has become sorted, hence we return true.
Note that there may be other sequences of operations which also sort the array.
Example 2:
Input: nums = [1,2,3,4,5]
Output: true
Explanation: The array is already sorted, hence we return true.
Example 3:
Input: nums = [3,16,8,4,2]
Output: false
Explanation: It can be shown that it is not possible to sort the input array using any number of operations.
Constraints:
1 <= nums.length <= 100
1 <= nums[i] <= 28
"""
class Solution:
def canSortArray(self, nums: List[int]) -> bool:
| You are given a 0-indexed array of positive integers nums.
In one operation, you can swap any two adjacent elements if they have the same number of set bits. You are allowed to do this operation any number of times (including zero).
Return true if you can sort the array, else return false.
Example 1:
Input: nums = [8,4,2,30,15]
Output: true
Explanation: Let's look at the binary representation of every element. The numbers 2, 4, and 8 have one set bit each with binary representation "10", "100", and "1000" respectively. The numbers 15 and 30 have four set bits each with binary representation "1111" and "11110".
We can sort the array using 4 operations:
- Swap nums[0] with nums[1]. This operation is valid because 8 and 4 have one set bit each. The array becomes [4,8,2,30,15].
- Swap nums[1] with nums[2]. This operation is valid because 8 and 2 have one set bit each. The array becomes [4,2,8,30,15].
- Swap nums[0] with nums[1]. This operation is valid because 4 and 2 have one set bit each. The array becomes [2,4,8,30,15].
- Swap nums[3] with nums[4]. This operation is valid because 30 and 15 have four set bits each. The array becomes [2,4,8,15,30].
The array has become sorted, hence we return true.
Note that there may be other sequences of operations which also sort the array.
Example 2:
Input: nums = [1,2,3,4,5]
Output: true
Explanation: The array is already sorted, hence we return true.
Example 3:
Input: nums = [3,16,8,4,2]
Output: false
Explanation: It can be shown that it is not possible to sort the input array using any number of operations.
Constraints:
1 <= nums.length <= 100
1 <= nums[i] <= 28
Please complete the code below to solve above prblem:
```python
class Solution:
def canSortArray(self, nums: List[int]) -> bool:
``` |
my_solution = Solution()
test_input = { "nums": [8,4,2,30,15] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [1,2,3,4,5] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [1] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [4] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [3,16,8,4,2] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [7] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [10] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [20,16] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [18] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [21,17] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [30] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [26,10] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [1,2] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [2,28,9] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [2,17] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [18,3,8] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [31,18,23] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [75,34,30] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [107,76,52] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [125,92,159] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [136,256,10] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [160,247,127] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [187,4,32] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [197,171,144] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [214,200,176] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [222,191,39] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [24,12] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [225,163,64] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [128,128] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [229,253,127] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [1,2,3] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [1,256,64] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [6,6,192] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [239,83,71] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [6,96,20] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [247,153,90] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [256,255,255] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [1,201,251,191] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [4,157,191,127] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [8,8,2] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [10,34,130] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [12,19,1,11] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [10,91,127] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [15,8,21,25] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [17,25,4,27] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [10,130,206] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [14,183,251] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [29,20,17,4] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [15,147,174] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [16,245,125] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [32,12,25,19] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [22,21,26] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [23,30,32] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [24,72,160] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [33,223,239] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [35,143,127,254] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [55,147,16,8] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [34,52,104] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [100,104,96,144] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [129,70,126,253] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [129,162,158,253] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [145,127,55,43] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [36,177,244] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [159,111,124,233] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [36,213,236] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [175,231,27,92] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [205,234,127,223] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [215,10,8,256] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [223,127,172,210] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [38,221,224] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [41,14,50] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [41,79,239] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [44,124,247] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [225,201,121,103] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [232,45,175,231] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [250,131,50,46] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [254,249,173,163] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [255,255,214,229] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [256,151,141,15] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [47,205,182] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [48,64,251] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [51,253,254] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [53,172,195] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [57,127,251] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [4,98,210,79,254] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [59,31,236] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [8,5,103,247,235] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [8,74,170,254,132] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [8,148,182,62,255] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [62,153,210] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [64,93,253] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [9,28,18,26,11] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [12,208,240,216,139] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [13,21,23,13,32] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [16,24,13,46,156] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [16,192,71,31,239] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [64,195,203] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [65,254,239] }
assert my_solution.canSortArray(**test_input) == True
test_input = { "nums": [17,11,5,20,8] }
assert my_solution.canSortArray(**test_input) == False
test_input = { "nums": [23,12,22,29,20] }
assert my_solution.canSortArray(**test_input) == False | 1,705,761,000 |
biweekly-contest-122-minimize-length-of-array-using-operations | https://leetcode.com/problems/minimize-length-of-array-using-operations | minimize-length-of-array-using-operations | {
"questionId": "3244",
"questionFrontendId": "3012",
"title": "Minimize Length of Array Using Operations",
"titleSlug": "minimize-length-of-array-using-operations",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 79,
"dislikes": 30,
"categoryTitle": "Algorithms"
} | """
You are given a 0-indexed integer array nums containing positive integers.
Your task is to minimize the length of nums by performing the following operations any number of times (including zero):
Select two distinct indices i and j from nums, such that nums[i] > 0 and nums[j] > 0.
Insert the result of nums[i] % nums[j] at the end of nums.
Delete the elements at indices i and j from nums.
Return an integer denoting the minimum length of nums after performing the operation any number of times.
Example 1:
Input: nums = [1,4,3,1]
Output: 1
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 2 and 1, insert nums[2] % nums[1] at the end and it becomes [1,4,3,1,3], then delete elements at indices 2 and 1.
nums becomes [1,1,3].
Operation 2: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [1,1,3,1], then delete elements at indices 1 and 2.
nums becomes [1,1].
Operation 3: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [1,1,0], then delete elements at indices 1 and 0.
nums becomes [0].
The length of nums cannot be reduced further. Hence, the answer is 1.
It can be shown that 1 is the minimum achievable length.
Example 2:
Input: nums = [5,5,5,10,5]
Output: 2
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 0 and 3, insert nums[0] % nums[3] at the end and it becomes [5,5,5,10,5,5], then delete elements at indices 0 and 3.
nums becomes [5,5,5,5].
Operation 2: Select indices 2 and 3, insert nums[2] % nums[3] at the end and it becomes [5,5,5,5,0], then delete elements at indices 2 and 3.
nums becomes [5,5,0].
Operation 3: Select indices 0 and 1, insert nums[0] % nums[1] at the end and it becomes [5,5,0,0], then delete elements at indices 0 and 1.
nums becomes [0,0].
The length of nums cannot be reduced further. Hence, the answer is 2.
It can be shown that 2 is the minimum achievable length.
Example 3:
Input: nums = [2,3,4]
Output: 1
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [2,3,4,3], then delete elements at indices 1 and 2.
nums becomes [2,3].
Operation 2: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [2,3,1], then delete elements at indices 1 and 0.
nums becomes [1].
The length of nums cannot be reduced further. Hence, the answer is 1.
It can be shown that 1 is the minimum achievable length.
Constraints:
1 <= nums.length <= 105
1 <= nums[i] <= 109
"""
class Solution:
def minimumArrayLength(self, nums: List[int]) -> int:
| You are given a 0-indexed integer array nums containing positive integers.
Your task is to minimize the length of nums by performing the following operations any number of times (including zero):
Select two distinct indices i and j from nums, such that nums[i] > 0 and nums[j] > 0.
Insert the result of nums[i] % nums[j] at the end of nums.
Delete the elements at indices i and j from nums.
Return an integer denoting the minimum length of nums after performing the operation any number of times.
Example 1:
Input: nums = [1,4,3,1]
Output: 1
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 2 and 1, insert nums[2] % nums[1] at the end and it becomes [1,4,3,1,3], then delete elements at indices 2 and 1.
nums becomes [1,1,3].
Operation 2: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [1,1,3,1], then delete elements at indices 1 and 2.
nums becomes [1,1].
Operation 3: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [1,1,0], then delete elements at indices 1 and 0.
nums becomes [0].
The length of nums cannot be reduced further. Hence, the answer is 1.
It can be shown that 1 is the minimum achievable length.
Example 2:
Input: nums = [5,5,5,10,5]
Output: 2
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 0 and 3, insert nums[0] % nums[3] at the end and it becomes [5,5,5,10,5,5], then delete elements at indices 0 and 3.
nums becomes [5,5,5,5].
Operation 2: Select indices 2 and 3, insert nums[2] % nums[3] at the end and it becomes [5,5,5,5,0], then delete elements at indices 2 and 3.
nums becomes [5,5,0].
Operation 3: Select indices 0 and 1, insert nums[0] % nums[1] at the end and it becomes [5,5,0,0], then delete elements at indices 0 and 1.
nums becomes [0,0].
The length of nums cannot be reduced further. Hence, the answer is 2.
It can be shown that 2 is the minimum achievable length.
Example 3:
Input: nums = [2,3,4]
Output: 1
Explanation: One way to minimize the length of the array is as follows:
Operation 1: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [2,3,4,3], then delete elements at indices 1 and 2.
nums becomes [2,3].
Operation 2: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [2,3,1], then delete elements at indices 1 and 0.
nums becomes [1].
The length of nums cannot be reduced further. Hence, the answer is 1.
It can be shown that 1 is the minimum achievable length.
Constraints:
1 <= nums.length <= 105
1 <= nums[i] <= 109
Please complete the code below to solve above prblem:
```python
class Solution:
def minimumArrayLength(self, nums: List[int]) -> int:
``` |
my_solution = Solution()
test_input = { "nums": [1,4,3,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,5,5,10,5] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [2,3,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [8,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,2,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,1,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,7,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,9,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,2,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,2,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,3,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,1,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,4,4] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [5,1,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,5,5] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [6,5,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [8,4,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,2,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,2,3,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,3,1,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,5,5,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,8,7,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,2,1,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,7,10,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,10,1,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,2,3,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,4,1,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,3,10,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,3,4,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,5,2,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,2,5,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,3,4,4,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,1,7,10,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,3,1,4,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,6,2,6,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,10,6,3,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,4,5,4,5,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,6,6,9,5,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,1,2,5,3,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,2,4,4,2,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,5,2,5,5,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,1,4,4,5,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,3,1,2,5,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,8,8,7,6,8] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,2,2,2,9,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,3,2,4,3,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,5,6,6,7,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [8,3,9,4,5,8] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,5,4,3,5,5,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,5,5,1,2,5,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,8,7,4,9,3,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,3,5,7,9,10,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,1,9,3,9,2,6] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,10,1,8,6,1,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,1,10,7,3,9,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [10,10,3,9,8,3,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [10,10,4,8,5,2,6] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,5,2,10,4,5,10,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,1,3,3,3,3,1,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,2,7,4,5,5,1,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,4,5,5,3,5,2,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,10,6,7,7,2,3,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,3,2,2,4,2,3,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,4,3,4,1,1,1,2] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [3,4,4,3,5,4,5,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [3,6,7,7,6,9,1,6] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,1,1,1,1,5,5,5] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [6,7,5,5,3,6,1,8] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [8,5,4,5,4,7,6,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [8,10,4,6,7,9,2,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [2,6,3,8,9,10,9,3,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,2,2,1,3,1,5,3,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,4,5,1,2,1,1,1,2] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [4,5,3,5,5,4,4,2,1] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,1,5,1,1,5,4,3,3] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [5,1,5,3,3,2,2,4,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,4,5,7,9,10,10,6,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [6,5,6,4,9,8,8,3,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,7,6,10,1,8,5,4,2] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [9,10,1,6,4,10,1,3,4] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [10,5,4,8,4,3,7,10,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,1,1,2,2,2,5,5,1,3] }
assert my_solution.minimumArrayLength(**test_input) == 2
test_input = { "nums": [4,5,1,8,2,7,2,7,7,6] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,1,3,10,1,4,5,2,9,7] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,2,2,9,5,6,6,10,2,3] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [7,7,3,6,8,10,3,7,6,9] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [1,4,5,8,9,3,1,4,7,4,5] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [4,10,3,8,9,5,7,6,9,10,10] }
assert my_solution.minimumArrayLength(**test_input) == 1
test_input = { "nums": [5,9,3,9,3,10,1,1,6,3,10] }
assert my_solution.minimumArrayLength(**test_input) == 1 | 1,705,761,000 |
biweekly-contest-122-divide-an-array-into-subarrays-with-minimum-cost-ii | https://leetcode.com/problems/divide-an-array-into-subarrays-with-minimum-cost-ii | divide-an-array-into-subarrays-with-minimum-cost-ii | {
"questionId": "3260",
"questionFrontendId": "3013",
"title": "Divide an Array Into Subarrays With Minimum Cost II",
"titleSlug": "divide-an-array-into-subarrays-with-minimum-cost-ii",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 54,
"dislikes": 2,
"categoryTitle": "Algorithms"
} | """
You are given a 0-indexed array of integers nums of length n, and two positive integers k and dist.
The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3.
You need to divide nums into k disjoint contiguous subarrays, such that the difference between the starting index of the second subarray and the starting index of the kth subarray should be less than or equal to dist. In other words, if you divide nums into the subarrays nums[0..(i1 - 1)], nums[i1..(i2 - 1)], ..., nums[ik-1..(n - 1)], then ik-1 - i1 <= dist.
Return the minimum possible sum of the cost of these subarrays.
Example 1:
Input: nums = [1,3,2,6,4,2], k = 3, dist = 3
Output: 5
Explanation: The best possible way to divide nums into 3 subarrays is: [1,3], [2,6,4], and [2]. This choice is valid because ik-1 - i1 is 5 - 2 = 3 which is equal to dist. The total cost is nums[0] + nums[2] + nums[5] which is 1 + 2 + 2 = 5.
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 5.
Example 2:
Input: nums = [10,1,2,2,2,1], k = 4, dist = 3
Output: 15
Explanation: The best possible way to divide nums into 4 subarrays is: [10], [1], [2], and [2,2,1]. This choice is valid because ik-1 - i1 is 3 - 1 = 2 which is less than dist. The total cost is nums[0] + nums[1] + nums[2] + nums[3] which is 10 + 1 + 2 + 2 = 15.
The division [10], [1], [2,2,2], and [1] is not valid, because the difference between ik-1 and i1 is 5 - 1 = 4, which is greater than dist.
It can be shown that there is no possible way to divide nums into 4 subarrays at a cost lower than 15.
Example 3:
Input: nums = [10,8,18,9], k = 3, dist = 1
Output: 36
Explanation: The best possible way to divide nums into 4 subarrays is: [10], [8], and [18,9]. This choice is valid because ik-1 - i1 is 2 - 1 = 1 which is equal to dist.The total cost is nums[0] + nums[1] + nums[2] which is 10 + 8 + 18 = 36.
The division [10], [8,18], and [9] is not valid, because the difference between ik-1 and i1 is 3 - 1 = 2, which is greater than dist.
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 36.
Constraints:
3 <= n <= 105
1 <= nums[i] <= 109
3 <= k <= n
k - 2 <= dist <= n - 2
"""
class Solution:
def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
| You are given a 0-indexed array of integers nums of length n, and two positive integers k and dist.
The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3.
You need to divide nums into k disjoint contiguous subarrays, such that the difference between the starting index of the second subarray and the starting index of the kth subarray should be less than or equal to dist. In other words, if you divide nums into the subarrays nums[0..(i1 - 1)], nums[i1..(i2 - 1)], ..., nums[ik-1..(n - 1)], then ik-1 - i1 <= dist.
Return the minimum possible sum of the cost of these subarrays.
Example 1:
Input: nums = [1,3,2,6,4,2], k = 3, dist = 3
Output: 5
Explanation: The best possible way to divide nums into 3 subarrays is: [1,3], [2,6,4], and [2]. This choice is valid because ik-1 - i1 is 5 - 2 = 3 which is equal to dist. The total cost is nums[0] + nums[2] + nums[5] which is 1 + 2 + 2 = 5.
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 5.
Example 2:
Input: nums = [10,1,2,2,2,1], k = 4, dist = 3
Output: 15
Explanation: The best possible way to divide nums into 4 subarrays is: [10], [1], [2], and [2,2,1]. This choice is valid because ik-1 - i1 is 3 - 1 = 2 which is less than dist. The total cost is nums[0] + nums[1] + nums[2] + nums[3] which is 10 + 1 + 2 + 2 = 15.
The division [10], [1], [2,2,2], and [1] is not valid, because the difference between ik-1 and i1 is 5 - 1 = 4, which is greater than dist.
It can be shown that there is no possible way to divide nums into 4 subarrays at a cost lower than 15.
Example 3:
Input: nums = [10,8,18,9], k = 3, dist = 1
Output: 36
Explanation: The best possible way to divide nums into 4 subarrays is: [10], [8], and [18,9]. This choice is valid because ik-1 - i1 is 2 - 1 = 1 which is equal to dist.The total cost is nums[0] + nums[1] + nums[2] which is 10 + 8 + 18 = 36.
The division [10], [8,18], and [9] is not valid, because the difference between ik-1 and i1 is 3 - 1 = 2, which is greater than dist.
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 36.
Constraints:
3 <= n <= 105
1 <= nums[i] <= 109
3 <= k <= n
k - 2 <= dist <= n - 2
Please complete the code below to solve above prblem:
```python
class Solution:
def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
``` |
my_solution = Solution()
test_input = { "nums": [1,3,2,6,4,2], "k": 3, "dist": 3 }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [10,1,2,2,2,1], "k": 4, "dist": 3 }
assert my_solution.minimumCost(**test_input) == 15
test_input = { "nums": [10,8,18,9], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 36
test_input = { "nums": [1,1,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 3
test_input = { "nums": [1,1,3], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [1,2,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [1,2,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [1,4,4], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,2,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 5
test_input = { "nums": [2,3,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [2,5,4], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,1,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 6
test_input = { "nums": [3,1,3], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [3,2,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [3,3,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,4,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [3,5,3], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [4,1,4], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,1,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,2,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 7
test_input = { "nums": [4,2,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [4,2,4], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [4,2,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [4,3,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [4,3,2], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [4,5,3], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [5,2,1], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 8
test_input = { "nums": [5,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [50,50,50], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 150
test_input = { "nums": [1,5,3,6], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,3,7], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,3,7], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,3,8], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,5,4,6], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 16
test_input = { "nums": [1,6,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [1,6,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [1,6,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 16
test_input = { "nums": [1,7,4,6], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 18
test_input = { "nums": [1,7,4,8], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 20
test_input = { "nums": [1,8,3,8], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [1,8,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 20
test_input = { "nums": [2,5,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,5,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 18
test_input = { "nums": [2,5,4,8], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [2,6,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,6,3,6], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [2,6,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 17
test_input = { "nums": [2,6,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [2,6,4,8], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 20
test_input = { "nums": [2,7,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,7,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [2,7,4,6], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [2,8,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 10
test_input = { "nums": [2,8,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [3,5,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,5,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,5,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,5,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [3,6,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,6,3,7], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,6,3,8], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,6,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 18
test_input = { "nums": [3,7,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,7,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,7,3,6], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [3,7,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [3,7,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 21
test_input = { "nums": [3,8,3,5], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 11
test_input = { "nums": [3,8,4,6], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 21
test_input = { "nums": [4,5,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,5,3,6], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,5,3,8], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,5,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 18
test_input = { "nums": [4,6,3,6], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,6,3,7], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,6,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 19
test_input = { "nums": [4,6,4,8], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 22
test_input = { "nums": [4,7,3,6], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,7,4,5], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 20
test_input = { "nums": [4,7,4,7], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 22
test_input = { "nums": [4,8,3,5], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [4,8,3,6], "k": 3, "dist": 1 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [4,8,3,7], "k": 3, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 14
test_input = { "nums": [4,8,4,6], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 22
test_input = { "nums": [4,8,4,8], "k": 4, "dist": 2 }
assert my_solution.minimumCost(**test_input) == 24
test_input = { "nums": [1,5,6,6,3,7,2], "k": 6, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 23
test_input = { "nums": [1,6,4,6,2,9,11], "k": 4, "dist": 3 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [1,6,4,7,9,6,1], "k": 4, "dist": 4 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [1,6,5,6,4,9,11], "k": 5, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 22
test_input = { "nums": [1,6,5,7,8,7,5], "k": 5, "dist": 4 }
assert my_solution.minimumCost(**test_input) == 25
test_input = { "nums": [1,6,5,8,11,10,6], "k": 5, "dist": 3 }
assert my_solution.minimumCost(**test_input) == 31
test_input = { "nums": [1,6,6,8,4,8,7], "k": 6, "dist": 4 }
assert my_solution.minimumCost(**test_input) == 33
test_input = { "nums": [1,7,6,8,5,10,10], "k": 6, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 37
test_input = { "nums": [1,8,3,8,11,11,10], "k": 3, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 12
test_input = { "nums": [1,8,4,7,11,1,8], "k": 4, "dist": 4 }
assert my_solution.minimumCost(**test_input) == 13
test_input = { "nums": [1,8,6,5,6,12,12], "k": 6, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 38
test_input = { "nums": [1,8,6,6,12,5,2], "k": 6, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 28
test_input = { "nums": [2,5,3,5,7,4,3], "k": 3, "dist": 3 }
assert my_solution.minimumCost(**test_input) == 9
test_input = { "nums": [2,5,4,6,6,1,3], "k": 4, "dist": 5 }
assert my_solution.minimumCost(**test_input) == 10 | 1,705,761,000 |
weekly-contest-380-count-elements-with-maximum-frequency | https://leetcode.com/problems/count-elements-with-maximum-frequency | count-elements-with-maximum-frequency | {
"questionId": "3242",
"questionFrontendId": "3005",
"title": "Count Elements With Maximum Frequency",
"titleSlug": "count-elements-with-maximum-frequency",
"isPaidOnly": false,
"difficulty": "Easy",
"likes": 47,
"dislikes": 2,
"categoryTitle": "Algorithms"
} | """
You are given an array nums consisting of positive integers.
Return the total frequencies of elements in numssuch that those elements all have the maximum frequency.
The frequency of an element is the number of occurrences of that element in the array.
Example 1:
Input: nums = [1,2,2,3,1,4]
Output: 4
Explanation: The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.
Example 2:
Input: nums = [1,2,3,4,5]
Output: 5
Explanation: All elements of the array have a frequency of 1 which is the maximum.
So the number of elements in the array with maximum frequency is 5.
Constraints:
1 <= nums.length <= 100
1 <= nums[i] <= 100
"""
class Solution:
def maxFrequencyElements(self, nums: List[int]) -> int:
| You are given an array nums consisting of positive integers.
Return the total frequencies of elements in numssuch that those elements all have the maximum frequency.
The frequency of an element is the number of occurrences of that element in the array.
Example 1:
Input: nums = [1,2,2,3,1,4]
Output: 4
Explanation: The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.
Example 2:
Input: nums = [1,2,3,4,5]
Output: 5
Explanation: All elements of the array have a frequency of 1 which is the maximum.
So the number of elements in the array with maximum frequency is 5.
Constraints:
1 <= nums.length <= 100
1 <= nums[i] <= 100
Please complete the code below to solve above prblem:
```python
class Solution:
def maxFrequencyElements(self, nums: List[int]) -> int:
``` |
my_solution = Solution()
test_input = { "nums": [1,2,2,3,1,4] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [1,2,3,4,5] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [15] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [10,12,11,9,6,19,11] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [2,12,17,18,11] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [19,19,19,20,19,8,19] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [1,1,1,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [10,1,12,10,10,19,10] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [1,1,1,20,6,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [17,17] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [6,13,15,15,11,6,7,12,4,11] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [1,2] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [14,14,17] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [17,17,2,12,20,17,12] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [3,9,11,11,20] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [8,15,8,11,8,13,12,11,8] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [17,8,17,19,17,13,17,17,17,5] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [11] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [5] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [4,4,10] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [15,13,2,16,2,5,1,18,8,16] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [1,17,12,7,17,3] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [8,2,8,6,1,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [3,9,7,9] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [20,20,20,5,12,20,9,16] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [2,14,3,8,16,4,4,3] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [6,12,3,3,11,2] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [5,2,13,19,15,20] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [2,13,13] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [4,5] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [20,20,15,20,20,20] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [16,16,16,16,1,10,16,9] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [5,3,5,8,5,3,5,15] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [17] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [2,2,3,3,9] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [5,11,4,2] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [13,13,7] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [2,15,10,10,10,4,13] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [3,7,1] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [19,6,19,19,19,19,19] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [15,3,12,4,9,14,10] }
assert my_solution.maxFrequencyElements(**test_input) == 7
test_input = { "nums": [1,19,12,1,12,12,1,6] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [17,7,3,3,6,5,6,2] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [12,4,2,9,17,14,1,12,6] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [16,11] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [11,11,11,11,10,11,3,11,11] }
assert my_solution.maxFrequencyElements(**test_input) == 7
test_input = { "nums": [16,4,20,10,12] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [3,11,3,11] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [13,9,13,13,13,13,2,13] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [2,8,9,4,3] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [19,6,9,12,12] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [20] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [1,11] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [6,4,7,19,20,10,13,14] }
assert my_solution.maxFrequencyElements(**test_input) == 8
test_input = { "nums": [16,8,5] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [15,15,4,7,15,15,15,15,15,7] }
assert my_solution.maxFrequencyElements(**test_input) == 7
test_input = { "nums": [5,20] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [13] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [7,15,13,18,3,11,13,7,1,13] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [17,5,17,5,5] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [4,5,3,5] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [11,2] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [1,17,17,20,2,2] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [2,5,2,2] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [1,1,1,3,8,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [1,19,19,5,14,13,1,20,6] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [19,12,8,20,3,1,12,17] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [7,15,1,1,6,3] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [8,8,8,3,8,8,3] }
assert my_solution.maxFrequencyElements(**test_input) == 5
test_input = { "nums": [5,1,2,2,2,1,1] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [12,13,6] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [18,12,8,2,16,19] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [15,10,2,18,11,14,9] }
assert my_solution.maxFrequencyElements(**test_input) == 7
test_input = { "nums": [19,17,9,13,1,13] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [4,12,15,1,4,4,2] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [16,16,16,8] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [2] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [13,15,1] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [10,10,5,16,17,6,18] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [3,2,14,2,18,7] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [16,16,3] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [1,8,10,11,8,15] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [8,19,2,7,5,6,3,4] }
assert my_solution.maxFrequencyElements(**test_input) == 8
test_input = { "nums": [9] }
assert my_solution.maxFrequencyElements(**test_input) == 1
test_input = { "nums": [13,6,13,10] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [14,13,14,4,4,14] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [9,9,1,9,9,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [14,4,11,14,14,4,4] }
assert my_solution.maxFrequencyElements(**test_input) == 6
test_input = { "nums": [4,20,20,4,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [5,11,8,3,11,11,11] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [3,2,18,5] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [3,8,20,7,16,20,18,13] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [19,9,16,4,10,3,18] }
assert my_solution.maxFrequencyElements(**test_input) == 7
test_input = { "nums": [11,2,2,3,19,3,11,2,14,1] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [19,14,11,7,19,1,11,2,16] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [18,15,3,2,8,12,19,14,12] }
assert my_solution.maxFrequencyElements(**test_input) == 2
test_input = { "nums": [5,6,11,9,5,5,5] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [8,4,4,12,8,1] }
assert my_solution.maxFrequencyElements(**test_input) == 4
test_input = { "nums": [9,1,9,9,3] }
assert my_solution.maxFrequencyElements(**test_input) == 3
test_input = { "nums": [18] }
assert my_solution.maxFrequencyElements(**test_input) == 1 | 1,705,199,400 |
weekly-contest-380-find-beautiful-indices-in-the-given-array-i | https://leetcode.com/problems/find-beautiful-indices-in-the-given-array-i | find-beautiful-indices-in-the-given-array-i | {
"questionId": "3245",
"questionFrontendId": "3006",
"title": "Find Beautiful Indices in the Given Array I",
"titleSlug": "find-beautiful-indices-in-the-given-array-i",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 91,
"dislikes": 21,
"categoryTitle": "Algorithms"
} | """
You are given a 0-indexed string s, a string a, a string b, and an integer k.
An index i is beautiful if:
0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
There exists an index j such that:
0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k
Return the array that contains beautiful indices in sorted order from smallest to largest.
Example 1:
Input: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Output: [16,33]
Explanation: There are 2 beautiful indices: [16,33].
- The index 16 is beautiful as s[16..17] == "my" and there exists an index 4 with s[4..11] == "squirrel" and |16 - 4| <= 15.
- The index 33 is beautiful as s[33..34] == "my" and there exists an index 18 with s[18..25] == "squirrel" and |33 - 18| <= 15.
Thus we return [16,33] as the result.
Example 2:
Input: s = "abcd", a = "a", b = "a", k = 4
Output: [0]
Explanation: There is 1 beautiful index: [0].
- The index 0 is beautiful as s[0..0] == "a" and there exists an index 0 with s[0..0] == "a" and |0 - 0| <= 4.
Thus we return [0] as the result.
Constraints:
1 <= k <= s.length <= 105
1 <= a.length, b.length <= 10
s, a, and b contain only lowercase English letters.
"""
class Solution:
def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
| You are given a 0-indexed string s, a string a, a string b, and an integer k.
An index i is beautiful if:
0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
There exists an index j such that:
0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k
Return the array that contains beautiful indices in sorted order from smallest to largest.
Example 1:
Input: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Output: [16,33]
Explanation: There are 2 beautiful indices: [16,33].
- The index 16 is beautiful as s[16..17] == "my" and there exists an index 4 with s[4..11] == "squirrel" and |16 - 4| <= 15.
- The index 33 is beautiful as s[33..34] == "my" and there exists an index 18 with s[18..25] == "squirrel" and |33 - 18| <= 15.
Thus we return [16,33] as the result.
Example 2:
Input: s = "abcd", a = "a", b = "a", k = 4
Output: [0]
Explanation: There is 1 beautiful index: [0].
- The index 0 is beautiful as s[0..0] == "a" and there exists an index 0 with s[0..0] == "a" and |0 - 0| <= 4.
Thus we return [0] as the result.
Constraints:
1 <= k <= s.length <= 105
1 <= a.length, b.length <= 10
s, a, and b contain only lowercase English letters.
Please complete the code below to solve above prblem:
```python
class Solution:
def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
``` |
my_solution = Solution()
test_input = { "s": "isawsquirrelnearmysquirrelhouseohmy", "a": "my", "b": "squirrel", "k": 15 }
assert my_solution.beautifulIndices(**test_input) == [16,33]
test_input = { "s": "abcd", "a": "a", "b": "a", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "sqgrt", "a": "rt", "b": "sq", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "mquz", "a": "tklr", "b": "caz", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "wl", "a": "xjigt", "b": "wl", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bavgoc", "a": "ba", "b": "c", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "xpcp", "a": "yxnod", "b": "xpc", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lahhnlwx", "a": "hhnlw", "b": "ty", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dexgscgecd", "a": "gscge", "b": "d", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "vjrao", "a": "vjr", "b": "yxpsw", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "oo", "a": "swhup", "b": "o", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bxlzgxc", "a": "ducf", "b": "xlzgx", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "wetlgztzm", "a": "box", "b": "wetl", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ocmm", "a": "m", "b": "oc", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [2,3]
test_input = { "s": "goxmox", "a": "gibs", "b": "ox", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "kzlrqzldvy", "a": "zl", "b": "tfsr", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qhd", "a": "hd", "b": "od", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bozpeh", "a": "bozp", "b": "vrjn", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ggfsg", "a": "gfsg", "b": "g", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "fape", "a": "vq", "b": "ap", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "isitbenom", "a": "pmng", "b": "itben", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gw", "a": "ln", "b": "gw", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "jhu", "a": "sio", "b": "xnx", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "elcklvcvdg", "a": "lck", "b": "e", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "subsu", "a": "tdo", "b": "su", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "jqcdc", "a": "c", "b": "d", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [2,4]
test_input = { "s": "hhvc", "a": "gfwo", "b": "hh", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tyoq", "a": "vhjit", "b": "yoq", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "rtbp", "a": "migjb", "b": "es", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gkkstqvl", "a": "gkkst", "b": "xszl", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bc", "a": "spzk", "b": "wsick", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gyalx", "a": "neet", "b": "rbhl", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qo", "a": "agt", "b": "xrh", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "rinzbrrr", "a": "nzb", "b": "r", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [2]
test_input = { "s": "tjly", "a": "j", "b": "n", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "frkxslnnn", "a": "rkxsl", "b": "n", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "cffczbccc", "a": "ff", "b": "c", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "uiddqbeoaw", "a": "iddq", "b": "rlr", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "fh", "a": "ywab", "b": "qcjyl", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gdbm", "a": "gdbm", "b": "uefwm", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bpcwswu", "a": "zi", "b": "pcwsw", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dh", "a": "jmcds", "b": "nytk", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qjgckhiif", "a": "hiif", "b": "jgc", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [5]
test_input = { "s": "qyixufgyk", "a": "y", "b": "ixuf", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [1,7]
test_input = { "s": "wiwiwinwio", "a": "hm", "b": "wi", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ffnlge", "a": "bjt", "b": "pavkr", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "rj", "a": "m", "b": "umg", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bkgqxl", "a": "yufy", "b": "kgq", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "hhcwp", "a": "sixek", "b": "cwp", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "czr", "a": "cz", "b": "wxxql", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tdbnme", "a": "t", "b": "dbnme", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "px", "a": "acgz", "b": "jaxel", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "wfa", "a": "fyntx", "b": "a", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ixfkxfld", "a": "ixfk", "b": "urkke", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "kmjvlkjy", "a": "gll", "b": "vlk", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bsbsvnmvnm", "a": "vnm", "b": "bs", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [4,7]
test_input = { "s": "uzqauzqw", "a": "uzq", "b": "psnso", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "fsvkche", "a": "yot", "b": "svkc", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "cwwzmfzz", "a": "fnlgc", "b": "cwwzm", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "profguo", "a": "o", "b": "oyzje", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ckbdnw", "a": "djpc", "b": "ckbdn", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ankfahcorr", "a": "r", "b": "kfah", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [8,9]
test_input = { "s": "ahjzfg", "a": "hjzf", "b": "zs", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "eueuau", "a": "u", "b": "e", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [1,3,5]
test_input = { "s": "etuwwhwljf", "a": "uwwh", "b": "efcuq", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vvjhgg", "a": "g", "b": "kj", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "igytmsmsgx", "a": "msmsg", "b": "gyt", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [4]
test_input = { "s": "cheoeo", "a": "eo", "b": "y", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gqzf", "a": "cgpdn", "b": "zf", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "zapqwtmx", "a": "apqwt", "b": "m", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "klxtee", "a": "e", "b": "klx", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "xa", "a": "gzsj", "b": "oooq", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gxoxqgxoxq", "a": "gxoxq", "b": "x", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [0,5]
test_input = { "s": "lsuo", "a": "d", "b": "uo", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "yhi", "a": "ph", "b": "yhi", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "cj", "a": "j", "b": "em", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "clxzclxz", "a": "ge", "b": "clxz", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gjtcpyiniv", "a": "cpyi", "b": "hjvtq", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "kyrvedszzo", "a": "rve", "b": "y", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [2]
test_input = { "s": "makolbcrme", "a": "qlhpf", "b": "akol", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vgxshd", "a": "vgx", "b": "en", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "wfvxfzut", "a": "wfv", "b": "ut", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "xxtxxuftxt", "a": "tx", "b": "x", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [2,7]
test_input = { "s": "cwtybs", "a": "wgfez", "b": "cwty", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "opnkctux", "a": "op", "b": "nkctu", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "swswmcsksw", "a": "mcsk", "b": "sw", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [4]
test_input = { "s": "qqnb", "a": "q", "b": "q", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [0,1]
test_input = { "s": "tt", "a": "t", "b": "q", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lllclbii", "a": "l", "b": "i", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [0,1,2,4]
test_input = { "s": "oanyzue", "a": "yzu", "b": "oan", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "opmfgzthj", "a": "opmf", "b": "g", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "uiddidde", "a": "idd", "b": "sal", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gzzau", "a": "za", "b": "rwu", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "srpxqurxx", "a": "nsr", "b": "x", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "sxaono", "a": "jy", "b": "xaon", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "acxtjiova", "a": "acx", "b": "tjiov", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "iltazkww", "a": "k", "b": "z", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [5]
test_input = { "s": "ltxbhpi", "a": "cjfbb", "b": "ltxb", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gysgysh", "a": "gys", "b": "qzvae", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "zypvgt", "a": "zypv", "b": "ljxni", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [] | 1,705,199,400 |
weekly-contest-380-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k | https://leetcode.com/problems/maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k | maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k | {
"questionId": "3240",
"questionFrontendId": "3007",
"title": "Maximum Number That Sum of the Prices Is Less Than or Equal to K",
"titleSlug": "maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k",
"isPaidOnly": false,
"difficulty": "Medium",
"likes": 125,
"dislikes": 74,
"categoryTitle": "Algorithms"
} | """
You are given an integer k and an integer x.
Consider s is the 1-indexed binary representation of an integer num. The price of a number num is the number of i's such that i % x == 0 and s[i] is a set bit.
Return the greatest integer num such that the sum of prices of all numbers from 1 to num is less than or equal to k.
Note:
In the binary representation of a number set bit is a bit of value 1.
The binary representation of a number will be indexed from right to left. For example, if s == 11100, s[4] == 1 and s[2] == 0.
Example 1:
Input: k = 9, x = 1
Output: 6
Explanation: The numbers 1, 2, 3, 4, 5, and 6 can be written in binary representation as "1", "10", "11", "100", "101", and "110" respectively.
Since x is equal to 1, the price of each number is the number of its set bits.
The number of set bits in these numbers is 9. So the sum of the prices of the first 6 numbers is 9.
So the answer is 6.
Example 2:
Input: k = 7, x = 2
Output: 9
Explanation: Since x is equal to 2, we should just check eventh bits.
The second bit of binary representation of numbers 2 and 3 is a set bit. So the sum of their prices is 2.
The second bit of binary representation of numbers 6 and 7 is a set bit. So the sum of their prices is 2.
The fourth bit of binary representation of numbers 8 and 9 is a set bit but their second bit is not. So the sum of their prices is 2.
Numbers 1, 4, and 5 don't have set bits in their eventh bits in their binary representation. So the sum of their prices is 0.
The second and the fourth bit of the binary representation of the number 10 are a set bit. So its price is 2.
The sum of the prices of the first 9 numbers is 6.
Because the sum of the prices of the first 10 numbers is 8, the answer is 9.
Constraints:
1 <= k <= 1015
1 <= x <= 8
"""
class Solution:
def findMaximumNumber(self, k: int, x: int) -> int:
| You are given an integer k and an integer x.
Consider s is the 1-indexed binary representation of an integer num. The price of a number num is the number of i's such that i % x == 0 and s[i] is a set bit.
Return the greatest integer num such that the sum of prices of all numbers from 1 to num is less than or equal to k.
Note:
In the binary representation of a number set bit is a bit of value 1.
The binary representation of a number will be indexed from right to left. For example, if s == 11100, s[4] == 1 and s[2] == 0.
Example 1:
Input: k = 9, x = 1
Output: 6
Explanation: The numbers 1, 2, 3, 4, 5, and 6 can be written in binary representation as "1", "10", "11", "100", "101", and "110" respectively.
Since x is equal to 1, the price of each number is the number of its set bits.
The number of set bits in these numbers is 9. So the sum of the prices of the first 6 numbers is 9.
So the answer is 6.
Example 2:
Input: k = 7, x = 2
Output: 9
Explanation: Since x is equal to 2, we should just check eventh bits.
The second bit of binary representation of numbers 2 and 3 is a set bit. So the sum of their prices is 2.
The second bit of binary representation of numbers 6 and 7 is a set bit. So the sum of their prices is 2.
The fourth bit of binary representation of numbers 8 and 9 is a set bit but their second bit is not. So the sum of their prices is 2.
Numbers 1, 4, and 5 don't have set bits in their eventh bits in their binary representation. So the sum of their prices is 0.
The second and the fourth bit of the binary representation of the number 10 are a set bit. So its price is 2.
The sum of the prices of the first 9 numbers is 6.
Because the sum of the prices of the first 10 numbers is 8, the answer is 9.
Constraints:
1 <= k <= 1015
1 <= x <= 8
Please complete the code below to solve above prblem:
```python
class Solution:
def findMaximumNumber(self, k: int, x: int) -> int:
``` |
my_solution = Solution()
test_input = { "k": 9, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 6
test_input = { "k": 7, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 9
test_input = { "k": 19, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 50
test_input = { "k": 57, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 120
test_input = { "k": 58, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 121
test_input = { "k": 60, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 187
test_input = { "k": 72, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 151
test_input = { "k": 81, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 176
test_input = { "k": 83, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 33
test_input = { "k": 83, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 210
test_input = { "k": 116, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 243
test_input = { "k": 157, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 316
test_input = { "k": 201, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 212
test_input = { "k": 268, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 555
test_input = { "k": 281, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 531
test_input = { "k": 283, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 274
test_input = { "k": 309, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 364
test_input = { "k": 363, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 746
test_input = { "k": 409, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 220
test_input = { "k": 456, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 967
test_input = { "k": 466, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 365
test_input = { "k": 500, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 379
test_input = { "k": 513, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 148
test_input = { "k": 521, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 1160
test_input = { "k": 540, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 571
test_input = { "k": 545, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 156
test_input = { "k": 579, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 165
test_input = { "k": 584, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 166
test_input = { "k": 589, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 427
test_input = { "k": 599, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 1206
test_input = { "k": 632, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 346
test_input = { "k": 692, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 481
test_input = { "k": 701, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 1404
test_input = { "k": 704, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 727
test_input = { "k": 731, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 1498
test_input = { "k": 781, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 210
test_input = { "k": 782, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 1613
test_input = { "k": 808, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 1639
test_input = { "k": 814, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 1645
test_input = { "k": 818, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 218
test_input = { "k": 821, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 433
test_input = { "k": 829, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 1660
test_input = { "k": 865, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 1760
test_input = { "k": 874, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 1769
test_input = { "k": 879, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 230
test_input = { "k": 879, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 628
test_input = { "k": 898, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 1921
test_input = { "k": 902, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 653
test_input = { "k": 905, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 1928
test_input = { "k": 937, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 1960
test_input = { "k": 957, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 701
test_input = { "k": 973, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 247
test_input = { "k": 978, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 737
test_input = { "k": 991, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 1006
test_input = { "k": 1029, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 771
test_input = { "k": 1065, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2083
test_input = { "k": 1086, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 805
test_input = { "k": 1105, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 280
test_input = { "k": 1113, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 815
test_input = { "k": 1143, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 1190
test_input = { "k": 1148, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 564
test_input = { "k": 1150, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 2301
test_input = { "k": 1156, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 835
test_input = { "k": 1171, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 2386
test_input = { "k": 1172, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 297
test_input = { "k": 1227, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 2506
test_input = { "k": 1236, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 2515
test_input = { "k": 1270, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 1525
test_input = { "k": 1274, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2220
test_input = { "k": 1281, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2223
test_input = { "k": 1282, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2224
test_input = { "k": 1288, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 1543
test_input = { "k": 1376, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2287
test_input = { "k": 1393, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 2800
test_input = { "k": 1415, "x": 4 }
assert my_solution.findMaximumNumber(**test_input) == 1454
test_input = { "k": 1446, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 2917
test_input = { "k": 1459, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 358
test_input = { "k": 1520, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 1017
test_input = { "k": 1539, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2400
test_input = { "k": 1545, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3144
test_input = { "k": 1573, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 1732
test_input = { "k": 1588, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 3251
test_input = { "k": 1590, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3189
test_input = { "k": 1617, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3280
test_input = { "k": 1633, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2463
test_input = { "k": 1634, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3297
test_input = { "k": 1687, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 741
test_input = { "k": 1731, "x": 6 }
assert my_solution.findMaximumNumber(**test_input) == 2528
test_input = { "k": 1750, "x": 5 }
assert my_solution.findMaximumNumber(**test_input) == 1850
test_input = { "k": 1751, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3542
test_input = { "k": 1760, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 3551
test_input = { "k": 1782, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 3573
test_input = { "k": 1787, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 766
test_input = { "k": 1851, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 797
test_input = { "k": 1856, "x": 2 }
assert my_solution.findMaximumNumber(**test_input) == 799
test_input = { "k": 1874, "x": 8 }
assert my_solution.findMaximumNumber(**test_input) == 3793
test_input = { "k": 1893, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3812
test_input = { "k": 1900, "x": 1 }
assert my_solution.findMaximumNumber(**test_input) == 444
test_input = { "k": 1900, "x": 7 }
assert my_solution.findMaximumNumber(**test_input) == 3819
test_input = { "k": 1902, "x": 3 }
assert my_solution.findMaximumNumber(**test_input) == 1336 | 1,705,199,400 |
weekly-contest-380-find-beautiful-indices-in-the-given-array-ii | https://leetcode.com/problems/find-beautiful-indices-in-the-given-array-ii | find-beautiful-indices-in-the-given-array-ii | {
"questionId": "3303",
"questionFrontendId": "3008",
"title": "Find Beautiful Indices in the Given Array II",
"titleSlug": "find-beautiful-indices-in-the-given-array-ii",
"isPaidOnly": false,
"difficulty": "Hard",
"likes": 101,
"dislikes": 9,
"categoryTitle": "Algorithms"
} | """
You are given a 0-indexed string s, a string a, a string b, and an integer k.
An index i is beautiful if:
0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
There exists an index j such that:
0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k
Return the array that contains beautiful indices in sorted order from smallest to largest.
Example 1:
Input: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Output: [16,33]
Explanation: There are 2 beautiful indices: [16,33].
- The index 16 is beautiful as s[16..17] == "my" and there exists an index 4 with s[4..11] == "squirrel" and |16 - 4| <= 15.
- The index 33 is beautiful as s[33..34] == "my" and there exists an index 18 with s[18..25] == "squirrel" and |33 - 18| <= 15.
Thus we return [16,33] as the result.
Example 2:
Input: s = "abcd", a = "a", b = "a", k = 4
Output: [0]
Explanation: There is 1 beautiful index: [0].
- The index 0 is beautiful as s[0..0] == "a" and there exists an index 0 with s[0..0] == "a" and |0 - 0| <= 4.
Thus we return [0] as the result.
Constraints:
1 <= k <= s.length <= 5 * 105
1 <= a.length, b.length <= 5 * 105
s, a, and b contain only lowercase English letters.
"""
class Solution:
def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
| You are given a 0-indexed string s, a string a, a string b, and an integer k.
An index i is beautiful if:
0 <= i <= s.length - a.length
s[i..(i + a.length - 1)] == a
There exists an index j such that:
0 <= j <= s.length - b.length
s[j..(j + b.length - 1)] == b
|j - i| <= k
Return the array that contains beautiful indices in sorted order from smallest to largest.
Example 1:
Input: s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
Output: [16,33]
Explanation: There are 2 beautiful indices: [16,33].
- The index 16 is beautiful as s[16..17] == "my" and there exists an index 4 with s[4..11] == "squirrel" and |16 - 4| <= 15.
- The index 33 is beautiful as s[33..34] == "my" and there exists an index 18 with s[18..25] == "squirrel" and |33 - 18| <= 15.
Thus we return [16,33] as the result.
Example 2:
Input: s = "abcd", a = "a", b = "a", k = 4
Output: [0]
Explanation: There is 1 beautiful index: [0].
- The index 0 is beautiful as s[0..0] == "a" and there exists an index 0 with s[0..0] == "a" and |0 - 0| <= 4.
Thus we return [0] as the result.
Constraints:
1 <= k <= s.length <= 5 * 105
1 <= a.length, b.length <= 5 * 105
s, a, and b contain only lowercase English letters.
Please complete the code below to solve above prblem:
```python
class Solution:
def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
``` |
my_solution = Solution()
test_input = { "s": "isawsquirrelnearmysquirrelhouseohmy", "a": "my", "b": "squirrel", "k": 15 }
assert my_solution.beautifulIndices(**test_input) == [16,33]
test_input = { "s": "abcd", "a": "a", "b": "a", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "a", "a": "a", "b": "a", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "aba", "a": "a", "b": "a", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == [0,2]
test_input = { "s": "nvnvt", "a": "eq", "b": "nv", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "npearbvede", "a": "myqpb", "b": "pearb", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vatevavakz", "a": "va", "b": "lbda", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ithhi", "a": "t", "b": "hhi", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "osuv", "a": "osuv", "b": "wrn", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dc", "a": "dreec", "b": "dc", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "jajrfw", "a": "rf", "b": "j", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "zcvx", "a": "kfdvv", "b": "tru", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "wltmqbxt", "a": "mqbxt", "b": "lt", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "gggsytwgzg", "a": "sytwg", "b": "g", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "diive", "a": "viw", "b": "lqqdn", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ss", "a": "omkdt", "b": "s", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "hfzoxcm", "a": "hfzo", "b": "ipelr", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "xllimtmil", "a": "imt", "b": "iwqx", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vdyl", "a": "i", "b": "ir", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ouwpaz", "a": "mxre", "b": "pa", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vlxgolxgoi", "a": "xf", "b": "lxgo", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "pnb", "a": "cx", "b": "pn", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "owhixi", "a": "hixi", "b": "anlc", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lrtsi", "a": "lrts", "b": "i", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tpyq", "a": "sa", "b": "py", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "imxclscgz", "a": "iujc", "b": "mxcls", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "sc", "a": "fc", "b": "th", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tgs", "a": "ldy", "b": "tgs", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ssaeqzzvvg", "a": "ssa", "b": "z", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "zchdy", "a": "zch", "b": "dm", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "youob", "a": "y", "b": "o", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "snwj", "a": "snwj", "b": "ry", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "rneq", "a": "ynprc", "b": "yts", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vxqf", "a": "tcnzs", "b": "qf", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "avnzbrpb", "a": "yzfgy", "b": "cfri", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "de", "a": "segs", "b": "bvdhs", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ulgzs", "a": "eiib", "b": "ulgz", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tw", "a": "ypf", "b": "svl", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "sotqbvds", "a": "uoj", "b": "s", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "oexy", "a": "e", "b": "a", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "sywgismky", "a": "sywgi", "b": "t", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "onwawarwa", "a": "wa", "b": "r", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [4,7]
test_input = { "s": "xpuldtpxpu", "a": "vkhl", "b": "xpu", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dg", "a": "amhb", "b": "aqwcf", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "spro", "a": "spro", "b": "lytwu", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "gfjuakm", "a": "fj", "b": "jytnd", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "so", "a": "kkhvu", "b": "rukp", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "zwedfgnra", "a": "dfgn", "b": "zwe", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == [3]
test_input = { "s": "nipetnupg", "a": "n", "b": "ipet", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [0,5]
test_input = { "s": "xckrhkrnfe", "a": "xc", "b": "kr", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "xibrjp", "a": "ibr", "b": "bpfuf", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "cj", "a": "x", "b": "dea", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "xfejay", "a": "xfej", "b": "koc", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ijkqk", "a": "nzxwn", "b": "vqk", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dqa", "a": "qj", "b": "norvy", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vbgvuo", "a": "u", "b": "rewjx", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "uw", "a": "flap", "b": "lowqe", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "xoi", "a": "vefut", "b": "x", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qzfsogwd", "a": "qzfs", "b": "txsdv", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "yalimlim", "a": "lim", "b": "bwi", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "mjvosrhrip", "a": "jzz", "b": "vo", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "dyswswiz", "a": "tib", "b": "dysws", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "ftyhkld", "a": "tyh", "b": "znru", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "adubkehe", "a": "kdtxl", "b": "dubke", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "svpbvld", "a": "d", "b": "svpbv", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "rmiwdb", "a": "rmiw", "b": "xgwcv", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "arikarikox", "a": "o", "b": "arik", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == [8]
test_input = { "s": "cigzky", "a": "cigz", "b": "tu", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "hjlllm", "a": "l", "b": "h", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [2,3,4]
test_input = { "s": "xiyebjzdbv", "a": "iqku", "b": "yebjz", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qrmogc", "a": "g", "b": "rm", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lagopphhnl", "a": "gopph", "b": "hnl", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == [2]
test_input = { "s": "xkggxk", "a": "xk", "b": "g", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [0,4]
test_input = { "s": "cdvr", "a": "iemxd", "b": "dt", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "swuaumom", "a": "swuau", "b": "m", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "qftqft", "a": "o", "b": "qft", "k": 1 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "bc", "a": "ucfx", "b": "lzgx", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "egzttzmtot", "a": "boxwe", "b": "t", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "agbx", "a": "a", "b": "tw", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "fkm", "a": "gu", "b": "fkm", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lt", "a": "z", "b": "lt", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "qkddvykd", "a": "kd", "b": "tprs", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vndnqdehvr", "a": "dnqd", "b": "ybboz", "k": 8 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lpnltfewly", "a": "few", "b": "l", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [5]
test_input = { "s": "lgioimioim", "a": "imsfs", "b": "ioim", "k": 10 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "jhucel", "a": "iox", "b": "nx", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "vdgtlvls", "a": "lvl", "b": "cu", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "buyryryrjq", "a": "yr", "b": "u", "k": 9 }
assert my_solution.beautifulIndices(**test_input) == [2,4,6]
test_input = { "s": "fwohvc", "a": "agagg", "b": "fwoh", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tjityoib", "a": "vh", "b": "jityo", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "tssjrbpsck", "a": "ssjr", "b": "sc", "k": 10 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "aqxv", "a": "t", "b": "x", "k": 4 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "zw", "a": "l", "b": "c", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "cbccekck", "a": "c", "b": "k", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [0,2,3,6]
test_input = { "s": "angkytf", "a": "ngk", "b": "ytf", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [1]
test_input = { "s": "oloxjjjqj", "a": "olox", "b": "j", "k": 7 }
assert my_solution.beautifulIndices(**test_input) == [0]
test_input = { "s": "zbriomnn", "a": "omn", "b": "zbr", "k": 6 }
assert my_solution.beautifulIndices(**test_input) == [4]
test_input = { "s": "ydmlx", "a": "tu", "b": "dml", "k": 5 }
assert my_solution.beautifulIndices(**test_input) == []
test_input = { "s": "lnoffflno", "a": "lno", "b": "f", "k": 3 }
assert my_solution.beautifulIndices(**test_input) == [0,6]
test_input = { "s": "hwayzb", "a": "fc", "b": "hway", "k": 2 }
assert my_solution.beautifulIndices(**test_input) == [] | 1,705,199,400 |
End of preview. Expand
in Dataset Viewer.
LeetCode Contest Benchmark
A new benchmark for evaluating Code LLMs proposed by DeepSeek-Coder, which consists of the latest algorithm problems of different difficulties.
Usage
git clone https://github.com/deepseek-ai/DeepSeek-Coder.git
cd Evaluation/LeetCode
# Set the model or path here
MODEL="deepseek-ai/deepseek-coder-7b-instruct"
python vllm_inference.py --model_name_or_path $MODEL --saved_path output/20240121-Jul.deepseek-coder-7b-instruct.jsonl
python evaluate_leetcode.py --generation_path output/20240121-Jul.deepseek-coder-7b-instruct.jsonl --result_path output/20240121-Jul.deepseek-coder-7b-instruct.result.jsonl
Citation
@article{guo2024deepseekcoder,
title = {DeepSeek-Coder: When the Large Language Model Meets Programming - The Rise of Code Intelligence},
author = {Daya Guo and Qihao Zhu and Dejian Yang and Zhenda Xie and Kai Dong and Wentao Zhang and Guanting Chen and Xiao Bi and Y. Wu and Y. K. Li and Fuli Luo and Yingfei Xiong and Wenfeng Liang},
year = {2024},
journal = {arXiv preprint arXiv: 2401.14196}
}
- Downloads last month
- 0