import numpy as np
from scipy.optimize import minimize

def solve():
    fun = lambda x: -1.0 * np.log(x[0] + x[1])
    bounds = [(0, None), (0, None), (0, None)]
    cons = {'type': 'eq', 'fun': lambda x: x[0] + 2*x[1] + x[2] - 5}
    x0 = np.array([1, 1, 2], dtype=np.float32)
    res = minimize(fun, x0, bounds=bounds, constraints=cons)
    return -1.0 * res.fun

max f(x) = ln(x1 + x2)
s.t.
x1 + 2 x2 <= 5
x1 >= 0, x2 >= 0

定义python函数 solve() 求解这个最优化问题，返回最大值

#<INSERT>

assert abs(solve() - 1.6094) < 1e-3


问题：写一段 python 代码实现以下功能。
找出小于第n个斐波那契数的最大完全平方数
函数命名为 max_square_number，输入为整数 n

答案：
```python
def max_square_number(n):
    if n <= 2:
        return 0  # 对于斐波那契数列的前两个数，没有完全平方数可用

    fibs = [0, 1]  # 存储斐波那契数列的前两个数
    squares = []  # 存储完全平方数的列表

    max_square = 0
    i = 2

    while i <= n:
        fibs.append(fibs[i-1] + fibs[i-2])  # 计算下一个斐波那契数
        i += 1

    fib = fibs[-1]
    perfect_squares = [i**2 for i in range(1, int(math.sqrt(fib)) + 1)]
    max_square = max(filter(lambda x: x < fib, perfect_squares))
    return max_square
```

----------------


import numpy as np
from scipy.optimize import curve_fit

def solve(arr):
    def func(x, a, b, c, d):
        return a * np.exp(-b * x + c * x**2) + d
    popt, pcov = curve_fit(func, arr[:, 0], arr[:, 1])
    return popt

已知一些2D点是由 y = a * exp(-b * x + c x^2) + d 生成的。给定这些点，请拟合出 a,b,c,d

定义python函数 solve(arr) 解决问题。输入 [N, 2] 的numpy数组，返回一个长度4的numpy数组代表 [a, b, c, d]

#<INSERT>

import numpy as np

def f1(x, a, b, c, d):
    return a * np.exp(-b * x + c * x**2) + d

x = np.linspace(0, 4, 50)
y = f1(x, 2.5, 1.3, 0.3, 0.5) + np.random.normal(0, 0.003, 50)
arr = np.stack((x, y), -1)
assert np.abs(solve(arr) - np.array([2.5, 1.3, 0.3, 0.5])).mean() < 0.1


import numpy as np
from scipy import optimize

def solve():
    def fun(x):
        return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0, 0.5 * (x[1] - x[0])**3 + x[1]]
    sol = optimize.root(fun, [0, 0], method='hybr')
    return sol.x

求下面方程的根

x_1 + 0.5 * (x_1 - x_2)^3 = 1
0.5 * (x_2 - x_1)^3 + x2 = 0

定义python函数 solve() 解决问题，返回一个长度为2的列表，表示方程的两个根

import numpy as np

#<INSERT>

assert np.abs(solve() - np.array([0.8411639, 0.1588361])).sum() < 1e-5


import numpy as np
from scipy import optimize

def solve():
    def fun(x):
        return [x[0]**2 + x[1]**2 - x[2]**2, x[0] + x[1] + x[2] - 10, x[0] - x[1]]
    sol = optimize.root(fun, [0, 0, 0], method='hybr')
    return sol.x

求下面方程的根

a^2 + b^2 = c^2
a + b + c = 10
a = b

定义python函数 solve() 解决问题，返回一个长度为3的列表[a, b, c]


from scipy.integrate import tplquad
import numpy as np

def solve():
    f = lambda z, y, x: np.exp(-(x**2 + y**2 + z**2))
    ret, _ = tplquad(f, -np.inf, np.inf, -np.inf, np.inf, -np.inf, np.inf)
    return ret

计算 $\iiint_{-\infty}^{\infty} e^{-(x^2 + y^2 + z^2)}dzdydz$
定义python函数solve解决问题，返回答案

#<INSERT>

assert abs(solve() - 5.56833) < 1e-3


import numpy as np
from scipy.optimize import basinhopping

def solve():
    def f(x):
        return np.cos(x**2 + 10*x + 3) + x**2 + 3*x
    ret = basinhopping(f, -1, niter=100)
    return ret.fun

f(x) = cos(x^2 + 10x + 3) + x^2 + 3x
有很多局部极值。求他的全局极值。

定义python函数 solve() 解决问题，返回全局极值


from scipy.integrate import dblquad
import numpy as np

def solve():
    f = lambda y, x : x*np.cos(y)
    ret, _ = dblquad(f, 0, 1, lambda x:-np.sqrt(x), lambda x:np.sqrt(x))
    return ret

计算 $\int_{x=0}^{1} \int_{y=-\sqrt{x}}^{\sqrt{x}} x cos(y) dy dx$
定义python函数solve解决问题，返回答案

#<INSERT>

assert abs(solve() - 0.70839) < 1e-3


from scipy.integrate import dblquad
import numpy as np

def solve():
    f = lambda y, x : x*y
    ret, _ = dblquad(f, 0, 1, lambda x:x, lambda x:2-x)
    return ret

计算 $\int_{x=0}^{1} \int_{y=x}^{2-x} xy dy dx$
定义python函数solve解决问题，返回答案


from scipy.integrate import dblquad
import numpy as np

def solve():
    f = lambda y, x : x*y**2
    ret, _ = dblquad(f, 0, 2, 0, 1)
    return ret

计算 $\int_{x=0}^{2} \int_{y=0}^{1} xy^2 dy dx$
定义python函数solve解决问题，返回答案


from scipy.integrate import quad
import numpy as np

def solve():
    f = lambda x : np.cos(x**2) * np.exp(-x)
    y, _ = quad(f, 0, np.inf)
    return y

计算 $\int_0^{\infty} cos(x^2)exp(-x) dx$
定义python函数solve解决问题，返回答案

#<INSERT>

assert abs(solve() - 0.534878) < 1e-3


from scipy.optimize import brenth

def solve():
    def f(x):
        return x**3 + 3 * x**2 - 10 * x - 32
    return brenth(f, 0, 5)

计算方程 x^3 + 3x^2 - 10x - 32 = 0 在 [0, 5] 内的根
定义python函数 solve() 解决问题，返回根


from scipy.integrate import quad
import numpy as np

def solve():
    f = lambda x : np.cos(x**2)
    y, _ = quad(f, 0, 10)
    return y

计算 $\int_0^{10} cos(x^2) dx$
定义python函数solve解决问题，返回答案

#<INSERT>

assert abs(solve() - 0.601125) < 1e-3


class Solution(object):
    def minimumCost(self, source, target, original, changed, cost):
        """
        :type source: str
        :type target: str
        :type original: List[str]
        :type changed: List[str]
        :type cost: List[int]
        :rtype: int
        """
        exit(0)

给你两个下标从 **0** 开始的字符串 `source` 和 `target` ，它们的长度均为 `n` 并且由 **小写** 英文字母组成。

另给你两个下标从 **0** 开始的字符串数组 `original` 和 `changed` ，以及一个整数数组 `cost` ，其中 `cost[i]` 代表将字符串 `original[i]` 更改为字符串 `changed[i]` 的成本。

你从字符串 `source` 开始。在一次操作中，**如果** 存在 **任意** 下标 `j` 满足 `cost[j] == z`  、`original[j] == x` 以及 `changed[j] == y` ，你就可以选择字符串中的 **子串** `x` 并以 `z` 的成本将其更改为 `y` 。 你可以执行 **任意数量** 的操作，但是任两次操作必须满足 **以下两个** 条件 **之一** ：

* 在两次操作中选择的子串分别是 `source[a..b]` 和 `source[c..d]` ，满足 `b < c`  **或** `d < a` 。换句话说，两次操作中选择的下标 **不相交** 。
* 在两次操作中选择的子串分别是 `source[a..b]` 和 `source[c..d]` ，满足 `a == c` **且** `b == d` 。换句话说，两次操作中选择的下标 **相同** 。

返回将字符串 `source` 转换为字符串 `target` 所需的 **最小** 成本。如果不可能完成转换，则返回 `-1` 。

**注意**，可能存在下标 `i` 、`j` 使得 `original[j] == original[i]` 且 `changed[j] == changed[i]` 。

**示例 1：**

```

**输入：**source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
**输出：**28
**解释：**将 "abcd" 转换为 "acbe"，执行以下操作：
- 将子串 source[1..1] 从 "b" 改为 "c" ，成本为 5 。
- 将子串 source[2..2] 从 "c" 改为 "e" ，成本为 1 。
- 将子串 source[2..2] 从 "e" 改为 "b" ，成本为 2 。
- 将子串 source[3..3] 从 "d" 改为 "e" ，成本为 20 。
产生的总成本是 5 + 1 + 2 + 20 = 28 。
可以证明这是可能的最小成本。

```

**示例 2：**

```

**输入：**source = "abcdefgh", target = "acdeeghh", original = ["bcd","fgh","thh"], changed = ["cde","thh","ghh"], cost = [1,3,5]
**输出：**9
**解释：**将 "abcdefgh" 转换为 "acdeeghh"，执行以下操作：
- 将子串 source[1..3] 从 "bcd" 改为 "cde" ，成本为 1 。
- 将子串 source[5..7] 从 "fgh" 改为 "thh" ，成本为 3 。可以执行此操作，因为下标 [5,7] 与第一次操作选中的下标不相交。
- 将子串 source[5..7] 从 "thh" 改为 "ghh" ，成本为 5 。可以执行此操作，因为下标 [5,7] 与第一次操作选中的下标不相交，且与第二次操作选中的下标相同。
产生的总成本是 1 + 3 + 5 = 9 。
可以证明这是可能的最小成本。

```

**示例 3：**

```

**输入：**source = "abcdefgh", target = "addddddd", original = ["bcd","defgh"], changed = ["ddd","ddddd"], cost = [100,1578]
**输出：**-1
**解释：**无法将 "abcdefgh" 转换为 "addddddd" 。
如果选择子串 source[1..3] 执行第一次操作，以将 "abcdefgh" 改为 "adddefgh" ，你无法选择子串 source[3..7] 执行第二次操作，因为两次操作有一个共用下标 3 。
如果选择子串 source[3..7] 执行第一次操作，以将 "abcdefgh" 改为 "abcddddd" ，你无法选择子串 source[1..3] 执行第二次操作，因为两次操作有一个共用下标 3 。

```

**提示：**

* `1 <= source.length == target.length <= 1000`
* `source`、`target` 均由小写英文字母组成
* `1 <= cost.length == original.length == changed.length <= 100`
* `1 <= original[i].length == changed[i].length <= source.length`
* `original[i]`、`changed[i]` 均由小写英文字母组成
* `original[i] != changed[i]`
* `1 <= cost[i] <= 106`

请完成以下实现
```python
class Solution(object):
    def minimumCost(self, source, target, original, changed, cost):
        '''
        :type source: str
        :type target: str
        :type original: List[str]
        :type changed: List[str]
        :type cost: List[int]
        :rtype: int
        '''
```

问题：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

请完成以下实现
```python
class Solution(object):
    def twoSum(self, nums, target):
        '''
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        '''
```

答案：
```python
class Solution:
    def twoSum(self, nums, target):
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []
```

----------------


class Solution(object):
    def numberOfSequence(self, n, sick):
        """
        :type n: int
        :type sick: List[int]
        :rtype: int
        """
        exit(0)

给你一个整数 `n` 和一个下标从 **0** 开始的整数数组 `sick` ，数组按 **升序** 排序。

有 `n` 位小朋友站成一排，按顺序编号为 `0` 到 `n - 1` 。数组 `sick` 包含一开始得了感冒的小朋友的位置。如果位置为 `i` 的小朋友得了感冒，他会传染给下标为 `i - 1` 或者 `i + 1` 的小朋友，**前提** 是被传染的小朋友存在且还没有得感冒。每一秒中， **至多一位** 还没感冒的小朋友会被传染。

经过有限的秒数后，队列中所有小朋友都会感冒。**感冒序列** 指的是 **所有** 一开始没有感冒的小朋友最后得感冒的顺序序列。请你返回所有感冒序列的数目。

由于答案可能很大，请你将答案对 `109 + 7` 取余后返回。

**注意**，感冒序列 **不** 包含一开始就得了感冒的小朋友的下标。

**示例 1：**

```

**输入：**n = 5, sick = [0,4]
**输出：**4
**解释：**一开始，下标为 1 ，2 和 3 的小朋友没有感冒。总共有 4 个可能的感冒序列：
- 一开始，下标为 1 和 3 的小朋友可以被传染，因为他们分别挨着有感冒的小朋友 0 和 4 ，令下标为 1 的小朋友先被传染。
然后，下标为 2 的小朋友挨着感冒的小朋友 1 ，下标为 3 的小朋友挨着感冒的小朋友 4 ，两位小朋友都可以被传染，令下标为 2 的小朋友被传染。
最后，下标为 3 的小朋友被传染，因为他挨着感冒的小朋友 2 和 4 ，感冒序列为 [1,2,3] 。
- 一开始，下标为 1 和 3 的小朋友可以被传染，因为他们分别挨着感冒的小朋友 0 和 4 ，令下标为 1 的小朋友先被传染。
然后，下标为 2 的小朋友挨着感冒的小朋友 1 ，下标为 3 的小朋友挨着感冒的小朋友 4 ，两位小朋友都可以被传染，令下标为 3 的小朋友被传染。
最后，下标为 2 的小朋友被传染，因为他挨着感冒的小朋友 1 和 3 ，感冒序列为  [1,3,2] 。
- 感冒序列 [3,1,2] ，被传染的顺序：[***0***,1,2,3,***4***] => [***0***,1,2,***3***,***4***] => [***0***,***1***,2,***3***,***4***] => [***0***,***1***,***2***,***3***,***4***] 。
- 感冒序列 [3,2,1] ，被传染的顺序：[***0***,1,2,3,***4***] => [***0***,1,2,***3***,***4***] => [***0***,1,***2***,***3***,***4***] => [***0***,***1***,***2***,***3***,***4***] 。

```

**示例 2：**

```

**输入：**n = 4, sick = [1]
**输出：**3
**解释：**一开始，下标为 0 ，2 和 3 的小朋友没有感冒。总共有 3 个可能的感冒序列：
- 感冒序列 [0,2,3] ，被传染的顺序：[0,***1***,2,3] => [***0***,***1***,2,3] => [***0***,***1***,***2***,3] => [***0***,***1***,***2***,***3***] 。
- 感冒序列 [2,0,3] ，被传染的顺序：[0,***1***,2,3] => [0,***1***,***2***,3] => [***0***,***1***,***2***,3] => [***0***,***1***,***2***,***3***] 。
- 感冒序列 [2,3,0] ，被传染的顺序：[0,***1***,2,3] => [0,***1***,***2***,3] => [0,***1***,***2***,***3***] => [***0***,***1***,***2***,***3***] 。

```

**提示：**

* `2 <= n <= 105`
* `1 <= sick.length <= n - 1`
* `0 <= sick[i] <= n - 1`
* `sick` 按升序排列。

请完成以下实现
```python
class Solution(object):
    def numberOfSequence(self, n, sick):
        '''
        :type n: int
        :type sick: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.numberOfSequence(*[5, [0, 4]]) == 4

assert my_solution.numberOfSequence(*[4, [1]]) == 3

assert my_solution.numberOfSequence(*[2, [0]]) == 1

assert my_solution.numberOfSequence(*[5, [0]]) == 1

assert my_solution.numberOfSequence(*[100, [0]]) == 1

assert my_solution.numberOfSequence(*[2, [1]]) == 1

assert my_solution.numberOfSequence(*[5, [1]]) == 4

assert my_solution.numberOfSequence(*[5, [2]]) == 6

assert my_solution.numberOfSequence(*[5, [3]]) == 4

assert my_solution.numberOfSequence(*[5, [4]]) == 1

assert my_solution.numberOfSequence(*[5, [0, 1]]) == 1

assert my_solution.numberOfSequence(*[3, [0, 2]]) == 1

assert my_solution.numberOfSequence(*[5, [0, 2]]) == 3

assert my_solution.numberOfSequence(*[5, [0, 3]]) == 6

assert my_solution.numberOfSequence(*[5, [1, 2]]) == 3

assert my_solution.numberOfSequence(*[5, [1, 3]]) == 6

assert my_solution.numberOfSequence(*[5, [1, 4]]) == 6

assert my_solution.numberOfSequence(*[5, [2, 3]]) == 3

assert my_solution.numberOfSequence(*[5, [2, 4]]) == 3

assert my_solution.numberOfSequence(*[5, [3, 4]]) == 1


#include <cstdlib>
class Solution {
public:
    long long maxSpending(vector<vector<int>> values) {
        exit(0);
    }
};

给你一个下标从 **0** 开始大小为 `m * n` 的整数矩阵 `values` ，表示 `m` 个不同商店里 `m * n` 件不同的物品。每个商店有 `n` 件物品，第 `i` 个商店的第 `j` 件物品的价值为 `values[i][j]` 。除此以外，第 `i` 个商店的物品已经按照价值非递增排好序了，也就是说对于所有 `0 <= j < n - 1` 都有 `values[i][j] >= values[i][j + 1]` 。

每一天，你可以在一个商店里购买一件物品。具体来说，在第 `d` 天，你可以：

* 选择商店 `i` 。
* 购买数组中最右边的物品 `j` ，开销为 `values[i][j] * d` 。换句话说，选择该商店中还没购买过的物品中最大的下标 `j` ，并且花费 `values[i][j] * d` 去购买。

**注意**，所有物品都视为不同的物品。比方说如果你已经从商店 `1` 购买了物品 `0` ，你还可以在别的商店里购买其他商店的物品 `0` 。

请你返回购买所有 `m * n` 件物品需要的 **最大开销** 。

**示例 1：**

```

**输入：**values = [[8,5,2],[6,4,1],[9,7,3]]
**输出：**285
**解释：**第一天，从商店 1 购买物品 2 ，开销为 values[1][2] * 1 = 1 。
第二天，从商店 0 购买物品 2 ，开销为 values[0][2] * 2 = 4 。
第三天，从商店 2 购买物品 2 ，开销为 values[2][2] * 3 = 9 。
第四天，从商店 1 购买物品 1 ，开销为 values[1][1] * 4 = 16 。
第五天，从商店 0 购买物品 1 ，开销为 values[0][1] * 5 = 25 。
第六天，从商店 1 购买物品 0 ，开销为 values[1][0] * 6 = 36 。
第七天，从商店 2 购买物品 1 ，开销为 values[2][1] * 7 = 49 。
第八天，从商店 0 购买物品 0 ，开销为 values[0][0] * 8 = 64 。
第九天，从商店 2 购买物品 0 ，开销为 values[2][0] * 9 = 81 。
所以总开销为 285 。
285 是购买所有 m * n 件物品的最大总开销。

```

**示例 2：**

```

**输入：**values = [[10,8,6,4,2],[9,7,5,3,2]]
**输出：**386
**解释：**第一天，从商店 0 购买物品 4 ，开销为 values[0][4] * 1 = 2 。
第二天，从商店 1 购买物品 4 ，开销为 values[1][4] * 2 = 4 。
第三天，从商店 1 购买物品 3 ，开销为 values[1][3] * 3 = 9 。
第四天，从商店 0 购买物品 3 ，开销为 values[0][3] * 4 = 16 。
第五天，从商店 1 购买物品 2 ，开销为 values[1][2] * 5 = 25 。
第六天，从商店 0 购买物品 2 ，开销为 values[0][2] * 6 = 36 。
第七天，从商店 1 购买物品 1 ，开销为 values[1][1] * 7 = 49 。
第八天，从商店 0 购买物品 1 ，开销为 values[0][1] * 8 = 64 。
第九天，从商店 1 购买物品 0 ，开销为 values[1][0] * 9 = 81 。
第十天，从商店 0 购买物品 0 ，开销为 values[0][0] * 10 = 100 。
所以总开销为 386 。
386 是购买所有 m * n 件物品的最大总开销。

```

**提示：**

* `1 <= m == values.length <= 10`
* `1 <= n == values[i].length <= 104`
* `1 <= values[i][j] <= 106`
* `values[i]` 按照非递增顺序排序。

请完成以下实现
```cpp
class Solution {
public:
    long long maxSpending(vector<vector<int>> values);
};
```

问题：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

请完成以下实现
```cpp
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target);
};
```

答案：
```cpp
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (nums[i] + nums[j] == target) {
                    return {i, j};
                }
            }
        }
        return {};
    }
};
```

----------------

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<long long>(my_solution.maxSpending({{8, 5, 2}, {6, 4, 1}, {9, 7, 3}}), 285));

assert (areEqual<long long>(my_solution.maxSpending({{10, 8, 6, 4, 2}, {9, 7, 5, 3, 2}}), 386));

assert (areEqual<long long>(my_solution.maxSpending({{1000000}}), 1000000));

assert (areEqual<long long>(my_solution.maxSpending({{1}}), 1));

assert (areEqual<long long>(my_solution.maxSpending({{1}, {2}}), 5));

assert (areEqual<long long>(my_solution.maxSpending({{2}, {1}}), 5));

assert (areEqual<long long>(my_solution.maxSpending({{1}, {1}}), 3));

assert (areEqual<long long>(my_solution.maxSpending({{5, 2}}), 12));

assert (areEqual<long long>(my_solution.maxSpending({{5, 5}}), 15));

assert (areEqual<long long>(my_solution.maxSpending({{7, 5}}), 19));

assert (areEqual<long long>(my_solution.maxSpending({{3, 2, 1}}), 14));

assert (areEqual<long long>(my_solution.maxSpending({{2, 2, 1}}), 11));

assert (areEqual<long long>(my_solution.maxSpending({{3, 3, 2}}), 17));

assert (areEqual<long long>(my_solution.maxSpending({{3}, {2}, {1}}), 14));

assert (areEqual<long long>(my_solution.maxSpending({{2}, {10}, {1}}), 35));

assert (areEqual<long long>(my_solution.maxSpending({{1000000, 1000000, 1000000}}), 6000000));

assert (areEqual<long long>(my_solution.maxSpending({{1000000, 1000000, 1000000, 1000000}}), 10000000));

assert (areEqual<long long>(my_solution.maxSpending({{1000000}, {1000000}, {1000000}, {1000000}}), 10000000));

assert (areEqual<long long>(my_solution.maxSpending({{1000000, 1000000}, {1000000, 1000000}}), 10000000));

assert (areEqual<long long>(my_solution.maxSpending({{2, 1}, {4, 3}}), 30));

}


#include <cstdlib>
class Solution {
public:
    vector<int> leftmostBuildingQueries(vector<int> heights, vector<vector<int>> queries) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的正整数数组 `heights` ，其中 `heights[i]` 表示第 `i` 栋建筑的高度。

如果一个人在建筑 `i` ，且存在 `i < j` 的建筑 `j` 满足 `heights[i] < heights[j]` ，那么这个人可以移动到建筑 `j` 。

给你另外一个数组 `queries` ，其中 `queries[i] = [ai, bi]` 。第 `i` 个查询中，Alice 在建筑 `ai` ，Bob 在建筑 `bi`。

请你能返回一个数组 `ans` ，其中 `ans[i]` 是第 `i` 个查询中，Alice 和 Bob 可以相遇的 **最左边的建筑** 。如果对于查询 `i` ，Alice和Bob 不能相遇，令 `ans[i]` 为 `-1` 。

**示例 1：**

```

**输入：**heights = [6,4,8,5,2,7], queries = [[0,1],[0,3],[2,4],[3,4],[2,2]]
**输出：**[2,5,-1,5,2]
**解释：**第一个查询中，Alice 和 Bob 可以移动到建筑 2 ，因为 heights[0] < heights[2] 且 heights[1] < heights[2] 。
第二个查询中，Alice 和 Bob 可以移动到建筑 5 ，因为 heights[0] < heights[5] 且 heights[3] < heights[5] 。
第三个查询中，Alice 无法与 Bob 相遇，因为 Alice 不能移动到任何其他建筑。
第四个查询中，Alice 和 Bob 可以移动到建筑 5 ，因为 heights[3] < heights[5] 且 heights[4] < heights[5] 。
第五个查询中，Alice 和 Bob 已经在同一栋建筑中。
对于 ans[i] != -1 ，ans[i] 是 Alice 和 Bob 可以相遇的建筑中最左边建筑的下标。
对于 ans[i] == -1 ，不存在 Alice 和 Bob 可以相遇的建筑。

```

**示例 2：**

```

**输入：**heights = [5,3,8,2,6,1,4,6], queries = [[0,7],[3,5],[5,2],[3,0],[1,6]]
**输出：**[7,6,-1,4,6]
**解释：**第一个查询中，Alice 可以直接移动到 Bob 的建筑，因为 heights[0] < heights[7] 。
第二个查询中，Alice 和 Bob 可以移动到建筑 6 ，因为 heights[3] < heights[6] 且 heights[5] < heights[6] 。
第三个查询中，Alice 无法与 Bob 相遇，因为 Bob 不能移动到任何其他建筑。
第四个查询中，Alice 和 Bob 可以移动到建筑 4 ，因为 heights[3] < heights[4] 且 heights[0] < heights[4] 。
第五个查询中，Alice 可以直接移动到 Bob 的建筑，因为 heights[1] < heights[6] 。
对于 ans[i] != -1 ，ans[i] 是 Alice 和 Bob 可以相遇的建筑中最左边建筑的下标。
对于 ans[i] == -1 ，不存在 Alice 和 Bob 可以相遇的建筑。

```

**提示：**

* `1 <= heights.length <= 5 * 104`
* `1 <= heights[i] <= 109`
* `1 <= queries.length <= 5 * 104`
* `queries[i] = [ai, bi]`
* `0 <= ai, bi <= heights.length - 1`

请完成以下实现
```cpp
class Solution {
public:
    vector<int> leftmostBuildingQueries(vector<int> heights, vector<vector<int>> queries);
};
```

#include<bits/stdc++.h>
#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({6, 4, 8, 5, 2, 7},{{0, 1}, {0, 3}, {2, 4}, {3, 4}, {2, 2}}), {2, 5, -1, 5, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({5, 3, 8, 2, 6, 1, 4, 6},{{0, 7}, {3, 5}, {5, 2}, {3, 0}, {1, 6}}), {7, 6, -1, 4, 6}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1},{{0, 0}}), {0}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1000000000},{{0, 0}}), {0}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 2},{{0, 0}, {0, 1}, {1, 0}, {1, 1}}), {0, 1, 1, 1}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({2, 1},{{0, 0}, {0, 1}, {1, 0}, {1, 1}}), {0, -1, -1, 1}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 2, 3},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, 1, 2, 1, 1, 2, 2, 2, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 3, 2},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, 1, 2, 1, 1, -1, 2, -1, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({2, 1, 3},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, 2, 2, 2, 1, 2, 2, 2, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({2, 3, 1},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, 1, -1, 1, 1, -1, -1, -1, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({3, 1, 2},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, -1, -1, -1, 1, 2, -1, 2, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({3, 2, 1},{{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}}), {0, -1, -1, -1, 1, -1, -1, -1, 2}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 2, 3, 4},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, 2, 3, 2, 2, 2, 3, 3, 3, 3, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 2, 4, 3},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, 2, 3, 2, 2, 2, -1, 3, 3, -1, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 3, 2, 4},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, 3, 3, 2, 3, 2, 3, 3, 3, 3, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 3, 4, 2},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, 2, -1, 2, 2, 2, -1, 3, -1, -1, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 4, 2, 3},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, -1, -1, 2, -1, 2, 3, 3, -1, 3, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({1, 4, 3, 2},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 1, 2, 3, 1, 1, -1, -1, 2, -1, 2, -1, 3, -1, -1, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({2, 1, 3, 4},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 2, 2, 3, 2, 1, 2, 3, 2, 2, 2, 3, 3, 3, 3, 3}));

assert (areEqual<vector<int>>(my_solution.leftmostBuildingQueries({2, 1, 4, 3},{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}}), {0, 2, 2, 3, 2, 1, 2, 3, 2, 2, 2, -1, 3, 3, -1, 3}));

}


#include <cstdlib>
class Solution {
public:
    vector<string> getWordsInLongestSubsequence(int n, vector<string> words, vector<int> groups) {
        exit(0);
    }
};

给你一个整数 `n` 和一个下标从 **0** 开始的字符串数组 `words` ，和一个下标从 **0** 开始的 **二进制** 数组 `groups` ，两个数组长度都是 `n` 。

你需要从下标 `[0, 1, ..., n - 1]` 中选出一个 **最长子序列** ，将这个子序列记作长度为 `k` 的 `[i0, i1, ..., ik - 1]` ，对于所有满足 `0 < j + 1 < k` 的 `j` 都有 `groups[ij] != groups[ij + 1]` 。

请你返回一个字符串数组，它是下标子序列 **依次** 对应 `words` 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。

**子序列** 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。

**注意：**`words` 中的字符串长度可能 **不相等** 。

**示例 1：**

```

**输入：**n = 3, words = ["e","a","b"], groups = [0,0,1]
**输出：**["e","b"]
**解释：**一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
得到答案为 [words[1],words[2]] = ["a","b"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 2 。
```

**示例 2：**

```

**输入：**n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
**输出：**["a","b","c"]
**解释：**一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 3 。
```

**提示：**

* `1 <= n == words.length == groups.length <= 100`
* `1 <= words[i].length <= 10`
* `0 <= groups[i] < 2`
* `words` 中的字符串 **互不相同** 。
* `words[i]` 只包含小写英文字母。

请完成以下实现
```cpp
class Solution {
public:
    vector<string> getWordsInLongestSubsequence(int n, vector<string> words, vector<int> groups);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(3,{"e", "a", "b"},{0, 0, 1}), {"e", "b"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(4,{"a", "b", "c", "d"},{1, 0, 1, 1}), {"a", "b", "c"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"c"},{0}), {"c"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"d"},{1}), {"d"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"e"},{0}), {"e"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"fe"},{0}), {"fe"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"frl"},{1}), {"frl"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"ha"},{1}), {"ha"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"l"},{0}), {"l"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"n"},{1}), {"n"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(1,{"s"},{1}), {"s"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"d", "g"},{0, 1}), {"d", "g"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"lr", "h"},{0, 0}), {"lr"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"wx", "h"},{0, 1}), {"wx", "h"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"yw", "n"},{0, 1}), {"yw", "n"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"z", "n"},{0, 0}), {"z"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(2,{"zr", "a"},{0, 0}), {"zr"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(3,{"h", "vv", "kp"},{0, 1, 0}), {"h", "vv", "kp"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(3,{"m", "v", "y"},{0, 1, 0}), {"m", "v", "y"}));

assert (areEqual<vector<string>>(my_solution.getWordsInLongestSubsequence(3,{"o", "cfy", "en"},{1, 0, 0}), {"o", "cfy"}));

}


#include <cstdlib>
class Solution {
public:
    long long minIncrementOperations(vector<int> nums, int k) {
        exit(0);
    }
};

给你一个下标从 **0** 开始、长度为 `n` 的整数数组 `nums` ，和一个整数 `k` 。

你可以执行下述 **递增** 运算 **任意** 次（可以是 **0** 次）：

* 从范围 `[0, n - 1]` 中选择一个下标 `i` ，并将 `nums[i]` 的值加 `1` 。

如果数组中任何长度 **大于或等于 3** 的子数组，其 **最大** 元素都大于或等于 `k` ，则认为数组是一个 **美丽数组** 。

以整数形式返回使数组变为 **美丽数组** 需要执行的 **最小** 递增运算数。

子数组是数组中的一个连续 **非空** 元素序列。

**示例 1：**

```

**输入：**nums = [2,3,0,0,2], k = 4
**输出：**3
**解释：**可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 1 ，并且将 nums[1] 的值加 1 -> [2,4,0,0,2] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,3] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,4] 。
长度大于或等于 3 的子数组为 [2,4,0], [4,0,0], [0,0,4], [2,4,0,0], [4,0,0,4], [2,4,0,0,4] 。
在所有子数组中，最大元素都等于 k = 4 ，所以 nums 现在是美丽数组。
可以证明无法用少于 3 次递增运算使 nums 变为美丽数组。
因此，答案为 3 。

```

**示例 2：**

```

**输入：**nums = [0,1,3,3], k = 5
**输出：**2
**解释：**可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,4,3] 。
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,5,3] 。
长度大于或等于 3 的子数组为 [0,1,5]、[1,5,3]、[0,1,5,3] 。
在所有子数组中，最大元素都等于 k = 5 ，所以 nums 现在是美丽数组。
可以证明无法用少于 2 次递增运算使 nums 变为美丽数组。
因此，答案为 2 。

```

**示例 3：**

```

**输入：**nums = [1,1,2], k = 1
**输出：**0
**解释：**在这个示例中，只有一个长度大于或等于 3 的子数组 [1,1,2] 。
其最大元素 2 已经大于 k = 1 ，所以无需执行任何增量运算。
因此，答案为 0 。

```

**提示：**

* `3 <= n == nums.length <= 105`
* `0 <= nums[i] <= 109`
* `0 <= k <= 109`

请完成以下实现
```cpp
class Solution {
public:
    long long minIncrementOperations(vector<int> nums, int k);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<long long>(my_solution.minIncrementOperations({2, 3, 0, 0, 2},4), 3));

assert (areEqual<long long>(my_solution.minIncrementOperations({0, 1, 3, 3},5), 2));

assert (areEqual<long long>(my_solution.minIncrementOperations({1, 1, 2},1), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({0, 5, 5},8), 3));

assert (areEqual<long long>(my_solution.minIncrementOperations({0, 18, 28},93), 65));

assert (areEqual<long long>(my_solution.minIncrementOperations({0, 24, 14},7), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({2, 3, 4},3), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({3, 5, 9},6), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({4, 3, 0},2), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({5, 6, 5},9), 3));

assert (areEqual<long long>(my_solution.minIncrementOperations({6, 9, 6},3), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({7, 9, 0},6), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({7, 47, 16},39), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({9, 6, 1},6), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({41, 44, 37},55), 11));

assert (areEqual<long long>(my_solution.minIncrementOperations({48, 3, 13},1), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({1, 2, 6, 9},8), 2));

assert (areEqual<long long>(my_solution.minIncrementOperations({1, 3, 1, 6},6), 3));

assert (areEqual<long long>(my_solution.minIncrementOperations({2, 35, 41, 20},4), 0));

assert (areEqual<long long>(my_solution.minIncrementOperations({3, 9, 9, 7},6), 0));

}


#include <cstdlib>
class Solution {
public:
    vector<int> findIndices(vector<int> nums, int indexDifference, int valueDifference) {
        exit(0);
    }
};

给你一个下标从 **0** 开始、长度为 `n` 的整数数组 `nums` ，以及整数 `indexDifference` 和整数 `valueDifference` 。

你的任务是从范围 `[0, n - 1]` 内找出  **2** 个满足下述所有条件的下标 `i` 和 `j` ：

* `abs(i - j) >= indexDifference` 且
* `abs(nums[i] - nums[j]) >= valueDifference`

返回整数数组 `answer`。如果存在满足题目要求的两个下标，则 `answer = [i, j]` ；否则，`answer = [-1, -1]` 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。

**注意：**`i` 和 `j` 可能 **相等** 。

**示例 1：**

```

**输入：**nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
**输出：**[0,3]
**解释：**在示例中，可以选择 i = 0 和 j = 3 。
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
因此，[0,3] 是一个符合题目要求的答案。
[3,0] 也是符合题目要求的答案。

```

**示例 2：**

```

**输入：**nums = [2,1], indexDifference = 0, valueDifference = 0
**输出：**[0,0]
**解释：**
在示例中，可以选择 i = 0 和 j = 0 。
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
因此，[0,0] 是一个符合题目要求的答案。
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。

```

**示例 3：**

```

**输入：**nums = [1,2,3], indexDifference = 2, valueDifference = 4
**输出：**[-1,-1]
**解释：**在示例中，可以证明无法找出 2 个满足所有条件的下标。
因此，返回 [-1,-1] 。
```

**提示：**

* `1 <= n == nums.length <= 105`
* `0 <= nums[i] <= 109`
* `0 <= indexDifference <= 105`
* `0 <= valueDifference <= 109`

请完成以下实现
```cpp
class Solution {
public:
    vector<int> findIndices(vector<int> nums, int indexDifference, int valueDifference);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<int>>(my_solution.findIndices({5, 1, 4, 1},2,4), {0, 3}));

assert (areEqual<vector<int>>(my_solution.findIndices({2, 1},0,0), {0, 0}));

assert (areEqual<vector<int>>(my_solution.findIndices({1, 2, 3},2,4), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({1},0,1), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({1},1,0), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({2},0,2), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({6},1,4), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({7},0,0), {0, 0}));

assert (areEqual<vector<int>>(my_solution.findIndices({8},1,6), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({9},0,1), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({9},1,9), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({12},0,5), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({16},0,16), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({16},1,6), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({46},0,36), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({0, 10},2,4), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({2, 7},2,7), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({5, 1},2,5), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({5, 12},0,10), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({8, 0},1,7), {0, 1}));

}


给你一个下标从 **0** 开始、长度为 `n` 的整数数组 `nums` ，以及整数 `indexDifference` 和整数 `valueDifference` 。

你的任务是从范围 `[0, n - 1]` 内找出  **2** 个满足下述所有条件的下标 `i` 和 `j` ：

* `abs(i - j) >= indexDifference` 且
* `abs(nums[i] - nums[j]) >= valueDifference`

返回整数数组 `answer`。如果存在满足题目要求的两个下标，则 `answer = [i, j]` ；否则，`answer = [-1, -1]` 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。

**注意：**`i` 和 `j` 可能 **相等** 。

**示例 1：**

```

**输入：**nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
**输出：**[0,3]
**解释：**在示例中，可以选择 i = 0 和 j = 3 。
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
因此，[0,3] 是一个符合题目要求的答案。
[3,0] 也是符合题目要求的答案。

```

**示例 2：**

```

**输入：**nums = [2,1], indexDifference = 0, valueDifference = 0
**输出：**[0,0]
**解释：**
在示例中，可以选择 i = 0 和 j = 0 。
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
因此，[0,0] 是一个符合题目要求的答案。
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。

```

**示例 3：**

```

**输入：**nums = [1,2,3], indexDifference = 2, valueDifference = 4
**输出：**[-1,-1]
**解释：**在示例中，可以证明无法找出 2 个满足所有条件的下标。
因此，返回 [-1,-1] 。
```

**提示：**

* `1 <= n == nums.length <= 100`
* `0 <= nums[i] <= 50`
* `0 <= indexDifference <= 100`
* `0 <= valueDifference <= 50`

请完成以下实现
```cpp
class Solution {
public:
    vector<int> findIndices(vector<int> nums, int indexDifference, int valueDifference);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<int>>(my_solution.findIndices({5, 1, 4, 1},2,4), {0, 3}));

assert (areEqual<vector<int>>(my_solution.findIndices({2, 1},0,0), {0, 0}));

assert (areEqual<vector<int>>(my_solution.findIndices({1, 2, 3},2,4), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({0},0,0), {0, 0}));

assert (areEqual<vector<int>>(my_solution.findIndices({3},0,0), {0, 0}));

assert (areEqual<vector<int>>(my_solution.findIndices({3},1,1), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({4},1,0), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({5},1,3), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({7},1,7), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({8},0,2), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({8},1,7), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({10},0,9), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({11},1,0), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({18},1,4), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({38},1,34), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({40},1,2), {-1, -1}));

assert (areEqual<vector<int>>(my_solution.findIndices({5, 10},1,2), {0, 1}));

assert (areEqual<vector<int>>(my_solution.findIndices({5, 48},0,29), {0, 1}));

assert (areEqual<vector<int>>(my_solution.findIndices({6, 3},1,2), {0, 1}));

assert (areEqual<vector<int>>(my_solution.findIndices({7, 6},1,0), {0, 1}));

}


class Solution(object):
    def beautifulIndices(self, s, a, b, k):
        """
        :type s: str
        :type a: str
        :type b: str
        :type k: int
        :rtype: List[int]
        """
        exit(0)

给你一个下标从 **0** 开始的字符串 `s` 、字符串 `a` 、字符串 `b` 和一个整数 `k` 。

如果下标 `i` 满足以下条件，则认为它是一个 **美丽下标** ：

* `0 <= i <= s.length - a.length`
* `s[i..(i + a.length - 1)] == a`
* 存在下标 `j` 使得：
	+ `0 <= j <= s.length - b.length`
	+ `s[j..(j + b.length - 1)] == b`
	+ `|j - i| <= k`

以数组形式按**从小到大排序**返回美丽下标。

**示例 1：**

```

**输入：**s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15
**输出：**[16,33]
**解释：**存在 2 个美丽下标：[16,33]。
- 下标 16 是美丽下标，因为 s[16..17] == "my" ，且存在下标 4 ，满足 s[4..11] == "squirrel" 且 |16 - 4| <= 15 。
- 下标 33 是美丽下标，因为 s[33..34] == "my" ，且存在下标 18 ，满足 s[18..25] == "squirrel" 且 |33 - 18| <= 15 。
因此返回 [16,33] 作为结果。
```

**示例 2：**

```

**输入：**s = "abcd", a = "a", b = "a", k = 4
**输出：**[0]
**解释：**存在 1 个美丽下标：[0]。
- 下标 0 是美丽下标，因为 s[0..0] == "a" ，且存在下标 0 ，满足 s[0..0] == "a" 且 |0 - 0| <= 4 。
因此返回 [0] 作为结果。
```

**提示：**

* `1 <= k <= s.length <= 5 * 105`
* `1 <= a.length, b.length <= 5 * 105`
* `s`、`a`、和 `b` 只包含小写英文字母。

请完成以下实现
```python
class Solution(object):
    def beautifulIndices(self, s, a, b, k):
        '''
        :type s: str
        :type a: str
        :type b: str
        :type k: int
        :rtype: List[int]
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.beautifulIndices(*['isawsquirrelnearmysquirrelhouseohmy', 'my', 'squirrel', 15]) == [16, 33]

assert my_solution.beautifulIndices(*['abcd', 'a', 'a', 4]) == [0]

assert my_solution.beautifulIndices(*['a', 'a', 'a', 1]) == [0]

assert my_solution.beautifulIndices(*['aba', 'a', 'a', 1]) == [0, 2]

assert my_solution.beautifulIndices(*['nvnvt', 'eq', 'nv', 1]) == []

assert my_solution.beautifulIndices(*['npearbvede', 'myqpb', 'pearb', 9]) == []

assert my_solution.beautifulIndices(*['vatevavakz', 'va', 'lbda', 1]) == []

assert my_solution.beautifulIndices(*['ithhi', 't', 'hhi', 1]) == [1]

assert my_solution.beautifulIndices(*['osuv', 'osuv', 'wrn', 1]) == []

assert my_solution.beautifulIndices(*['dc', 'dreec', 'dc', 2]) == []

assert my_solution.beautifulIndices(*['jajrfw', 'rf', 'j', 3]) == [3]

assert my_solution.beautifulIndices(*['zcvx', 'kfdvv', 'tru', 1]) == []

assert my_solution.beautifulIndices(*['wltmqbxt', 'mqbxt', 'lt', 7]) == [3]

assert my_solution.beautifulIndices(*['gggsytwgzg', 'sytwg', 'g', 4]) == [3]

assert my_solution.beautifulIndices(*['diive', 'viw', 'lqqdn', 4]) == []

assert my_solution.beautifulIndices(*['ss', 'omkdt', 's', 1]) == []

assert my_solution.beautifulIndices(*['hfzoxcm', 'hfzo', 'ipelr', 1]) == []

assert my_solution.beautifulIndices(*['xllimtmil', 'imt', 'iwqx', 5]) == []

assert my_solution.beautifulIndices(*['vdyl', 'i', 'ir', 4]) == []

assert my_solution.beautifulIndices(*['ouwpaz', 'mxre', 'pa', 5]) == []


#include <cstdlib>
class Solution {
public:
    int minProcessingTime(vector<int> processorTime, vector<int> tasks) {
        exit(0);
    }
};

你有 `n` 颗处理器，每颗处理器都有 `4` 个核心。现有 `n * 4` 个待执行任务，每个核心只执行 **一个** 任务。

给你一个下标从 **0** 开始的整数数组 `processorTime` ，表示每颗处理器最早空闲时间。另给你一个下标从 **0** 开始的整数数组 `tasks` ，表示执行每个任务所需的时间。返回所有任务都执行完毕需要的 **最小时间** 。

注意：每个核心独立执行任务。

**示例 1：**

```

**输入：**processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
**输出：**16
**解释：**
最优的方案是将下标为 4, 5, 6, 7 的任务分配给第一颗处理器（最早空闲时间 time = 8），下标为 0, 1, 2, 3 的任务分配给第二颗处理器（最早空闲时间 time = 10）。
第一颗处理器执行完所有任务需要花费的时间 = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16 。
第二颗处理器执行完所有任务需要花费的时间 = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13 。
因此，可以证明执行完所有任务需要花费的最小时间是 16 。
```

**示例 2：**

```

**输入：**processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
**输出：**23
**解释：**
最优的方案是将下标为 1, 4, 5, 6 的任务分配给第一颗处理器（最早空闲时间 time = 10），下标为 0, 2, 3, 7 的任务分配给第二颗处理器（最早空闲时间 time = 20）。
第一颗处理器执行完所有任务需要花费的时间 = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18 。
第二颗处理器执行完所有任务需要花费的时间 = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23 。
因此，可以证明执行完所有任务需要花费的最小时间是 23 。

```

**提示：**

* `1 <= n == processorTime.length <= 25000`
* `1 <= tasks.length <= 105`
* `0 <= processorTime[i] <= 109`
* `1 <= tasks[i] <= 109`
* `tasks.length == 4 * n`

请完成以下实现
```cpp
class Solution {
public:
    int minProcessingTime(vector<int> processorTime, vector<int> tasks);
};
```


class Solution(object):
    def maximumSetSize(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: int
        """
        exit(0)

给你两个下标从 `0` 开始的整数数组 `nums1` 和 `nums2` ，它们的长度都是偶数 `n` 。

你必须从 `nums1` 中移除 `n / 2` 个元素，同时从 `nums2` 中也移除 `n / 2` 个元素。移除之后，你将 `nums1` 和 `nums2` 中剩下的元素插入到集合 `s` 中。

返回集合 `s`可能的 **最多** 包含多少元素。

**示例 1：**

```

**输入：**nums1 = [1,2,1,2], nums2 = [1,1,1,1]
**输出：**2
**解释：**从 nums1 和 nums2 中移除两个 1 。移除后，数组变为 nums1 = [2,2] 和 nums2 = [1,1] 。因此，s = {1,2} 。
可以证明，在移除之后，集合 s 最多可以包含 2 个元素。

```

**示例 2：**

```

**输入：**nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
**输出：**5
**解释：**从 nums1 中移除 2、3 和 6 ，同时从 nums2 中移除两个 3 和一个 2 。移除后，数组变为 nums1 = [1,4,5] 和 nums2 = [2,3,2] 。因此，s = {1,2,3,4,5} 。
可以证明，在移除之后，集合 s 最多可以包含 5 个元素。

```

**示例 3：**

```

**输入：**nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
**输出：**6
**解释：**从 nums1 中移除 1、2 和 3 ，同时从 nums2 中移除 4、5 和 6 。移除后，数组变为 nums1 = [1,2,3] 和 nums2 = [4,5,6] 。因此，s = {1,2,3,4,5,6} 。
可以证明，在移除之后，集合 s 最多可以包含 6 个元素。
```

**提示：**

* `n == nums1.length == nums2.length`
* `1 <= n <= 2 * 104`
* `n`是偶数。
* `1 <= nums1[i], nums2[i] <= 109`

请完成以下实现
```python
class Solution(object):
    def maximumSetSize(self, nums1, nums2):
        '''
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.maximumSetSize(*[[1, 2, 1, 2], [1, 1, 1, 1]]) == 2

assert my_solution.maximumSetSize(*[[1, 2, 3, 4, 5, 6], [2, 3, 2, 3, 2, 3]]) == 5

assert my_solution.maximumSetSize(*[[1, 1, 2, 2, 3, 3], [4, 4, 5, 5, 6, 6]]) == 6

assert my_solution.maximumSetSize(*[[1, 2, 1, 1], [1, 2, 3, 4]]) == 4

assert my_solution.maximumSetSize(*[[1, 1, 1, 1], [12, 23, 41, 9]]) == 3

assert my_solution.maximumSetSize(*[[12, 23, 41, 9], [1, 1, 1, 1]]) == 3

assert my_solution.maximumSetSize(*[[9, 8, 4, 7], [5, 5, 9, 5]]) == 4

assert my_solution.maximumSetSize(*[[8, 9], [4, 3]]) == 2

assert my_solution.maximumSetSize(*[[7, 1], [6, 10]]) == 2

assert my_solution.maximumSetSize(*[[10, 3], [5, 6]]) == 2

assert my_solution.maximumSetSize(*[[3, 6], [6, 6]]) == 2

assert my_solution.maximumSetSize(*[[5, 1], [6, 6]]) == 2

assert my_solution.maximumSetSize(*[[10, 7], [8, 4]]) == 2

assert my_solution.maximumSetSize(*[[10, 8, 7, 9], [7, 9, 9, 5]]) == 4

assert my_solution.maximumSetSize(*[[1, 10, 6, 5], [3, 7, 10, 10]]) == 4

assert my_solution.maximumSetSize(*[[5, 2, 8, 6], [7, 4, 1, 1]]) == 4

assert my_solution.maximumSetSize(*[[2, 4, 1, 4], [10, 2, 4, 10]]) == 4

assert my_solution.maximumSetSize(*[[5, 7], [3, 1]]) == 2

assert my_solution.maximumSetSize(*[[1, 10, 1, 2], [9, 5, 8, 5]]) == 4

assert my_solution.maximumSetSize(*[[9, 4], [5, 7]]) == 2


#include <cstdlib>
class Solution {
public:
    vector<int> lexicographicallySmallestArray(vector<int> nums, int limit) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的 **正整数** 数组 `nums` 和一个 **正整数** `limit` 。

在一次操作中，你可以选择任意两个下标 `i` 和 `j`，**如果** 满足 `|nums[i] - nums[j]| <= limit` ，则交换 `nums[i]` 和 `nums[j]` 。

返回执行任意次操作后能得到的 **字典序最小的数组**。

如果在数组 `a` 和数组 `b` 第一个不同的位置上，数组 `a` 中的对应元素比数组 `b` 中的对应元素的字典序更小，则认为数组 `a` 就比数组 `b` 字典序更小。例如，数组 `[2,10,3]` 比数组 `[10,2,3]` 字典序更小，下标 `0` 处是两个数组第一个不同的位置，且 `2 < 10` 。

**示例 1：**

```

**输入：**nums = [1,5,3,9,8], limit = 2
**输出：**[1,3,5,8,9]
**解释：**执行 2 次操作：
- 交换 nums[1] 和 nums[2] 。数组变为 [1,3,5,9,8] 。
- 交换 nums[3] 和 nums[4] 。数组变为 [1,3,5,8,9] 。
即便执行更多次操作，也无法得到字典序更小的数组。
注意，执行不同的操作也可能会得到相同的结果。

```

**示例 2：**

```

**输入：**nums = [1,7,6,18,2,1], limit = 3
**输出：**[1,6,7,18,1,2]
**解释：**执行 3 次操作：
- 交换 nums[1] 和 nums[2] 。数组变为 [1,6,7,18,2,1] 。
- 交换 nums[0] 和 nums[4] 。数组变为 [2,6,7,18,1,1] 。
- 交换 nums[0] 和 nums[5] 。数组变为 [1,6,7,18,1,2] 。
即便执行更多次操作，也无法得到字典序更小的数组。

```

**示例 3：**

```

**输入：**nums = [1,7,28,19,10], limit = 3
**输出：**[1,7,28,19,10]
**解释：**[1,7,28,19,10] 是字典序最小的数组，因为不管怎么选择下标都无法执行操作。

```

**提示：**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 109`
* `1 <= limit <= 109`

请完成以下实现
```cpp
class Solution {
public:
    vector<int> lexicographicallySmallestArray(vector<int> nums, int limit);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1, 5, 3, 9, 8},2), {1, 3, 5, 8, 9}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1, 7, 6, 18, 2, 1},3), {1, 6, 7, 18, 1, 2}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1, 7, 28, 19, 10},3), {1, 7, 28, 19, 10}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1000000000},1), {1000000000}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1, 60, 34, 84, 62, 56, 39, 76, 49, 38},4), {1, 56, 34, 84, 60, 62, 38, 76, 49, 39}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({1, 81, 10, 79, 36, 2, 87, 12, 20, 77},7), {1, 77, 10, 79, 36, 2, 81, 12, 20, 87}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({2, 71, 5, 87, 11, 15, 70, 70, 14, 38},14), {2, 70, 5, 87, 11, 14, 70, 71, 15, 38}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({4, 3, 23, 84, 34, 88, 44, 44, 18, 15},3), {3, 4, 23, 84, 34, 88, 44, 44, 15, 18}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({4, 34, 29, 73, 51, 11, 8, 53, 98, 47},10), {4, 29, 34, 73, 47, 8, 11, 51, 98, 53}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({4, 52, 38, 59, 71, 27, 31, 83, 88, 10},14), {4, 27, 31, 38, 52, 59, 71, 83, 88, 10}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({4, 68, 8, 10, 70, 62, 27, 5, 42, 61},11), {4, 61, 5, 8, 62, 68, 27, 10, 42, 70}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 9, 35, 60, 73, 91, 61, 57, 87, 76},11), {5, 9, 35, 57, 73, 76, 60, 61, 87, 91}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 15, 68, 47, 49, 67, 9, 6, 35, 14},4), {5, 14, 67, 47, 49, 68, 6, 9, 35, 15}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 16, 43, 15, 66, 21, 58, 74, 55, 66},9), {5, 15, 43, 16, 55, 21, 58, 66, 66, 74}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 30, 92, 4, 31, 2, 17, 39, 15, 7},3), {2, 30, 92, 4, 31, 5, 15, 39, 17, 7}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 38, 68, 80, 64, 79, 50, 5, 8, 95},7), {5, 38, 64, 79, 68, 80, 50, 5, 8, 95}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({5, 100, 44, 45, 16, 30, 14, 65, 83, 64},15), {5, 100, 14, 16, 30, 44, 45, 64, 83, 65}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({6, 57, 100, 67, 4, 63, 47, 59, 21, 66},8), {4, 57, 100, 59, 6, 63, 47, 66, 21, 67}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({6, 70, 90, 1, 33, 81, 60, 80, 68, 44},7), {1, 68, 90, 6, 33, 80, 60, 81, 70, 44}));

assert (areEqual<vector<int>>(my_solution.lexicographicallySmallestArray({6, 74, 74, 74, 30, 70, 91, 74, 76, 41},1), {6, 74, 74, 74, 30, 70, 91, 74, 76, 41}));

}


#include <cstdlib>
class Solution {
public:
    vector<int> lastVisitedIntegers(vector<string> words) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的字符串数组 `words` ，其中 `words[i]` 要么是一个字符串形式的正整数，要么是字符串 `"prev"` 。

我们从数组的开头开始遍历，对于 `words` 中的每个 `"prev"` 字符串，找到 `words` 中的 **上一个遍历的整数** ，定义如下：

* `k` 表示到当前位置为止的连续 `"prev"` 字符串数目（包含当前字符串），令下标从 **0** 开始的 **整数** 数组 `nums` 表示目前为止遍历过的所有整数，同时用 `nums_reverse` 表示 `nums` 反转得到的数组，那么当前 `"prev"` 对应的 **上一个遍历的整数** 是 `nums_reverse` 数组中下标为 `(k - 1)` 的整数。
* 如果 `k` 比目前为止遍历过的整数数目 **更多** ，那么上一个遍历的整数为 `-1` 。

请你返回一个整数数组，包含所有上一个遍历的整数。

**示例 1：**

```

**输入：**words = ["1","2","prev","prev","prev"]
**输出：**[2,1,-1]
**解释：**
对于下标为 2 处的 "prev" ，上一个遍历的整数是 2 ，因为连续 "prev" 数目为 1 ，同时在数组 reverse_nums 中，第一个元素是 2 。
对于下标为 3 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev" 数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
对于下标为 4 处的 "prev" ，上一个遍历的整数是 -1 ，因为连续 "prev" 数目为 3 ，但总共只遍历过 2 个整数。

```

**示例 2：**

```

**输入：**words = ["1","prev","2","prev","prev"]
**输出：**[1,2,1]
**解释：**
对于下标为 1 处的 "prev" ，上一个遍历的整数是 1 。
对于下标为 3 处的 "prev" ，上一个遍历的整数是 2 。
对于下标为 4 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev"数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。

```

**提示：**

* `1 <= words.length <= 100`
* `words[i] == "prev"` 或 `1 <= int(words[i]) <= 100`

请完成以下实现
```cpp
class Solution {
public:
    vector<int> lastVisitedIntegers(vector<string> words);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"1", "2", "prev", "prev", "prev"}), {2, 1, -1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"1", "prev", "2", "prev", "prev"}), {1, 2, 1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "prev", "27"}), {-1, -1, -1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"17", "42"}), {}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev"}), {-1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "prev", "52", "prev"}), {-1, -1, -1, 52}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "68", "prev", "prev", "53", "40", "23", "prev"}), {-1, -1, 68, -1, 23}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"99", "23", "prev"}), {23}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "prev", "58", "99", "prev", "10", "prev"}), {-1, -1, -1, 99, 10}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "51", "prev", "prev"}), {-1, 51, -1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "46", "9", "prev"}), {-1, 9}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "prev", "prev", "prev", "26"}), {-1, -1, -1, -1, -1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "21", "prev", "76", "82", "prev", "96", "prev", "57", "prev"}), {-1, 21, 82, 96, 57}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"52", "4", "prev", "prev", "prev", "69"}), {4, 52, -1}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"24", "prev"}), {24}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"46", "prev", "78", "prev", "83", "21", "prev", "94", "50"}), {46, 78, 21}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"14", "66", "prev", "prev", "46", "prev"}), {66, 14, 46}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"35", "90"}), {}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "9", "prev", "8", "prev"}), {-1, 9, 8}));

assert (areEqual<vector<int>>(my_solution.lastVisitedIntegers({"prev", "prev", "88", "71", "47", "65", "24", "39"}), {-1, -1}));

}


class Solution(object):
    def getGoodIndices(self, variables, target):
        """
        :type variables: List[List[int]]
        :type target: int
        :rtype: List[int]
        """
        return exit(0)

给你一个下标从 **0** 开始的二维数组 `variables` ，其中 `variables[i] = [ai, bi, ci, mi]`，以及一个整数 `target` 。

如果满足以下公式，则下标 `i` 是 **好下标**：

* `0 <= i < variables.length`
* `((aibi % 10)ci) % mi == target`

返回一个由 **好下标** 组成的数组，**顺序不限** 。

**示例 1：**

```

**输入：**variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
**输出：**[0,2]
**解释：**对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [2,3,3,10] ，(23 % 10)3 % 10 = 2 。
2) 对于下标 1 ，variables[1] = [3,3,3,1] ，(33 % 10)3 % 1 = 0 。
3) 对于下标 2 ，variables[2] = [6,1,1,4] ，(61 % 10)1 % 4 = 2 。
因此，返回 [0,2] 作为答案。

```

**示例 2：**

```

**输入：**variables = [[39,3,1000,1000]], target = 17
**输出：**[]
**解释：**对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [39,3,1000,1000] ，(393 % 10)1000 % 1000 = 1 。
因此，返回 [] 作为答案。

```

**提示：**

* `1 <= variables.length <= 100`
* `variables[i] == [ai, bi, ci, mi]`
* `1 <= ai, bi, ci, mi <= 103`
* `0 <= target <= 103`

请完成以下实现
```python
class Solution(object):
    def getGoodIndices(self, variables, target):
        '''
        :type variables: List[List[int]]
        :type target: int
        :rtype: List[int]
        '''
```


#include <cstdlib>
class Solution {
public:
    vector<vector<int>> constructProductMatrix(vector<vector<int>> grid) {
        exit(0);
    }
};

给你一个下标从 **0** 开始、大小为 `n * m` 的二维整数矩阵 `grid` ，定义一个下标从 **0** 开始、大小为 `n * m` 的的二维矩阵 `p`。如果满足以下条件，则称 `p` 为 `grid` 的 **乘积矩阵** ：

* 对于每个元素 `p[i][j]` ，它的值等于除了 `grid[i][j]` 外所有元素的乘积。乘积对 `12345` 取余数。

返回 `grid` 的乘积矩阵。

**示例 1：**

```

**输入：**grid = [[1,2],[3,4]]
**输出：**[[24,12],[8,6]]
**解释：**p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
所以答案是 [[24,12],[8,6]] 。
```

**示例 2：**

```

**输入：**grid = [[12345],[2],[1]]
**输出：**[[2],[0],[0]]
**解释：**p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0 ，所以 p[0][1] = 0
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0 ，所以 p[0][2] = 0
所以答案是 [[2],[0],[0]] 。
```

**提示：**

* `1 <= n == grid.length <= 105`
* `1 <= m == grid[i].length <= 105`
* `2 <= n * m <= 105`
* `1 <= grid[i][j] <= 109`

请完成以下实现
```cpp
class Solution {
public:
    vector<vector<int>> constructProductMatrix(vector<vector<int>> grid);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1, 2}, {3, 4}}), {{24, 12}, {8, 6}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{12345}, {2}, {1}}), {{2}, {0}, {0}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1}, {2}}), {{2}, {1}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1, 2}}), {{2, 1}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{12345, 12345}}), {{0, 0}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1}, {4}}), {{4}, {1}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{3}, {4}}), {{4}, {3}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{4}, {3}}), {{3}, {4}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1, 1, 1}}), {{1, 1, 1}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{2, 1, 1}}), {{1, 2, 2}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{3}, {5}, {2}}), {{10}, {6}, {15}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1, 2}, {1, 1}, {6, 4}}), {{48, 24}, {48, 48}, {8, 12}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{1, 2, 2}, {1, 4, 3}}), {{48, 24, 24}, {48, 12, 16}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{2}, {7}, {2}, {6}}), {{84}, {24}, {84}, {28}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{3}, {4}, {7}, {7}}), {{196}, {147}, {84}, {84}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{3, 1, 1}, {1, 3, 4}}), {{12, 36, 36}, {36, 12, 9}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{4}, {8}, {3}, {7}}), {{168}, {84}, {224}, {96}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{5}, {8}, {8}, {3}}), {{192}, {120}, {120}, {320}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{6}, {5}, {8}, {5}}), {{200}, {240}, {150}, {240}}));

assert (areEqual<vector<vector<int>>>(my_solution.constructProductMatrix({{8}, {1}, {3}, {8}}), {{24}, {192}, {64}, {24}}));

}


class Solution(object):
    def minimumAddedCoins(self, coins, target):
        """
        :type coins: List[int]
        :type target: int
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `coins`，表示可用的硬币的面值，以及一个整数 `target` 。

如果存在某个 `coins` 的子序列总和为 `x`，那么整数 `x` 就是一个 **可取得的金额** 。

返回需要添加到数组中的 **任意面值** 硬币的 **最小数量** ，使范围 `[1, target]` 内的每个整数都属于 **可取得的金额** 。

数组的 **子序列** 是通过删除原始数组的一些（**可能不删除**）元素而形成的新的 **非空** 数组，删除过程不会改变剩余元素的相对位置。

**示例 1：**

```

**输入：**coins = [1,4,10], target = 19
**输出：**2
**解释：**需要添加面值为 2 和 8 的硬币各一枚，得到硬币数组 [1,2,4,8,10] 。
可以证明从 1 到 19 的所有整数都可由数组中的硬币组合得到，且需要添加到数组中的硬币数目最小为 2 。

```

**示例 2：**

```

**输入：**coins = [1,4,10,5,7,19], target = 19
**输出：**1
**解释：**只需要添加一枚面值为 2 的硬币，得到硬币数组 [1,2,4,5,7,10,19] 。
可以证明从 1 到 19 的所有整数都可由数组中的硬币组合得到，且需要添加到数组中的硬币数目最小为 1 。
```

**示例 3：**

```

**输入：**coins = [1,1,1], target = 20
**输出：**3
**解释：**
需要添加面值为 4 、8 和 16 的硬币各一枚，得到硬币数组 [1,1,1,4,8,16] 。
可以证明从 1 到 20 的所有整数都可由数组中的硬币组合得到，且需要添加到数组中的硬币数目最小为 3 。
```

**提示：**

* `1 <= target <= 105`
* `1 <= coins.length <= 105`
* `1 <= coins[i] <= target`

请完成以下实现
```python
class Solution(object):
    def minimumAddedCoins(self, coins, target):
        '''
        :type coins: List[int]
        :type target: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minimumAddedCoins(*[[1, 4, 10], 19]) == 2

assert my_solution.minimumAddedCoins(*[[1, 4, 10, 5, 7, 19], 19]) == 1

assert my_solution.minimumAddedCoins(*[[1, 1, 1], 20]) == 3

assert my_solution.minimumAddedCoins(*[[1], 100000]) == 16

assert my_solution.minimumAddedCoins(*[[100000], 100000]) == 17

assert my_solution.minimumAddedCoins(*[[2], 5]) == 2

assert my_solution.minimumAddedCoins(*[[5, 6, 7], 10]) == 3

assert my_solution.minimumAddedCoins(*[[5, 6, 7], 15]) == 3

assert my_solution.minimumAddedCoins(*[[4, 11, 13, 15, 7, 5, 12, 11, 5, 9], 34]) == 2

assert my_solution.minimumAddedCoins(*[[8, 12, 9], 27]) == 3

assert my_solution.minimumAddedCoins(*[[2, 13, 7, 1, 11], 35]) == 1

assert my_solution.minimumAddedCoins(*[[10, 3, 5, 11, 6], 27]) == 2

assert my_solution.minimumAddedCoins(*[[6, 6, 6, 15, 4], 31]) == 2

assert my_solution.minimumAddedCoins(*[[6, 15, 6], 22]) == 3

assert my_solution.minimumAddedCoins(*[[8, 14, 15, 4, 14, 15, 8, 10, 8], 42]) == 2

assert my_solution.minimumAddedCoins(*[[9, 14, 14, 9, 14, 5, 12, 10, 11], 17]) == 3

assert my_solution.minimumAddedCoins(*[[14, 5, 13, 3, 7, 10, 10, 10], 32]) == 2

assert my_solution.minimumAddedCoins(*[[8, 6, 7, 12], 26]) == 3

assert my_solution.minimumAddedCoins(*[[15, 1, 12], 43]) == 4

assert my_solution.minimumAddedCoins(*[[4, 1, 4, 10], 16]) == 1


#include <cstdlib>
class Solution {
public:
    int minimumChanges(string s, int k) {
        exit(0);
    }
};

给你一个字符串 `s` 和一个整数 `k` ，请你将 `s` 分成 `k` 个**子字符串** ，使得每个 **子字符串** 变成 **半回文串** 需要修改的字符数目最少。

请你返回一个整数，表示需要修改的 **最少** 字符数目。

**注意：**

* 如果一个字符串从左往右和从右往左读是一样的，那么它是一个 **回文串** 。
* 如果长度为 `len` 的字符串存在一个满足 `1 <= d < len` 的正整数 `d` ，`len % d == 0` 成立且所有对 `d` 做除法余数相同的下标对应的字符连起来得到的字符串都是 **回文串** ，那么我们说这个字符串是 **半回文串** 。比方说 `"aa"` ，`"aba"` ，`"adbgad"` 和 `"abab"` 都是 **半回文串** ，而 `"a"` ，`"ab"` 和 `"abca"` 不是。
* **子字符串** 指的是一个字符串中一段连续的字符序列。

**示例 1：**

```

**输入：**s = "abcac", k = 2
**输出：**1
**解释：**我们可以将 s 分成子字符串 "ab" 和 "cac" 。子字符串 "cac" 已经是半回文串。如果我们将 "ab" 变成 "aa" ，它也会变成一个 d = 1 的半回文串。
该方案是将 s 分成 2 个子字符串的前提下，得到 2 个半回文子字符串需要的最少修改次数。所以答案为 1 。
```

**示例 2:**

```

**输入：**s = "abcdef", k = 2
**输出：**2
**解释：**我们可以将 s 分成子字符串 "abc" 和 "def" 。子字符串 "abc" 和 "def" 都需要修改一个字符得到半回文串，所以我们总共需要 2 次字符修改使所有子字符串变成半回文串。
该方案是将 s 分成 2 个子字符串的前提下，得到 2 个半回文子字符串需要的最少修改次数。所以答案为 2 。
```

**示例 3：**

```

**输入：**s = "aabbaa", k = 3
**输出：**0
**解释：**我们可以将 s 分成子字符串 "aa" ，"bb" 和 "aa" 。
字符串 "aa" 和 "bb" 都已经是半回文串了。所以答案为 0 。

```

**提示：**

* `2 <= s.length <= 200`
* `1 <= k <= s.length / 2`
* `s` 只包含小写英文字母。

请完成以下实现
```cpp
class Solution {
public:
    int minimumChanges(string s, int k);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<int>(my_solution.minimumChanges("abcac",2), 1));

assert (areEqual<int>(my_solution.minimumChanges("abcdef",2), 2));

assert (areEqual<int>(my_solution.minimumChanges("aabbaa",3), 0));

assert (areEqual<int>(my_solution.minimumChanges("aq",1), 1));

assert (areEqual<int>(my_solution.minimumChanges("bb",1), 0));

assert (areEqual<int>(my_solution.minimumChanges("aac",1), 1));

assert (areEqual<int>(my_solution.minimumChanges("abcc",1), 2));

assert (areEqual<int>(my_solution.minimumChanges("acba",2), 2));

assert (areEqual<int>(my_solution.minimumChanges("edaswf",1), 2));

assert (areEqual<int>(my_solution.minimumChanges("aabcbaa",1), 0));

assert (areEqual<int>(my_solution.minimumChanges("dqpldq",3), 3));

assert (areEqual<int>(my_solution.minimumChanges("eksddulf",1), 3));

assert (areEqual<int>(my_solution.minimumChanges("aaaaacabbb",1), 3));

assert (areEqual<int>(my_solution.minimumChanges("aaabacacbb",1), 3));

assert (areEqual<int>(my_solution.minimumChanges("abbbbacaaa",1), 3));

assert (areEqual<int>(my_solution.minimumChanges("abcccbaccb",1), 2));

assert (areEqual<int>(my_solution.minimumChanges("baacbbbaba",1), 2));

assert (areEqual<int>(my_solution.minimumChanges("babcbaccba",1), 1));

assert (areEqual<int>(my_solution.minimumChanges("cabbcabcbc",1), 3));

assert (areEqual<int>(my_solution.minimumChanges("ccbccaaabb",1), 4));

}


class Solution(object):
    def findMaximumNumber(self, k, x):
        """
        :type k: int
        :type x: int
        :rtype: int
        """
        exit(0)

给你一个整数 `k` 和一个整数 `x` 。

令 `s` 为整数 `num` 的下标从 **1** 开始的二进制表示。我们说一个整数 `num` 的 **价值** 是满足 `i % x == 0` 且 `s[i]` 是 **设置位** 的 `i` 的数目。

请你返回**最大** 整数`num` ，满足从 `1` 到 `num` 的所有整数的 **价值** 和小于等于 `k` 。

**注意：**

* 一个整数二进制表示下 **设置位** 是值为 `1` 的数位。
* 一个整数的二进制表示下标从右到左编号，比方说如果 `s == 11100` ，那么 `s[4] == 1` 且 `s[2] == 0` 。

**示例 1：**

```

**输入：**k = 9, x = 1
**输出：**6
**解释：**数字 1 ，2 ，3 ，4 ，5 和 6 二进制表示分别为 "1" ，"10" ，"11" ，"100" ，"101" 和 "110" 。
由于 x 等于 1 ，每个数字的价值分别为所有设置位的数目。
这些数字的所有设置位数目总数是 9 ，所以前 6 个数字的价值和为 9 。
所以答案为 6 。
```

**示例 2：**

```

**输入：**k = 7, x = 2
**输出：**9
**解释：**由于 x 等于 2 ，我们检查每个数字的偶数位。
2 和 3 在二进制表示下的第二个数位为设置位，所以它们的价值和为 2 。
6 和 7 在二进制表示下的第二个数位为设置位，所以它们的价值和为 2 。
8 和 9 在二进制表示下的第四个数位为设置位但第二个数位不是设置位，所以它们的价值和为 2 。
数字 1 ，4 和 5 在二进制下偶数位都不是设置位，所以它们的价值和为 0 。
10 在二进制表示下的第二个数位和第四个数位都是设置位，所以它的价值为 2 。
前 9 个数字的价值和为 6 。
前 10 个数字的价值和为 8，超过了 k = 7 ，所以答案为 9 。
```

**提示：**

* `1 <= k <= 1015`
* `1 <= x <= 8`

请完成以下实现
```python
class Solution(object):
    def findMaximumNumber(self, k, x):
        '''
        :type k: int
        :type x: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.findMaximumNumber(*[9, 1]) == 6

assert my_solution.findMaximumNumber(*[7, 2]) == 9

assert my_solution.findMaximumNumber(*[19, 6]) == 50

assert my_solution.findMaximumNumber(*[57, 4]) == 120

assert my_solution.findMaximumNumber(*[58, 5]) == 121

assert my_solution.findMaximumNumber(*[60, 8]) == 187

assert my_solution.findMaximumNumber(*[72, 5]) == 151

assert my_solution.findMaximumNumber(*[81, 6]) == 176

assert my_solution.findMaximumNumber(*[83, 1]) == 33

assert my_solution.findMaximumNumber(*[83, 7]) == 210

assert my_solution.findMaximumNumber(*[116, 5]) == 243

assert my_solution.findMaximumNumber(*[157, 6]) == 316

assert my_solution.findMaximumNumber(*[201, 3]) == 212

assert my_solution.findMaximumNumber(*[268, 6]) == 555

assert my_solution.findMaximumNumber(*[281, 5]) == 531

assert my_solution.findMaximumNumber(*[283, 3]) == 274

assert my_solution.findMaximumNumber(*[309, 4]) == 364

assert my_solution.findMaximumNumber(*[363, 7]) == 746

assert my_solution.findMaximumNumber(*[409, 2]) == 220

assert my_solution.findMaximumNumber(*[456, 7]) == 967


class Solution(object):
    def canSortArray(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        exit(0)

给你一个下标从 **0** 开始且全是 **正** 整数的数组 `nums` 。

一次 **操作** 中，如果两个 **相邻** 元素在二进制下数位为 **1** 的数目 **相同** ，那么你可以将这两个元素交换。你可以执行这个操作 **任意次** （**也可以 0 次**）。

如果你可以使数组变有序，请你返回 `true` ，否则返回 `false` 。

**示例 1：**

```

**输入：**nums = [8,4,2,30,15]
**输出：**true
**解释：**我们先观察每个元素的二进制表示。 2 ，4 和 8 分别都只有一个数位为 1 ，分别为 "10" ，"100" 和 "1000" 。15 和 30 分别有 4 个数位为 1 ："1111" 和 "11110" 。
我们可以通过 4 个操作使数组有序：
- 交换 nums[0] 和 nums[1] 。8 和 4 分别只有 1 个数位为 1 。数组变为 [4,8,2,30,15] 。
- 交换 nums[1] 和 nums[2] 。8 和 2 分别只有 1 个数位为 1 。数组变为 [4,2,8,30,15] 。
- 交换 nums[0] 和 nums[1] 。4 和 2 分别只有 1 个数位为 1 。数组变为 [2,4,8,30,15] 。
- 交换 nums[3] 和 nums[4] 。30 和 15 分别有 4 个数位为 1 ，数组变为 [2,4,8,15,30] 。
数组变成有序的，所以我们返回 true 。
注意我们还可以通过其他的操作序列使数组变得有序。

```

**示例 2：**

```

**输入：**nums = [1,2,3,4,5]
**输出：**true
**解释：**数组已经是有序的，所以我们返回 true 。

```

**示例 3：**

```

**输入：**nums = [3,16,8,4,2]
**输出：**false
**解释：**无法通过操作使数组变为有序。

```

**提示：**

* `1 <= nums.length <= 100`
* `1 <= nums[i] <= 28`

请完成以下实现
```python
class Solution(object):
    def canSortArray(self, nums):
        '''
        :type nums: List[int]
        :rtype: bool
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.canSortArray(*[[8, 4, 2, 30, 15]]) == True

assert my_solution.canSortArray(*[[1, 2, 3, 4, 5]]) == True

assert my_solution.canSortArray(*[[3, 16, 8, 4, 2]]) == False

assert my_solution.canSortArray(*[[1]]) == True

assert my_solution.canSortArray(*[[4]]) == True

assert my_solution.canSortArray(*[[7]]) == True

assert my_solution.canSortArray(*[[10]]) == True

assert my_solution.canSortArray(*[[18]]) == True

assert my_solution.canSortArray(*[[30]]) == True

assert my_solution.canSortArray(*[[1, 2]]) == True

assert my_solution.canSortArray(*[[2, 17]]) == True

assert my_solution.canSortArray(*[[20, 16]]) == False

assert my_solution.canSortArray(*[[21, 17]]) == False

assert my_solution.canSortArray(*[[24, 12]]) == True

assert my_solution.canSortArray(*[[26, 10]]) == False

assert my_solution.canSortArray(*[[128, 128]]) == True

assert my_solution.canSortArray(*[[1, 2, 3]]) == True

assert my_solution.canSortArray(*[[1, 256, 64]]) == True

assert my_solution.canSortArray(*[[2, 28, 9]]) == False

assert my_solution.canSortArray(*[[6, 6, 192]]) == True


#include <cstdlib>
class Solution {
public:
    int findKOr(vector<int> nums, int k) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的整数数组 `nums` 和一个整数 `k` 。

`nums` 中的 **K-or** 是一个满足以下条件的非负整数：

* 只有在 `nums` 中，至少存在 `k` 个元素的第 `i` 位值为 1 ，那么 K-or 中的第 `i` 位的值才是 1 。

返回 `nums` 的 **K-or** 值。

**注意** ：对于整数 `x` ，如果 `(2i AND x) == 2i` ，则 `x` 中的第 `i` 位值为 1 ，其中 `AND` 为按位与运算符。

**示例 1：**

```

**输入：**nums = [7,12,9,8,9,15], k = 4
**输出：**9
**解释：**nums[0]、nums[2]、nums[4] 和 nums[5] 的第 0 位的值为 1 。
nums[0] 和 nums[5] 的第 1 位的值为 1 。
nums[0]、nums[1] 和 nums[5] 的第 2 位的值为 1 。
nums[1]、nums[2]、nums[3]、nums[4] 和 nums[5] 的第 3 位的值为 1 。
只有第 0 位和第 3 位满足数组中至少存在 k 个元素在对应位上的值为 1 。因此，答案为 2^0 + 2^3 = 9 。

```

**示例 2：**

```

**输入：**nums = [2,12,1,11,4,5], k = 6
**输出：**0
**解释：**因为 k == 6 == nums.length ，所以数组的 6-or 等于其中所有元素按位与运算的结果。因此，答案为 2 AND 12 AND 1 AND 11 AND 4 AND 5 = 0 。

```

**示例 3：**

```

**输入：**nums = [10,8,5,9,11,6,8], k = 1
**输出：**15
**解释：**因为 k == 1 ，数组的 1-or 等于其中所有元素按位或运算的结果。因此，答案为 10 OR 8 OR 5 OR 9 OR 11 OR 6 OR 8 = 15 。
```

**提示：**

* `1 <= nums.length <= 50`
* `0 <= nums[i] < 231`
* `1 <= k <= nums.length`

请完成以下实现
```cpp
class Solution {
public:
    int findKOr(vector<int> nums, int k);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<int>(my_solution.findKOr({7, 12, 9, 8, 9, 15},4), 9));

assert (areEqual<int>(my_solution.findKOr({2, 12, 1, 11, 4, 5},6), 0));

assert (areEqual<int>(my_solution.findKOr({10, 8, 5, 9, 11, 6, 8},1), 15));

assert (areEqual<int>(my_solution.findKOr({14, 7, 12, 9, 8, 9, 1, 15},4), 13));

assert (areEqual<int>(my_solution.findKOr({2, 12, 1, 11, 4, 5},3), 5));

assert (areEqual<int>(my_solution.findKOr({10, 8, 5, 10, 11, 11, 6, 8},1), 15));

assert (areEqual<int>(my_solution.findKOr({0},1), 0));

assert (areEqual<int>(my_solution.findKOr({1},1), 1));

assert (areEqual<int>(my_solution.findKOr({2},1), 2));

assert (areEqual<int>(my_solution.findKOr({3},1), 3));

assert (areEqual<int>(my_solution.findKOr({4},1), 4));

assert (areEqual<int>(my_solution.findKOr({5},1), 5));

assert (areEqual<int>(my_solution.findKOr({6},1), 6));

assert (areEqual<int>(my_solution.findKOr({7},1), 7));

assert (areEqual<int>(my_solution.findKOr({8},1), 8));

assert (areEqual<int>(my_solution.findKOr({9},1), 9));

assert (areEqual<int>(my_solution.findKOr({10},1), 10));

assert (areEqual<int>(my_solution.findKOr({11},1), 11));

assert (areEqual<int>(my_solution.findKOr({12},1), 12));

assert (areEqual<int>(my_solution.findKOr({13},1), 13));

}


#include <cstdlib>
class Solution {
public:
    long long maxBalancedSubsequenceSum(vector<int> nums) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的整数数组 `nums` 。

`nums` 一个长度为 `k` 的 **子序列** 指的是选出 `k` 个 **下标** `i0 < i1 < ... < ik-1` ，如果这个子序列满足以下条件，我们说它是 **平衡的** ：

* 对于范围 `[1, k - 1]` 内的所有 `j` ，`nums[ij] - nums[ij-1] >= ij - ij-1` 都成立。

`nums` 长度为 `1` 的 **子序列** 是平衡的。

请你返回一个整数，表示 `nums` **平衡** 子序列里面的 **最大元素和** 。

一个数组的 **子序列** 指的是从原数组中删除一些元素（**也可能一个元素也不删除**）后，剩余元素保持相对顺序得到的 **非空** 新数组。

**示例 1：**

```

**输入：**nums = [3,3,5,6]
**输出：**14
**解释：**这个例子中，选择子序列 [3,5,6] ，下标为 0 ，2 和 3 的元素被选中。
nums[2] - nums[0] >= 2 - 0 。
nums[3] - nums[2] >= 3 - 2 。
所以，这是一个平衡子序列，且它的和是所有平衡子序列里最大的。
包含下标 1 ，2 和 3 的子序列也是一个平衡的子序列。
最大平衡子序列和为 14 。
```

**示例 2：**

```

**输入：**nums = [5,-1,-3,8]
**输出：**13
**解释：**这个例子中，选择子序列 [5,8] ，下标为 0 和 3 的元素被选中。
nums[3] - nums[0] >= 3 - 0 。
所以，这是一个平衡子序列，且它的和是所有平衡子序列里最大的。
最大平衡子序列和为 13 。

```

**示例 3：**

```

**输入：**nums = [-2,-1]
**输出：**-1
**解释：**这个例子中，选择子序列 [-1] 。
这是一个平衡子序列，而且它的和是 nums 所有平衡子序列里最大的。

```

**提示：**

* `1 <= nums.length <= 105`
* `-109 <= nums[i] <= 109`

请完成以下实现
```cpp
class Solution {
public:
    long long maxBalancedSubsequenceSum(vector<int> nums);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({3, 3, 5, 6}), 14));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({5, -1, -3, 8}), 13));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-2, -1}), -1));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({0}), 0));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-47}), -47));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-8}), -8));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-7}), -7));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-6}), -6));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-5}), -5));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-3}), -3));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-2}), -2));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({-1}), -1));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({1}), 1));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({3}), 3));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({4}), 4));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({5}), 5));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({7}), 7));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({8}), 8));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({9}), 9));

assert (areEqual<long long>(my_solution.maxBalancedSubsequenceSum({45}), 45));

}


class Solution(object):
    def incremovableSubarrayCount(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的 **正** 整数数组 `nums` 。

如果 `nums` 的一个子数组满足：移除这个子数组后剩余元素 **严格递增** ，那么我们称这个子数组为 **移除递增** 子数组。比方说，`[5, 3, 4, 6, 7]` 中的 `[3, 4]` 是一个移除递增子数组，因为移除该子数组后，`[5, 3, 4, 6, 7]` 变为 `[5, 6, 7]` ，是严格递增的。

请你返回 `nums` 中 **移除递增** 子数组的总数目。

**注意** ，剩余元素为空的数组也视为是递增的。

**子数组** 指的是一个数组中一段连续的元素序列。

**示例 1：**

```

**输入：**nums = [1,2,3,4]
**输出：**10
**解释：**10 个移除递增子数组分别为：[1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4] 和 [1,2,3,4]。移除任意一个子数组后，剩余元素都是递增的。注意，空数组不是移除递增子数组。

```

**示例 2：**

```

**输入：**nums = [6,5,7,8]
**输出：**7
**解释：**7个移除递增子数组分别为：[5], [6], [5,7], [6,5], [5,7,8], [6,5,7] 和 [6,5,7,8] 。
nums 中只有这 7 个移除递增子数组。

```

**示例 3：**

```

**输入：**nums = [8,7,6,6]
**输出：**3
**解释：**3 个移除递增子数组分别为：[8,7,6], [7,6,6] 和 [8,7,6,6] 。注意 [8,7] 不是移除递增子数组因为移除 [8,7] 后 nums 变为 [6,6] ，它不是严格递增的。

```

**提示：**

* `1 <= nums.length <= 50`
* `1 <= nums[i] <= 50`

请完成以下实现
```python
class Solution(object):
    def incremovableSubarrayCount(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.incremovableSubarrayCount(*[[1, 2, 3, 4]]) == 10

assert my_solution.incremovableSubarrayCount(*[[6, 5, 7, 8]]) == 7

assert my_solution.incremovableSubarrayCount(*[[8, 7, 6, 6]]) == 3

assert my_solution.incremovableSubarrayCount(*[[1]]) == 1

assert my_solution.incremovableSubarrayCount(*[[2]]) == 1

assert my_solution.incremovableSubarrayCount(*[[3]]) == 1

assert my_solution.incremovableSubarrayCount(*[[4]]) == 1

assert my_solution.incremovableSubarrayCount(*[[5]]) == 1

assert my_solution.incremovableSubarrayCount(*[[6]]) == 1

assert my_solution.incremovableSubarrayCount(*[[7]]) == 1

assert my_solution.incremovableSubarrayCount(*[[8]]) == 1

assert my_solution.incremovableSubarrayCount(*[[9]]) == 1

assert my_solution.incremovableSubarrayCount(*[[10]]) == 1

assert my_solution.incremovableSubarrayCount(*[[1, 2]]) == 3

assert my_solution.incremovableSubarrayCount(*[[1, 4]]) == 3

assert my_solution.incremovableSubarrayCount(*[[1, 8]]) == 3

assert my_solution.incremovableSubarrayCount(*[[2, 10]]) == 3

assert my_solution.incremovableSubarrayCount(*[[3, 4]]) == 3

assert my_solution.incremovableSubarrayCount(*[[3, 8]]) == 3

assert my_solution.incremovableSubarrayCount(*[[3, 10]]) == 3


#include <cstdlib>
class Solution {
public:
    int maximumStrongPairXor(vector<int> nums) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的整数数组 `nums` 。如果一对整数 `x` 和 `y` 满足以下条件，则称其为 **强数对** ：

* `|x - y| <= min(x, y)`

你需要从 `nums` 中选出两个整数，且满足：这两个整数可以形成一个强数对，并且它们的按位异或（`XOR`）值是在该数组所有强数对中的 **最大值** 。

返回数组 `nums` 所有可能的强数对中的 **最大** 异或值。

**注意**，你可以选择同一个整数两次来形成一个强数对。

**示例 1：**

```

**输入：**nums = [1,2,3,4,5]
**输出：**7
**解释：**数组 nums 中有 11 个强数对：(1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) 和 (5, 5) 。
这些强数对中的最大异或值是 3 XOR 4 = 7 。

```

**示例 2：**

```

**输入：**nums = [10,100]
**输出：**0
**解释：**数组 nums 中有 2 个强数对：(10, 10) 和 (100, 100) 。
这些强数对中的最大异或值是 10 XOR 10 = 0 ，数对 (100, 100) 的异或值也是 100 XOR 100 = 0 。

```

**示例 3：**

```

**输入：**nums = [500,520,2500,3000]
**输出：**1020
**解释：**数组 nums 中有 6 个强数对：(500, 500), (500, 520), (520, 520), (2500, 2500), (2500, 3000) 和 (3000, 3000) 。
这些强数对中的最大异或值是 500 XOR 520 = 1020 ；另一个异或值非零的数对是 (5, 6) ，其异或值是 2500 XOR 3000 = 636 。

```

**提示：**

* `1 <= nums.length <= 5 * 104`
* `1 <= nums[i] <= 220 - 1`

请完成以下实现
```cpp
class Solution {
public:
    int maximumStrongPairXor(vector<int> nums);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 3, 4, 5}), 7));

assert (areEqual<int>(my_solution.maximumStrongPairXor({10, 100}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({500, 520, 2500, 3000}), 1020));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({2, 3}), 1));

assert (areEqual<int>(my_solution.maximumStrongPairXor({3, 4}), 7));

assert (areEqual<int>(my_solution.maximumStrongPairXor({4, 5}), 1));

assert (areEqual<int>(my_solution.maximumStrongPairXor({5, 6}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 1, 1}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 1, 2}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 1, 3}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 1, 4}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 1, 5}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 1}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 2}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 3}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 4}), 6));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 2, 5}), 3));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 3, 1}), 0));

assert (areEqual<int>(my_solution.maximumStrongPairXor({1, 3, 2}), 3));

}


class Solution(object):
    def minOperations(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 和一个正整数 `k` 。

你可以对数组执行以下操作 **任意次** ：

* 选择数组里的 **任意** 一个元素，并将它的 **二进制** 表示 **翻转** 一个数位，翻转数位表示将 `0` 变成 `1` 或者将 `1` 变成 `0` 。

你的目标是让数组里 **所有** 元素的按位异或和得到 `k` ，请你返回达成这一目标的 **最少**操作次数。

**注意**，你也可以将一个数的前导 0 翻转。比方说，数字 `(101)2` 翻转第四个数位，得到 `(1101)2` 。

**示例 1：**

```

**输入：**nums = [2,1,3,4], k = 1
**输出：**2
**解释：**我们可以执行以下操作：
- 选择下标为 2 的元素，也就是 3 == (011)2 ，我们翻转第一个数位得到 (010)2 == 2 。数组变为 [2,1,2,4] 。
- 选择下标为 0 的元素，也就是 2 == (010)2 ，我们翻转第三个数位得到 (110)2 == 6 。数组变为 [6,1,2,4] 。
最终数组的所有元素异或和为 (6 XOR 1 XOR 2 XOR 4) == 1 == k 。
无法用少于 2 次操作得到异或和等于 k 。

```

**示例 2：**

```

**输入：**nums = [2,0,2,0], k = 0
**输出：**0
**解释：**数组所有元素的异或和为 (2 XOR 0 XOR 2 XOR 0) == 0 == k 。所以不需要进行任何操作。

```

**提示：**

* `1 <= nums.length <= 105`
* `0 <= nums[i] <= 106`
* `0 <= k <= 106`

请完成以下实现
```python
class Solution(object):
    def minOperations(self, nums, k):
        '''
        :type nums: List[int]
        :type k: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minOperations(*[[2, 1, 3, 4], 1]) == 2

assert my_solution.minOperations(*[[2, 0, 2, 0], 0]) == 0

assert my_solution.minOperations(*[[4], 7]) == 2

assert my_solution.minOperations(*[[3, 13, 9, 8, 5, 18, 11, 10], 13]) == 2

assert my_solution.minOperations(*[[9, 7, 9, 14, 8, 6], 12]) == 3

assert my_solution.minOperations(*[[13, 9, 10, 16, 11, 8, 1], 17]) == 3

assert my_solution.minOperations(*[[12, 14], 1]) == 2

assert my_solution.minOperations(*[[18, 18], 20]) == 2

assert my_solution.minOperations(*[[3, 5, 1, 1], 19]) == 3

assert my_solution.minOperations(*[[7, 0, 0, 0], 8]) == 4

assert my_solution.minOperations(*[[13, 15, 19, 18, 2, 9, 18, 11, 0, 7], 6]) == 1

assert my_solution.minOperations(*[[9, 15, 19, 15, 10, 15, 14, 0, 2, 5], 20]) == 1

assert my_solution.minOperations(*[[19, 4, 19, 6, 3, 19, 14, 4, 16, 12], 4]) == 0

assert my_solution.minOperations(*[[2, 10, 5, 5, 12, 3, 14, 6, 11, 14], 3]) == 2

assert my_solution.minOperations(*[[11, 20], 10]) == 3

assert my_solution.minOperations(*[[10, 12, 5, 3, 16, 0], 1]) == 2

assert my_solution.minOperations(*[[0, 4, 4, 7, 14, 13], 1]) == 2

assert my_solution.minOperations(*[[16, 2, 20, 13, 15, 20, 13], 16]) == 3

assert my_solution.minOperations(*[[19, 11, 11, 0, 16, 2, 2, 0, 9], 4]) == 3

assert my_solution.minOperations(*[[10, 17, 19, 8, 15], 19]) == 3


class Solution(object):
    def findIntersectionValues(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        exit(0)

给你两个下标从 **0** 开始的整数数组 `nums1` 和 `nums2` ，它们分别含有 `n` 和 `m` 个元素。

请你计算以下两个数值：

* 统计 `0 <= i < n` 中的下标 `i` ，满足 `nums1[i]` 在 `nums2` 中 **至少** 出现了一次。
* 统计 `0 <= i < m` 中的下标 `i` ，满足 `nums2[i]` 在 `nums1` 中 **至少** 出现了一次。

请你返回一个长度为 `2` 的整数数组`answer` ，**按顺序** 分别为以上两个数值。

**示例 1：**

```

**输入：**nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
**输出：**[3,4]
**解释：**分别计算两个数值：
- nums1 中下标为 1 ，2 和 3 的元素在 nums2 中至少出现了一次，所以第一个值为 3 。
- nums2 中下标为 0 ，1 ，3 和 4 的元素在 nums1 中至少出现了一次，所以第二个值为 4 。

```

**示例 2：**

```

**输入：**nums1 = [3,4,2,3], nums2 = [1,5]
**输出：**[0,0]
**解释：**两个数组中没有公共元素，所以两个值都为 0 。

```

**提示：**

* `n == nums1.length`
* `m == nums2.length`
* `1 <= n, m <= 100`
* `1 <= nums1[i], nums2[i] <= 100`

请完成以下实现
```python
class Solution(object):
    def findIntersectionValues(self, nums1, nums2):
        '''
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        '''
```


class Solution(object):
    def maxSubarrayLength(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        exit(0)

给你一个整数数组 `nums` 和一个整数 `k` 。

一个元素 `x` 在数组中的 **频率** 指的是它在数组中的出现次数。

如果一个数组中所有元素的频率都 **小于等于**`k` ，那么我们称这个数组是 **好** 数组。

请你返回 `nums` 中 **最长好** 子数组的长度。

**子数组** 指的是一个数组中一段连续非空的元素序列。

**示例 1：**

```

**输入：**nums = [1,2,3,1,2,3,1,2], k = 2
**输出：**6
**解释：**最长好子数组是 [1,2,3,1,2,3] ，值 1 ，2 和 3 在子数组中的频率都没有超过 k = 2 。[2,3,1,2,3,1] 和 [3,1,2,3,1,2] 也是好子数组。
最长好子数组的长度为 6 。

```

**示例 2：**

```

**输入：**nums = [1,2,1,2,1,2,1,2], k = 1
**输出：**2
**解释：**最长好子数组是 [1,2] ，值 1 和 2 在子数组中的频率都没有超过 k = 1 。[2,1] 也是好子数组。
最长好子数组的长度为 2 。

```

**示例 3：**

```

**输入：**nums = [5,5,5,5,5,5,5], k = 4
**输出：**4
**解释：**最长好子数组是 [5,5,5,5] ，值 5 在子数组中的频率没有超过 k = 4 。
最长好子数组的长度为 4 。

```

**提示：**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 109`
* `1 <= k <= nums.length`

请完成以下实现
```python
class Solution(object):
    def maxSubarrayLength(self, nums, k):
        '''
        :type nums: List[int]
        :type k: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.maxSubarrayLength(*[[1, 2, 3, 1, 2, 3, 1, 2], 2]) == 6

assert my_solution.maxSubarrayLength(*[[1, 2, 1, 2, 1, 2, 1, 2], 1]) == 2

assert my_solution.maxSubarrayLength(*[[5, 5, 5, 5, 5, 5, 5], 4]) == 4

assert my_solution.maxSubarrayLength(*[[1], 1]) == 1

assert my_solution.maxSubarrayLength(*[[2], 1]) == 1

assert my_solution.maxSubarrayLength(*[[3], 1]) == 1

assert my_solution.maxSubarrayLength(*[[4], 1]) == 1

assert my_solution.maxSubarrayLength(*[[5], 1]) == 1

assert my_solution.maxSubarrayLength(*[[6], 1]) == 1

assert my_solution.maxSubarrayLength(*[[7], 1]) == 1

assert my_solution.maxSubarrayLength(*[[8], 1]) == 1

assert my_solution.maxSubarrayLength(*[[9], 1]) == 1

assert my_solution.maxSubarrayLength(*[[10], 1]) == 1

assert my_solution.maxSubarrayLength(*[[1, 11], 2]) == 2

assert my_solution.maxSubarrayLength(*[[2, 11], 1]) == 2

assert my_solution.maxSubarrayLength(*[[3, 5], 2]) == 2

assert my_solution.maxSubarrayLength(*[[4, 6], 2]) == 2

assert my_solution.maxSubarrayLength(*[[5, 8], 2]) == 2

assert my_solution.maxSubarrayLength(*[[6, 7], 1]) == 2

assert my_solution.maxSubarrayLength(*[[7, 9], 2]) == 2


#include <cstdlib>
class Solution {
public:
    int maxSum(vector<int> nums, int k) {
        exit(0);
    }
};

给你一个下标从 **0** 开始的整数数组 `nums` 和一个 **正** 整数 `k` 。

你可以对数组执行以下操作 **任意次** ：

* 选择两个互不相同的下标 `i` 和 `j` ，**同时** 将 `nums[i]` 更新为 `(nums[i] AND nums[j])` 且将 `nums[j]` 更新为 `(nums[i] OR nums[j])` ，`OR` 表示按位 **或** 运算，`AND` 表示按位 **与** 运算。

你需要从最终的数组里选择 `k` 个元素，并计算它们的 **平方** 之和。

请你返回你可以得到的 **最大** 平方和。

由于答案可能会很大，将答案对 `109 + 7` **取余** 后返回。

**示例 1：**

```

**输入：**nums = [2,6,5,8], k = 2
**输出：**261
**解释：**我们可以对数组执行以下操作：
- 选择 i = 0 和 j = 3 ，同时将 nums[0] 变为 (2 AND 8) = 0 且 nums[3] 变为 (2 OR 8) = 10 ，结果数组为 nums = [0,6,5,10] 。
- 选择 i = 2 和 j = 3 ，同时将 nums[2] 变为 (5 AND 10) = 0 且 nums[3] 变为 (5 OR 10) = 15 ，结果数组为 nums = [0,6,0,15] 。
从最终数组里选择元素 15 和 6 ，平方和为 152 + 62 = 261 。
261 是可以得到的最大结果。

```

**示例 2：**

```

**输入：**nums = [4,5,4,7], k = 3
**输出：**90
**解释：**不需要执行任何操作。
选择元素 7 ，5 和 4 ，平方和为 72 + 52 + 42 = 90 。
90 是可以得到的最大结果。

```

**提示：**

* `1 <= k <= nums.length <= 105`
* `1 <= nums[i] <= 109`

请完成以下实现
```cpp
class Solution {
public:
    int maxSum(vector<int> nums, int k);
};
```


class Solution(object):
    def numberGame(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        exit(0)

你有一个下标从 **0** 开始、长度为 **偶数** 的整数数组 `nums` ，同时还有一个空数组 `arr` 。Alice 和 Bob 决定玩一个游戏，游戏中每一轮 Alice 和 Bob 都会各自执行一次操作。游戏规则如下：

* 每一轮，Alice 先从 `nums` 中移除一个 **最小** 元素，然后 Bob 执行同样的操作。
* 接着，Bob 会将移除的元素添加到数组 `arr` 中，然后 Alice 也执行同样的操作。
* 游戏持续进行，直到 `nums` 变为空。

返回结果数组 `arr` 。

**示例 1：**

```

**输入：**nums = [5,4,2,3]
**输出：**[3,2,5,4]
**解释：**第一轮，Alice 先移除 2 ，然后 Bob 移除 3 。然后 Bob 先将 3 添加到 arr 中，接着 Alice 再将 2 添加到 arr 中。于是 arr = [3,2] 。
第二轮开始时，nums = [5,4] 。Alice 先移除 4 ，然后 Bob 移除 5 。接着他们都将元素添加到 arr 中，arr 变为 [3,2,5,4] 。

```

**示例 2：**

```

**输入：**nums = [2,5]
**输出：**[5,2]
**解释：**第一轮，Alice 先移除 2 ，然后 Bob 移除 5 。然后 Bob 先将 5 添加到 arr 中，接着 Alice 再将 2 添加到 arr 中。于是 arr = [5,2] 。

```

**提示：**

* `1 <= nums.length <= 100`
* `1 <= nums[i] <= 100`
* `nums.length % 2 == 0`

请完成以下实现
```python
class Solution(object):
    def numberGame(self, nums):
        '''
        :type nums: List[int]
        :rtype: List[int]
        '''
```


class Solution(object):
    def hasTrailingZeros(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        exit(0)

给你一个 **正整数** 数组 `nums` 。

你需要检查是否可以从数组中选出 **两个或更多** 元素，满足这些元素的按位或运算（ `OR`）结果的二进制表示中 **至少**存在一个尾随零。

例如，数字 `5` 的二进制表示是 `"101"`，不存在尾随零，而数字 `4` 的二进制表示是 `"100"`，存在两个尾随零。

如果可以选择两个或更多元素，其按位或运算结果存在尾随零，返回 `true`；否则，返回`false` 。

**示例 1：**

```

**输入：**nums = [1,2,3,4,5]
**输出：**true
**解释：**如果选择元素 2 和 4，按位或运算结果是 6，二进制表示为 "110" ，存在一个尾随零。

```

**示例 2：**

```

**输入：**nums = [2,4,8,16]
**输出：**true
**解释：**如果选择元素 2 和 4，按位或运算结果是 6，二进制表示为 "110"，存在一个尾随零。
其他按位或运算结果存在尾随零的可能选择方案包括：(2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), 以及 (2, 4, 8, 16) 。

```

**示例 3：**

```

**输入：**nums = [1,3,5,7,9]
**输出：**false
**解释：**不存在按位或运算结果存在尾随零的选择方案。

```

**提示：**

* `2 <= nums.length <= 100`
* `1 <= nums[i] <= 100`

请完成以下实现
```python
class Solution(object):
    def hasTrailingZeros(self, nums):
        '''
        :type nums: List[int]
        :rtype: bool
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.hasTrailingZeros(*[[1, 2, 3, 4, 5]]) == True

assert my_solution.hasTrailingZeros(*[[2, 4, 8, 16]]) == True

assert my_solution.hasTrailingZeros(*[[1, 3, 5, 7, 9]]) == False

assert my_solution.hasTrailingZeros(*[[1, 2]]) == False

assert my_solution.hasTrailingZeros(*[[1, 3]]) == False

assert my_solution.hasTrailingZeros(*[[1, 7]]) == False

assert my_solution.hasTrailingZeros(*[[2, 2]]) == True

assert my_solution.hasTrailingZeros(*[[3, 3]]) == False

assert my_solution.hasTrailingZeros(*[[3, 4]]) == False

assert my_solution.hasTrailingZeros(*[[3, 9]]) == False

assert my_solution.hasTrailingZeros(*[[4, 3]]) == False

assert my_solution.hasTrailingZeros(*[[4, 8]]) == True

assert my_solution.hasTrailingZeros(*[[4, 32]]) == True

assert my_solution.hasTrailingZeros(*[[5, 6]]) == False

assert my_solution.hasTrailingZeros(*[[6, 2]]) == True

assert my_solution.hasTrailingZeros(*[[6, 8]]) == True

assert my_solution.hasTrailingZeros(*[[7, 9]]) == False

assert my_solution.hasTrailingZeros(*[[7, 10]]) == False

assert my_solution.hasTrailingZeros(*[[8, 2]]) == True

assert my_solution.hasTrailingZeros(*[[8, 4]]) == True


class Solution(object):
    def minimumCost(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个长度为 `n` 的整数数组 `nums` 。

一个数组的 **代价** 是它的 **第一个** 元素。比方说，`[1,2,3]` 的代价是 `1` ，`[3,4,1]` 的代价是 `3` 。

你需要将 `nums` 分成 `3` 个 **连续且没有交集** 的子数组。

请你返回这些子数组的 **最小** 代价 **总和** 。

**示例 1：**

```

**输入：**nums = [1,2,3,12]
**输出：**6
**解释：**最佳分割成 3 个子数组的方案是：[1] ，[2] 和 [3,12] ，总代价为 1 + 2 + 3 = 6 。
其他得到 3 个子数组的方案是：
- [1] ，[2,3] 和 [12] ，总代价是 1 + 2 + 12 = 15 。
- [1,2] ，[3] 和 [12] ，总代价是 1 + 3 + 12 = 16 。

```

**示例 2：**

```

**输入：**nums = [5,4,3]
**输出：**12
**解释：**最佳分割成 3 个子数组的方案是：[5] ，[4] 和 [3] ，总代价为 5 + 4 + 3 = 12 。
12 是所有分割方案里的最小总代价。

```

**示例 3：**

```

**输入：**nums = [10,3,1,1]
**输出：**12
**解释：**最佳分割成 3 个子数组的方案是：[10,3] ，[1] 和 [1] ，总代价为 10 + 1 + 1 = 12 。
12 是所有分割方案里的最小总代价。

```

**提示：**

* `3 <= n <= 50`
* `1 <= nums[i] <= 50`

请完成以下实现
```python
class Solution(object):
    def minimumCost(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minimumCost(*[[1, 2, 3, 12]]) == 6

assert my_solution.minimumCost(*[[5, 4, 3]]) == 12

assert my_solution.minimumCost(*[[10, 3, 1, 1]]) == 12

assert my_solution.minimumCost(*[[1, 1, 1]]) == 3

assert my_solution.minimumCost(*[[1, 1, 2]]) == 4

assert my_solution.minimumCost(*[[1, 1, 3]]) == 5

assert my_solution.minimumCost(*[[1, 1, 4]]) == 6

assert my_solution.minimumCost(*[[1, 1, 5]]) == 7

assert my_solution.minimumCost(*[[1, 2, 1]]) == 4

assert my_solution.minimumCost(*[[1, 2, 2]]) == 5

assert my_solution.minimumCost(*[[1, 2, 3]]) == 6

assert my_solution.minimumCost(*[[1, 2, 4]]) == 7

assert my_solution.minimumCost(*[[1, 2, 5]]) == 8

assert my_solution.minimumCost(*[[1, 3, 1]]) == 5

assert my_solution.minimumCost(*[[1, 3, 2]]) == 6

assert my_solution.minimumCost(*[[1, 3, 3]]) == 7

assert my_solution.minimumCost(*[[1, 3, 4]]) == 8

assert my_solution.minimumCost(*[[1, 3, 5]]) == 9

assert my_solution.minimumCost(*[[1, 4, 1]]) == 6

assert my_solution.minimumCost(*[[1, 4, 2]]) == 7


class Solution(object):
    def removeAlmostEqualCharacters(self, word):
        """
        :type word: str
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的字符串 `word` 。

一次操作中，你可以选择 `word` 中任意一个下标 `i` ，将 `word[i]` 修改成任意一个小写英文字母。

请你返回消除 `word` 中所有相邻 **近似相等** 字符的 **最少** 操作次数。

两个字符 `a` 和 `b` 如果满足 `a == b` 或者 `a` 和 `b` 在字母表中是相邻的，那么我们称它们是 **近似相等** 字符。

**示例 1：**

```

**输入：**word = "aaaaa"
**输出：**2
**解释：**我们将 word 变为 "a***c***a***c***a" ，该字符串没有相邻近似相等字符。
消除 word 中所有相邻近似相等字符最少需要 2 次操作。

```

**示例 2：**

```

**输入：**word = "abddez"
**输出：**2
**解释：**我们将 word 变为 "***y***bd***o***ez" ，该字符串没有相邻近似相等字符。
消除 word 中所有相邻近似相等字符最少需要 2 次操作。
```

**示例 3：**

```

**输入：**word = "zyxyxyz"
**输出：**3
**解释：**我们将 word 变为 "z***a***x***a***x***a***z" ，该字符串没有相邻近似相等字符。
消除 word 中所有相邻近似相等字符最少需要 3 次操作

```

**提示：**

* `1 <= word.length <= 100`
* `word` 只包含小写英文字母。

请完成以下实现
```python
class Solution(object):
    def removeAlmostEqualCharacters(self, word):
        '''
        :type word: str
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.removeAlmostEqualCharacters(*['aaaaa']) == 2

assert my_solution.removeAlmostEqualCharacters(*['abddez']) == 2

assert my_solution.removeAlmostEqualCharacters(*['zyxyxyz']) == 3

assert my_solution.removeAlmostEqualCharacters(*['a']) == 0

assert my_solution.removeAlmostEqualCharacters(*['b']) == 0

assert my_solution.removeAlmostEqualCharacters(*['c']) == 0

assert my_solution.removeAlmostEqualCharacters(*['aa']) == 1

assert my_solution.removeAlmostEqualCharacters(*['ab']) == 1

assert my_solution.removeAlmostEqualCharacters(*['ac']) == 0

assert my_solution.removeAlmostEqualCharacters(*['ba']) == 1

assert my_solution.removeAlmostEqualCharacters(*['bb']) == 1

assert my_solution.removeAlmostEqualCharacters(*['bc']) == 1

assert my_solution.removeAlmostEqualCharacters(*['ca']) == 0

assert my_solution.removeAlmostEqualCharacters(*['cb']) == 1

assert my_solution.removeAlmostEqualCharacters(*['cc']) == 1

assert my_solution.removeAlmostEqualCharacters(*['aaa']) == 1

assert my_solution.removeAlmostEqualCharacters(*['aab']) == 1

assert my_solution.removeAlmostEqualCharacters(*['aac']) == 1

assert my_solution.removeAlmostEqualCharacters(*['aba']) == 1

assert my_solution.removeAlmostEqualCharacters(*['abb']) == 1


#include <cstdlib>
class Solution {
public:
    int differenceOfSums(int n, int m) {
        exit(0);
    }
};

给你两个正整数 `n` 和 `m` 。

现定义两个整数 `num1` 和 `num2` ，如下所示：

* `num1`：范围 `[1, n]` 内所有 **无法被** `m` **整除** 的整数之和。
* `num2`：范围 `[1, n]` 内所有 **能够被** `m` **整除** 的整数之和。

返回整数 `num1 - num2` 。

**示例 1：**

```

**输入：**n = 10, m = 3
**输出：**19
**解释：**在这个示例中：
- 范围 [1, 10] 内无法被 3 整除的整数为 [1,2,4,5,7,8,10] ，num1 = 这些整数之和 = 37 。
- 范围 [1, 10] 内能够被 3 整除的整数为 [3,6,9] ，num2 = 这些整数之和 = 18 。
返回 37 - 18 = 19 作为答案。

```

**示例 2：**

```

**输入：**n = 5, m = 6
**输出：**15
**解释：**在这个示例中：
- 范围 [1, 5] 内无法被 6 整除的整数为 [1,2,3,4,5] ，num1 = 这些整数之和 =  15 。
- 范围 [1, 5] 内能够被 6 整除的整数为 [] ，num2 = 这些整数之和 = 0 。
返回 15 - 0 = 15 作为答案。

```

**示例 3：**

```

**输入：**n = 5, m = 1
**输出：**-15
**解释：**在这个示例中：
- 范围 [1, 5] 内无法被 1 整除的整数为 [] ，num1 = 这些整数之和 = 0 。
- 范围 [1, 5] 内能够被 1 整除的整数为 [1,2,3,4,5] ，num2 = 这些整数之和 = 15 。
返回 0 - 15 = -15 作为答案。

```

**提示：**

* `1 <= n, m <= 1000`

请完成以下实现
```cpp
class Solution {
public:
    int differenceOfSums(int n, int m);
};
```

#include <vector>
#include <string>
using namespace std;

#<INSERT>

#include<assert.h>

template<typename T>
bool areEqual(const T a, const T b) {
    return a == b;
}

template<typename T>
bool areEqual(const std::vector<T> a, const std::vector<T> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); i++) {
        if(!areEqual(a[i], b[i])) return false;
    }
    return true;
}

Solution my_solution;
int main(){

assert (areEqual<int>(my_solution.differenceOfSums(10,3), 19));

assert (areEqual<int>(my_solution.differenceOfSums(5,6), 15));

assert (areEqual<int>(my_solution.differenceOfSums(5,1), -15));

assert (areEqual<int>(my_solution.differenceOfSums(15,9), 102));

assert (areEqual<int>(my_solution.differenceOfSums(8,10), 36));

assert (areEqual<int>(my_solution.differenceOfSums(23,36), 276));

assert (areEqual<int>(my_solution.differenceOfSums(1,32), 1));

assert (areEqual<int>(my_solution.differenceOfSums(36,7), 456));

assert (areEqual<int>(my_solution.differenceOfSums(3,8), 6));

assert (areEqual<int>(my_solution.differenceOfSums(4,2), -2));

assert (areEqual<int>(my_solution.differenceOfSums(9,7), 31));

assert (areEqual<int>(my_solution.differenceOfSums(20,9), 156));

assert (areEqual<int>(my_solution.differenceOfSums(3,19), 6));

assert (areEqual<int>(my_solution.differenceOfSums(6,16), 21));

assert (areEqual<int>(my_solution.differenceOfSums(6,1), -21));

assert (areEqual<int>(my_solution.differenceOfSums(5,25), 15));

assert (areEqual<int>(my_solution.differenceOfSums(9,3), 9));

assert (areEqual<int>(my_solution.differenceOfSums(8,23), 36));

assert (areEqual<int>(my_solution.differenceOfSums(17,1), -153));

assert (areEqual<int>(my_solution.differenceOfSums(18,9), 117));

}