* @lc app=leetcode.cn id=1095 lang=golang
*
* [1095] 山脉数组中查找目标值
*
* https://leetcode.cn/problems/find-in-mountain-array/description/
*
* algorithms
* Hard (37.66%)
* Likes: 163
* Dislikes: 0
* Total Accepted: 25.6K
* Total Submissions: 67.9K
* Testcase Example: '[1,2,3,4,5,3,1]\n3'
*
* (这是一个 交互式问题 )
*
* 给你一个 山脉数组 mountainArr,请你返回能够使得 mountainArr.get(index) 等于 target 最小 的下标 index
* 值。
*
* 如果不存在这样的下标 index,就请返回 -1。
*
*
*
* 何为山脉数组?如果数组 A 是一个山脉数组的话,那它满足如下条件:
*
* 首先,A.length >= 3
*
* 其次,在 0 < i < A.length - 1 条件下,存在 i 使得:
*
*
* A[0] < A[1] < ..
* @lc app=leetcode.cn id=1268 lang=golang
*
* [1268] 搜索推荐系统
*
* https://leetcode.cn/problems/search-suggestions-system/description/
*
* algorithms
* Medium (59.98%)
* Likes: 165
* Dislikes: 0
* Total Accepted: 19K
* Total Submissions: 31.7K
* Testcase Example: '["mobile","mouse","moneypot","monitor","mousepad"]\n"mouse"'
*
* 给你一个产品数组 products 和一个字符串 searchWord ,products 数组中每个产品都是一个字符串。
*
* 请你设计一个推荐系统,在依次输入单词 searchWord 的每一个字母后,推荐 products 数组中前缀与 searchWord
* 相同的最多三个产品。如果前缀相同的可推荐产品超过三个,请按字典序返回最小的三个。
*
* 请你以二维列表的形式,返回在输入 searchWord 每个字母后相应的推荐产品的列表。
*
*
*
* 示例 1:
*
* 输入:products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord
* = "mouse"
* 输出:[
* ["mobile","moneypot","monitor"],
* ["mobile","moneypot","monitor"],
* ["mouse","mousepad"],
* ["mouse","mousepad"],
* ["mouse","mousepad"]
* ]
* 解释:按字典序排序后的产品列表是 ["mobile","moneypot","monitor","mouse","mousepad"]
* 输入 m 和 mo,由于所有产品的前缀都相同,所以系统返回字典序最小的三个产品 ["mobile","moneypot","monitor"]
* 输入 mou, mous 和 mouse 后系统都返回 ["mouse","mousepad"]
*
*
* 示例 2:
*
* 输入:products = ["havana"], searchWord = "havana"
* 输出:[["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]
*
*
* 示例 3:
*
* 输入:products = ["bags","baggage","banner","box","cloths"], searchWord =
* "bags"
*
* 输出:[["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]
*
*
* 示例 4:
*
* 输入:products = ["havana"], searchWord = "tatiana"
* 输出:[[],[],[],[],[],[],[]]
*
*
*
*
* 提示:
*
*
* 1 <= products.length <= 1000
* 1 <= Σ products[i].length <= 2 * 10^4
* products[i] 中所有的字符都是小写英文字母。
* 1 <= searchWord.length <= 1000
* searchWord 中所有字符都是小写英文字母。
*
*
*/.
* @lc app=leetcode.cn id=1283 lang=golang
*
* [1283] 使结果不超过阈值的最小除数
*
* https://leetcode.cn/problems/find-the-smallest-divisor-given-a-threshold/description/
*
* algorithms
* Medium (47.64%)
* Likes: 83
* Dislikes: 0
* Total Accepted: 12.7K
* Total Submissions: 26.7K
* Testcase Example: '[1,2,5,9]\n6'
*
* 给你一个整数数组 nums 和一个正整数 threshold ,你需要选择一个正整数作为除数,然后将数组里每个数都除以它,并对除法结果求和。
*
* 请你找出能够使上述结果小于等于阈值 threshold 的除数中 最小 的那个。
*
* 每个数除以除数后都向上取整,比方说 7/3 = 3 , 10/2 = 5 。
*
* 题目保证一定有解。
*
*
*
* 示例 1:
*
*
* 输入:nums = [1,2,5,9], threshold = 6
* 输出:5
* 解释:如果除数为 1 ,我们可以得到和为 17 (1+2+5+9)。
* 如果除数为 4 ,我们可以得到和为 7 (1+1+2+3) 。如果除数为 5 ,和为 5 (1+1+1+2)。
*
*
* 示例 2:
*
*
* 输入:nums = [2,3,5,7,11], threshold = 11
* 输出:3
*
*
* 示例 3:
*
*
* 输入:nums = [19], threshold = 5
* 输出:4
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 5 * 10^4
* 1 <= nums[i] <= 10^6
* nums.length <= threshold <= 10^6
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=1300 lang=golang
*
* [1300] 转变数组后最接近目标值的数组和
*
* https://leetcode.cn/problems/sum-of-mutated-array-closest-to-target/description/
*
* algorithms
* Medium (46.57%)
* Likes: 186
* Dislikes: 0
* Total Accepted: 29.5K
* Total Submissions: 63.2K
* Testcase Example: '[4,9,3]\n10'
*
* 给你一个整数数组 arr 和一个目标值 target ,请你返回一个整数 value ,使得将数组中所有大于 value 的值变成 value
* 后,数组的和最接近 target (最接近表示两者之差的绝对值最小)。
*
* 如果有多种使得和最接近 target 的方案,请你返回这些整数中的最小值。
*
* 请注意,答案不一定是 arr 中的数字。
*
*
*
* 示例 1:
*
* 输入:arr = [4,9,3], target = 10
* 输出:3
* 解释:当选择 value 为 3 时,数组会变成 [3, 3, 3],和为 9 ,这是最接近 target 的方案。
*
*
* 示例 2:
*
* 输入:arr = [2,3,5], target = 10
* 输出:5
*
*
* 示例 3:
*
* 输入:arr = [60864,25176,27249,21296,20204], target = 56803
* 输出:11361
*
*
*
*
* 提示:
*
*
* 1 <= arr.length <= 10^4
* 1 <= arr[i], target <= 10^5
*
*
*/.
* @lc app=leetcode.cn id=1337 lang=golang
*
* [1337] 矩阵中战斗力最弱的 K 行
*
* https://leetcode.cn/problems/the-k-weakest-rows-in-a-matrix/description/
*
* algorithms
* Easy (68.95%)
* Likes: 195
* Dislikes: 0
* Total Accepted: 54.7K
* Total Submissions: 79.4K
* Testcase Example: '[[1,1,0,0,0],[1,1,1,1,0],[1,0,0,0,0],[1,1,0,0,0],[1,1,1,1,1]]\n3'
*
* 给你一个大小为 m * n 的矩阵 mat,矩阵由若干军人和平民组成,分别用 1 和 0 表示。
*
* 请你返回矩阵中战斗力最弱的 k 行的索引,按从最弱到最强排序。
*
* 如果第 i 行的军人数量少于第 j 行,或者两行军人数量相同但 i 小于 j,那么我们认为第 i 行的战斗力比第 j 行弱。
*
* 军人 总是 排在一行中的靠前位置,也就是说 1 总是出现在 0 之前。
*
*
*
* 示例 1:
*
*
* 输入:mat =
* [[1,1,0,0,0],
* [1,1,1,1,0],
* [1,0,0,0,0],
* [1,1,0,0,0],
* [1,1,1,1,1]],
* k = 3
* 输出:[2,0,3]
* 解释:
* 每行中的军人数目:
* 行 0 -> 2
* 行 1 -> 4
* 行 2 -> 1
* 行 3 -> 2
* 行 4 -> 5
* 从最弱到最强对这些行排序后得到 [2,0,3,1,4]
*
*
* 示例 2:
*
*
* 输入:mat =
* [[1,0,0,0],
* [1,1,1,1],
* [1,0,0,0],
* [1,0,0,0]],
* k = 2
* 输出:[0,2]
* 解释:
* 每行中的军人数目:
* 行 0 -> 1
* 行 1 -> 4
* 行 2 -> 1
* 行 3 -> 1
* 从最弱到最强对这些行排序后得到 [0,2,3,1]
*
*
*
*
* 提示:
*
*
* m == mat.length
* n == mat[i].length
* 2
* 1
* matrix[i][j] 不是 0 就是 1
*
*
*/.
* @lc app=leetcode.cn id=1346 lang=golang
*
* [1346] 检查整数及其两倍数是否存在
*
* https://leetcode.cn/problems/check-if-n-and-its-double-exist/description/
*
* algorithms
* Easy (42.45%)
* Likes: 83
* Dislikes: 0
* Total Accepted: 32K
* Total Submissions: 75.5K
* Testcase Example: '[10,2,5,3]'
*
* 给你一个整数数组 arr,请你检查是否存在两个整数 N 和 M,满足 N 是 M 的两倍(即,N = 2 * M)。
*
* 更正式地,检查是否存在两个下标 i 和 j 满足:
*
*
* i != j
* 0 <= i, j < arr.length
* arr[i] == 2 * arr[j]
*
*
*
*
* 示例 1:
*
* 输入:arr = [10,2,5,3]
* 输出:true
* 解释:N = 10 是 M = 5 的两倍,即 10 = 2 * 5 。
*
*
* 示例 2:
*
* 输入:arr = [7,1,14,11]
* 输出:true
* 解释:N = 14 是 M = 7 的两倍,即 14 = 2 * 7 。
*
*
* 示例 3:
*
* 输入:arr = [3,1,7,11]
* 输出:false
* 解释:在该情况下不存在 N 和 M 满足 N = 2 * M 。
*
*
*
*
* 提示:
*
*
* 2 <= arr.length <= 500
* -10^3 <= arr[i] <= 10^3
*
*
*/.
* @lc app=leetcode.cn id=1351 lang=golang
*
* [1351] 统计有序矩阵中的负数
*
* https://leetcode.cn/problems/count-negative-numbers-in-a-sorted-matrix/description/
*
* algorithms
* Easy (74.61%)
* Likes: 128
* Dislikes: 0
* Total Accepted: 46.8K
* Total Submissions: 62.7K
* Testcase Example: '[[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]'
*
* 给你一个 m * n 的矩阵 grid,矩阵中的元素无论是按行还是按列,都以非递增顺序排列。 请你统计并返回 grid 中 负数 的数目。
*
*
*
* 示例 1:
*
*
* 输入:grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
* 输出:8
* 解释:矩阵中共有 8 个负数。
*
*
* 示例 2:
*
*
* 输入:grid = [[3,2],[1,0]]
* 输出:0
*
*
*
*
* 提示:
*
*
* m == grid.length
* n == grid[i].length
* 1 <= m, n <= 100
* -100 <= grid[i][j] <= 100
*
*
*
*
* 进阶:你可以设计一个时间复杂度为 O(n + m) 的解决方案吗?
*
*/.
* @lc app=leetcode.cn id=1385 lang=golang
*
* [1385] 两个数组间的距离值
*
* https://leetcode.cn/problems/find-the-distance-value-between-two-arrays/description/
*
* algorithms
* Easy (64.34%)
* Likes: 92
* Dislikes: 0
* Total Accepted: 35.9K
* Total Submissions: 55.8K
* Testcase Example: '[4,5,8]\n[10,9,1,8]\n2'
*
* 给你两个整数数组 arr1 , arr2 和一个整数 d ,请你返回两个数组之间的 距离值 。
*
* 「距离值」 定义为符合此距离要求的元素数目:对于元素 arr1[i] ,不存在任何元素 arr2[j] 满足 |arr1[i]-arr2[j]| <=
* d 。
*
*
*
* 示例 1:
*
* 输入:arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
* 输出:2
* 解释:
* 对于 arr1[0]=4 我们有:
* |4-10|=6 > d=2
* |4-9|=5 > d=2
* |4-1|=3 > d=2
* |4-8|=4 > d=2
* 所以 arr1[0]=4 符合距离要求
*
* 对于 arr1[1]=5 我们有:
* |5-10|=5 > d=2
* |5-9|=4 > d=2
* |5-1|=4 > d=2
* |5-8|=3 > d=2
* 所以 arr1[1]=5 也符合距离要求
*
* 对于 arr1[2]=8 我们有:
* |8-10|=2 <= d=2
* |8-9|=1 <= d=2
* |8-1|=7 > d=2
* |8-8|=0 <= d=2
* 存在距离小于等于 2 的情况,不符合距离要求
*
* 故而只有 arr1[0]=4 和 arr1[1]=5 两个符合距离要求,距离值为 2
*
* 示例 2:
*
* 输入:arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
* 输出:2
*
*
* 示例 3:
*
* 输入:arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
* 输出:1
*
*
*
*
* 提示:
*
*
* 1 <= arr1.length, arr2.length <= 500
* -10^3 <= arr1[i], arr2[j] <= 10^3
* 0 <= d <= 100
*
*
*/.
* @lc app=leetcode.cn id=1482 lang=golang
*
* [1482] 制作 m 束花所需的最少天数
*
* https://leetcode.cn/problems/minimum-number-of-days-to-make-m-bouquets/description/
*
* algorithms
* Medium (58.00%)
* Likes: 276
* Dislikes: 0
* Total Accepted: 39.1K
* Total Submissions: 67.5K
* Testcase Example: '[1,10,3,10,2]\n3\n1'
*
* 给你一个整数数组 bloomDay,以及两个整数 m 和 k 。
*
* 现需要制作 m 束花。制作花束时,需要使用花园中 相邻的 k 朵花 。
*
* 花园中有 n 朵花,第 i 朵花会在 bloomDay[i] 时盛开,恰好 可以用于 一束 花中。
*
* 请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。
*
*
*
* 示例 1:
*
* 输入:bloomDay = [1,10,3,10,2], m = 3, k = 1
* 输出:3
* 解释:让我们一起观察这三天的花开过程,x 表示花开,而 _ 表示花还未开。
* 现在需要制作 3 束花,每束只需要 1 朵。
* 1 天后:[x, _, _, _, _] // 只能制作 1 束花
* 2 天后:[x, _, _, _, x] // 只能制作 2 束花
* 3 天后:[x, _, x, _, x] // 可以制作 3 束花,答案为 3
*
*
* 示例 2:
*
* 输入:bloomDay = [1,10,3,10,2], m = 3, k = 2
* 输出:-1
* 解释:要制作 3 束花,每束需要 2 朵花,也就是一共需要 6 朵花。而花园中只有 5 朵花,无法满足制作要求,返回 -1 。
*
*
* 示例 3:
*
* 输入:bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
* 输出:12
* 解释:要制作 2 束花,每束需要 3 朵。
* 花园在 7 天后和 12 天后的情况如下:
* 7 天后:[x, x, x, x, _, x, x]
* 可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花,因为它们不相邻。
* 12 天后:[x, x, x, x, x, x, x]
* 显然,我们可以用不同的方式制作两束花。
*
*
* 示例 4:
*
* 输入:bloomDay = [1000000000,1000000000], m = 1, k = 1
* 输出:1000000000
* 解释:需要等 1000000000 天才能采到花来制作花束
*
*
* 示例 5:
*
* 输入:bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
* 输出:9
*
*
*
*
* 提示:
*
*
* bloomDay.length == n
* 1 <= n <= 10^5
* 1 <= bloomDay[i] <= 10^9
* 1 <= m <= 10^6
* 1 <= k <= n
*
*
*/.
* @lc app=leetcode.cn id=1498 lang=golang
*
* [1498] 满足条件的子序列数目
*
* https://leetcode.cn/problems/number-of-subsequences-that-satisfy-the-given-sum-condition/description/
*
* algorithms
* Medium (37.40%)
* Likes: 110
* Dislikes: 0
* Total Accepted: 9K
* Total Submissions: 24.1K
* Testcase Example: '[3,5,6,7]\n9'
*
* 给你一个整数数组 nums 和一个整数 target 。
*
* 请你统计并返回 nums 中能满足其最小元素与最大元素的 和 小于或等于 target 的 非空 子序列的数目。
*
* 由于答案可能很大,请将结果对 10^9 + 7 取余后返回。
*
*
*
* 示例 1:
*
*
* 输入:nums = [3,5,6,7], target = 9
* 输出:4
* 解释:有 4 个子序列满足该条件。
* [3] -> 最小元素 + 最大元素 <= target (3 + 3 <= 9)
* [3,5] -> (3 + 5 <= 9)
* [3,5,6] -> (3 + 6 <= 9)
* [3,6] -> (3 + 6 <= 9)
*
*
* 示例 2:
*
*
* 输入:nums = [3,3,6,8], target = 10
* 输出:6
* 解释:有 6 个子序列满足该条件。(nums 中可以有重复数字)
* [3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]
*
* 示例 3:
*
*
* 输入:nums = [2,3,3,4,6,7], target = 12
* 输出:61
* 解释:共有 63 个非空子序列,其中 2 个不满足条件([6,7], [7])
* 有效序列总数为(63 - 2 = 61)
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 10^5
* 1 <= nums[i] <= 10^6
* 1 <= target <= 10^6
*
*
*/.
* @lc app=leetcode.cn id=153 lang=golang
*
* [153] 寻找旋转排序数组中的最小值
*
* https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/description/
*
* algorithms
* Medium (56.98%)
* Likes: 867
* Dislikes: 0
* Total Accepted: 339.6K
* Total Submissions: 596K
* Testcase Example: '[3,4,5,1,2]'
*
* 已知一个长度为 n 的数组,预先按照升序排列,经由 1 到 n 次 旋转 后,得到输入数组。例如,原数组 nums = [0,1,2,4,5,6,7]
* 在变化后可能得到:
*
* 若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]
* 若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]
*
*
* 注意,数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2],
* ..., a[n-2]] 。
*
* 给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
*
* 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
*
*
*
* 示例 1:
*
*
* 输入:nums = [3,4,5,1,2]
* 输出:1
* 解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。
*
*
* 示例 2:
*
*
* 输入:nums = [4,5,6,7,0,1,2]
* 输出:0
* 解释:原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。
*
*
* 示例 3:
*
*
* 输入:nums = [11,13,15,17]
* 输出:11
* 解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。
*
*
*
*
* 提示:
*
*
* n == nums.length
* 1 <= n <= 5000
* -5000 <= nums[i] <= 5000
* nums 中的所有整数 互不相同
* nums 原来是一个升序排序的数组,并进行了 1 至 n 次旋转
*
*
*/.
* @lc app=leetcode.cn id=1539 lang=golang
*
* [1539] 第 k 个缺失的正整数
*
* https://leetcode.cn/problems/kth-missing-positive-number/description/
*
* algorithms
* Easy (54.04%)
* Likes: 166
* Dislikes: 0
* Total Accepted: 36.8K
* Total Submissions: 68.1K
* Testcase Example: '[2,3,4,7,11]\n5'
*
* 给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。
*
* 请你找到这个数组里第 k 个缺失的正整数。
*
*
*
* 示例 1:
*
*
* 输入:arr = [2,3,4,7,11], k = 5
* 输出:9
* 解释:缺失的正整数包括 [1,5,6,8,9,10,12,13,...] 。第 5 个缺失的正整数为 9 。
*
*
* 示例 2:
*
*
* 输入:arr = [1,2,3,4], k = 2
* 输出:6
* 解释:缺失的正整数包括 [5,6,7,...] 。第 2 个缺失的正整数为 6 。
*
*
*
*
* 提示:
*
*
* 1 <= arr.length <= 1000
* 1 <= arr[i] <= 1000
* 1 <= k <= 1000
* 对于所有 1 <= i < j <= arr.length 的 i 和 j 满足 arr[i] < arr[j]
*
*
*
*
* 进阶:
*
* 你可以设计一个时间复杂度小于 O(n) 的算法解决此问题吗?
*
*/.
* @lc app=leetcode.cn id=1608 lang=golang
*
* [1608] 特殊数组的特征值
*
* https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x/description/
*
* algorithms
* Easy (61.65%)
* Likes: 184
* Dislikes: 0
* Total Accepted: 51.5K
* Total Submissions: 83.5K
* Testcase Example: '[3,5]'
*
* 给你一个非负整数数组 nums 。如果存在一个数 x ,使得 nums 中恰好有 x 个元素 大于或者等于 x ,那么就称 nums 是一个 特殊数组
* ,而 x 是该数组的 特征值 。
*
* 注意: x 不必 是 nums 的中的元素。
*
* 如果数组 nums 是一个 特殊数组 ,请返回它的特征值 x 。否则,返回 -1 。可以证明的是,如果 nums 是特殊数组,那么其特征值 x 是
* 唯一的 。
*
*
*
* 示例 1:
*
* 输入:nums = [3,5]
* 输出:2
* 解释:有 2 个元素(3 和 5)大于或等于 2 。
*
*
* 示例 2:
*
* 输入:nums = [0,0]
* 输出:-1
* 解释:没有满足题目要求的特殊数组,故而也不存在特征值 x 。
* 如果 x = 0,应该有 0 个元素 >= x,但实际有 2 个。
* 如果 x = 1,应该有 1 个元素 >= x,但实际有 0 个。
* 如果 x = 2,应该有 2 个元素 >= x,但实际有 0 个。
* x 不能取更大的值,因为 nums 中只有两个元素。
*
* 示例 3:
*
* 输入:nums = [0,4,3,0,4]
* 输出:3
* 解释:有 3 个元素大于或等于 3 。
*
*
* 示例 4:
*
* 输入:nums = [3,6,7,7,0]
* 输出:-1
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 100
* 0 <= nums[i] <= 1000
*
*
*/.
* @lc app=leetcode.cn id=162 lang=golang
*
* [162] 寻找峰值
*
* https://leetcode.cn/problems/find-peak-element/description/
*
* algorithms
* Medium (49.46%)
* Likes: 934
* Dislikes: 0
* Total Accepted: 274.4K
* Total Submissions: 554.9K
* Testcase Example: '[1,2,3,1]'
*
* 峰值元素是指其值严格大于左右相邻值的元素。
*
* 给你一个整数数组 nums,找到峰值元素并返回其索引。
* 数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。
*
* 你可以假设 nums[-1] = nums[n] = -∞ 。
*
* 你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
*
*
*
* 示例 1:
*
*
* 输入:nums = [1,2,3,1]
* 输出:2
* 解释:3 是峰值元素,你的函数应该返回其索引 2。
*
* 示例 2:
*
*
* 输入:nums = [1,2,1,3,5,6,4]
* 输出:1 或 5
* 解释:你的函数可以返回索引 1,其峰值元素为 2;
* 或者返回索引 5, 其峰值元素为 6。
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 1000
* -2^31 <= nums[i] <= 2^31 - 1
* 对于所有有效的 i 都有 nums[i] != nums[i + 1]
*
*
*/.
* @lc app=leetcode.cn id=167 lang=golang
*
* [167] 两数之和 II - 输入有序数组
*
* https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/description/
*
* algorithms
* Medium (59.20%)
* Likes: 954
* Dislikes: 0
* Total Accepted: 519.4K
* Total Submissions: 877.3K
* Testcase Example: '[2,7,11,15]\n9'
*
* 给你一个下标从 1 开始的整数数组 numbers ,该数组已按 非递减顺序排列 ,请你从数组中找出满足相加之和等于目标数 target
* 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ,则 1 <= index1 < index2 <=
* numbers.length 。
*
* 以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
*
* 你可以假设每个输入 只对应唯一的答案 ,而且你 不可以 重复使用相同的元素。
*
* 你所设计的解决方案必须只使用常量级的额外空间。
*
*
* 示例 1:
*
*
* 输入:numbers = [2,7,11,15], target = 9
* 输出:[1,2]
* 解释:2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
*
* 示例 2:
*
*
* 输入:numbers = [2,3,4], target = 6
* 输出:[1,3]
* 解释:2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
*
* 示例 3:
*
*
* 输入:numbers = [-1,0], target = -1
* 输出:[1,2]
* 解释:-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
*
*
*
*
* 提示:
*
*
* 2 <= numbers.length <= 3 * 10^4
* -1000 <= numbers[i] <= 1000
* numbers 按 非递减顺序 排列
* -1000 <= target <= 1000
* 仅存在一个有效答案
*
*
*/.
* @lc app=leetcode.cn id=1802 lang=golang
*
* [1802] 有界数组中指定下标处的最大值
*
* https://leetcode.cn/problems/maximum-value-at-a-given-index-in-a-bounded-array/description/
*
* algorithms
* Medium (29.20%)
* Likes: 78
* Dislikes: 0
* Total Accepted: 10.6K
* Total Submissions: 31.5K
* Testcase Example: '4\n2\n6'
*
* 给你三个正整数 n、index 和 maxSum 。你需要构造一个同时满足下述所有条件的数组 nums(下标 从 0 开始 计数):
*
*
* nums.length == n
* nums[i] 是 正整数 ,其中 0 <= i < n
* abs(nums[i] - nums[i+1]) <= 1 ,其中 0 <= i < n-1
* nums 中所有元素之和不超过 maxSum
* nums[index] 的值被 最大化
*
*
* 返回你所构造的数组中的 nums[index] 。
*
* 注意:abs(x) 等于 x 的前提是 x >= 0 ;否则,abs(x) 等于 -x 。
*
*
*
* 示例 1:
*
* 输入:n = 4, index = 2, maxSum = 6
* 输出:2
* 解释:数组 [1,1,2,1] 和 [1,2,2,1] 满足所有条件。不存在其他在指定下标处具有更大值的有效数组。
*
*
* 示例 2:
*
* 输入:n = 6, index = 1, maxSum = 10
* 输出:3
*
*
*
*
* 提示:
*
*
* 1 <= n <= maxSum <= 10^9
* 0 <= index < n
*
*
*/.
* @lc app=leetcode.cn id=1818 lang=golang
*
* [1818] 绝对差值和
*
* https://leetcode.cn/problems/minimum-absolute-sum-difference/description/
*
* algorithms
* Medium (37.51%)
* Likes: 145
* Dislikes: 0
* Total Accepted: 30.4K
* Total Submissions: 81K
* Testcase Example: '[1,7,5]\n[2,3,5]'
*
* 给你两个正整数数组 nums1 和 nums2 ,数组的长度都是 n 。
*
* 数组 nums1 和 nums2 的 绝对差值和 定义为所有 |nums1[i] - nums2[i]|(0 )的 总和(下标从 0 开始)。
*
* 你可以选用 nums1 中的 任意一个 元素来替换 nums1 中的 至多 一个元素,以 最小化 绝对差值和。
*
* 在替换数组 nums1 中最多一个元素 之后 ,返回最小绝对差值和。因为答案可能很大,所以需要对 10^9 + 7 取余 后返回。
*
* |x| 定义为:
*
*
* 如果 x >= 0 ,值为 x ,或者
* 如果 x ,值为 -x
*
*
*
*
* 示例 1:
*
*
* 输入:nums1 = [1,7,5], nums2 = [2,3,5]
* 输出:3
* 解释:有两种可能的最优方案:
* - 将第二个元素替换为第一个元素:[1,7,5] => [1,1,5] ,或者
* - 将第二个元素替换为第三个元素:[1,7,5] => [1,5,5]
* 两种方案的绝对差值和都是 |1-2| + (|1-3| 或者 |5-3|) + |5-5| = 3
*
*
* 示例 2:
*
*
* 输入:nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]
* 输出:0
* 解释:nums1 和 nums2 相等,所以不用替换元素。绝对差值和为 0
*
*
* 示例 3:
*
*
* 输入:nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]
* 输出:20
* 解释:将第一个元素替换为第二个元素:[1,10,4,4,2,7] => [10,10,4,4,2,7]
* 绝对差值和为 |10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20
*
*
*
*
* 提示:
*
*
* n == nums1.length
* n == nums2.length
* 1
* 1
*
*
*/.
* @lc app=leetcode.cn id=1894 lang=golang
*
* [1894] 找到需要补充粉笔的学生编号
*
* https://leetcode.cn/problems/find-the-student-that-will-replace-the-chalk/description/
*
* algorithms
* Medium (45.85%)
* Likes: 98
* Dislikes: 0
* Total Accepted: 46.4K
* Total Submissions: 101.2K
* Testcase Example: '[5,1,5]\n22'
*
* 一个班级里有 n 个学生,编号为 0 到 n - 1 。每个学生会依次回答问题,编号为 0 的学生先回答,然后是编号为 1 的学生,以此类推,直到编号为
* n - 1 的学生,然后老师会重复这个过程,重新从编号为 0 的学生开始回答问题。
*
* 给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i
* 的学生回答问题时,他会消耗 chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ,那么学生 i 需要 补充 粉笔。
*
* 请你返回需要 补充 粉笔的学生 编号 。
*
*
*
* 示例 1:
*
* 输入:chalk = [5,1,5], k = 22
* 输出:0
* 解释:学生消耗粉笔情况如下:
* - 编号为 0 的学生使用 5 支粉笔,然后 k = 17 。
* - 编号为 1 的学生使用 1 支粉笔,然后 k = 16 。
* - 编号为 2 的学生使用 5 支粉笔,然后 k = 11 。
* - 编号为 0 的学生使用 5 支粉笔,然后 k = 6 。
* - 编号为 1 的学生使用 1 支粉笔,然后 k = 5 。
* - 编号为 2 的学生使用 5 支粉笔,然后 k = 0 。
* 编号为 0 的学生没有足够的粉笔,所以他需要补充粉笔。
*
* 示例 2:
*
* 输入:chalk = [3,4,1,2], k = 25
* 输出:1
* 解释:学生消耗粉笔情况如下:
* - 编号为 0 的学生使用 3 支粉笔,然后 k = 22 。
* - 编号为 1 的学生使用 4 支粉笔,然后 k = 18 。
* - 编号为 2 的学生使用 1 支粉笔,然后 k = 17 。
* - 编号为 3 的学生使用 2 支粉笔,然后 k = 15 。
* - 编号为 0 的学生使用 3 支粉笔,然后 k = 12 。
* - 编号为 1 的学生使用 4 支粉笔,然后 k = 8 。
* - 编号为 2 的学生使用 1 支粉笔,然后 k = 7 。
* - 编号为 3 的学生使用 2 支粉笔,然后 k = 5 。
* - 编号为 0 的学生使用 3 支粉笔,然后 k = 2 。
* 编号为 1 的学生没有足够的粉笔,所以他需要补充粉笔。
*
*
*
*
* 提示:
*
*
* chalk.length == n
* 1 <= n <= 10^5
* 1 <= chalk[i] <= 10^5
* 1 <= k <= 10^9
*
*
*/.
* @lc app=leetcode.cn id=209 lang=golang
*
* [209] 长度最小的子数组
*
* https://leetcode.cn/problems/minimum-size-subarray-sum/description/
*
* algorithms
* Medium (47.56%)
* Likes: 1489
* Dislikes: 0
* Total Accepted: 460.3K
* Total Submissions: 968.2K
* Testcase Example: '7\n[2,3,1,2,4,3]'
*
* 给定一个含有 n 个正整数的数组和一个正整数 target 。
*
* 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]
* ,并返回其长度。如果不存在符合条件的子数组,返回 0 。
*
*
*
* 示例 1:
*
*
* 输入:target = 7, nums = [2,3,1,2,4,3]
* 输出:2
* 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
*
*
* 示例 2:
*
*
* 输入:target = 4, nums = [1,4,4]
* 输出:1
*
*
* 示例 3:
*
*
* 输入:target = 11, nums = [1,1,1,1,1,1,1,1]
* 输出:0
*
*
*
*
* 提示:
*
*
* 1
* 1
* 1
*
*
*
*
* 进阶:
*
*
* 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
*
*
*/.
* @lc app=leetcode.cn id=2300 lang=golang
*
* [2300] 咒语和药水的成功对数
*
* https://leetcode.cn/problems/successful-pairs-of-spells-and-potions/description/
*
* algorithms
* Medium (44.59%)
* Likes: 89
* Dislikes: 0
* Total Accepted: 34.5K
* Total Submissions: 77.5K
* Testcase Example: '[5,1,3]\n[1,2,3,4,5]\n7'
*
* 给你两个正整数数组 spells 和 potions ,长度分别为 n 和 m ,其中 spells[i] 表示第 i
* 个咒语的能量强度,potions[j] 表示第 j 瓶药水的能量强度。
*
* 同时给你一个整数 success 。一个咒语和药水的能量强度 相乘 如果 大于等于 success ,那么它们视为一对 成功 的组合。
*
* 请你返回一个长度为 n 的整数数组 pairs,其中 pairs[i] 是能跟第 i 个咒语成功组合的 药水 数目。
*
*
*
* 示例 1:
*
* 输入:spells = [5,1,3], potions = [1,2,3,4,5], success = 7
* 输出:[4,0,3]
* 解释:
* - 第 0 个咒语:5 * [1,2,3,4,5] = [5,10,15,20,25] 。总共 4 个成功组合。
* - 第 1 个咒语:1 * [1,2,3,4,5] = [1,2,3,4,5] 。总共 0 个成功组合。
* - 第 2 个咒语:3 * [1,2,3,4,5] = [3,6,9,12,15] 。总共 3 个成功组合。
* 所以返回 [4,0,3] 。
*
*
* 示例 2:
*
* 输入:spells = [3,1,2], potions = [8,5,8], success = 16
* 输出:[2,0,2]
* 解释:
* - 第 0 个咒语:3 * [8,5,8] = [24,15,24] 。总共 2 个成功组合。
* - 第 1 个咒语:1 * [8,5,8] = [8,5,8] 。总共 0 个成功组合。
* - 第 2 个咒语:2 * [8,5,8] = [16,10,16] 。总共 2 个成功组合。
* 所以返回 [2,0,2] 。
*
*
*
*
* 提示:
*
*
* n == spells.length
* m == potions.length
* 1 <= n, m <= 10^5
* 1 <= spells[i], potions[i] <= 10^5
* 1 <= success <= 10^10
*
*
*/.
* @lc app=leetcode.cn id=240 lang=golang
*
* [240] 搜索二维矩阵 II
*
* https://leetcode.cn/problems/search-a-2d-matrix-ii/description/
*
- algorithms
- Medium (52.36%)
- Likes: 1184
- Dislikes: 0
- Total Accepted: 333.2K
- Total Submissions: 636.3K
- Testcase Example: '[[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]]\n' +
'5'
*
* 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性:
*
*
* 每行的元素从左到右升序排列。
* 每列的元素从上到下升序排列。
*
*
*
*
* 示例 1:
*
*
* 输入:matrix =
* [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]],
* target = 5
* 输出:true
*
*
* 示例 2:
*
*
* 输入:matrix =
* [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]],
* target = 20
* 输出:false
*
*
*
*
* 提示:
*
*
* m == matrix.length
* n == matrix[i].length
* 1 <= n, m <= 300
* -10^9 <= matrix[i][j] <= 10^9
* 每行的所有元素从左到右升序排列
* 每列的所有元素从上到下升序排列
* -10^9 <= target <= 10^9
*
*
*/.
* @lc app=leetcode.cn id=2517 lang=golang
*
* [2517] 礼盒的最大甜蜜度
*
* https://leetcode.cn/problems/maximum-tastiness-of-candy-basket/description/
*
* algorithms
* Medium (70.12%)
* Likes: 26
* Dislikes: 0
* Total Accepted: 3.8K
* Total Submissions: 5.4K
* Testcase Example: '[13,5,1,8,21,2]\n3'
*
* 给你一个正整数数组 price ,其中 price[i] 表示第 i 类糖果的价格,另给你一个正整数 k 。
*
* 商店组合 k 类 不同 糖果打包成礼盒出售。礼盒的 甜蜜度 是礼盒中任意两种糖果 价格 绝对差的最小值。
*
* 返回礼盒的 最大 甜蜜度。
*
*
*
* 示例 1:
*
*
* 输入:price = [13,5,1,8,21,2], k = 3
* 输出:8
* 解释:选出价格分别为 [13,5,21] 的三类糖果。
* 礼盒的甜蜜度为 min(|13 - 5|, |13 - 21|, |5 - 21|) = min(8, 8, 16) = 8 。
* 可以证明能够取得的最大甜蜜度就是 8 。
*
*
* 示例 2:
*
*
* 输入:price = [1,3,1], k = 2
* 输出:2
* 解释:选出价格分别为 [1,3] 的两类糖果。
* 礼盒的甜蜜度为 min(|1 - 3|) = min(2) = 2 。
* 可以证明能够取得的最大甜蜜度就是 2 。
*
*
* 示例 3:
*
*
* 输入:price = [7,7,7,7], k = 2
* 输出:0
* 解释:从现有的糖果中任选两类糖果,甜蜜度都会是 0 。
*
*
*
*
* 提示:
*
*
* 1 <= price.length <= 10^5
* 1 <= price[i] <= 10^9
* 2 <= k <= price.length
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=278 lang=golang
*
* [278] 第一个错误的版本
*
* https://leetcode.cn/problems/first-bad-version/description/
*
* algorithms
* Easy (45.65%)
* Likes: 838
* Dislikes: 0
* Total Accepted: 415.6K
* Total Submissions: 910.3K
* Testcase Example: '5\n4'
*
*
* 你是产品经理,目前正在带领一个团队开发新的产品。不幸的是,你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的,所以错误的版本之后的所有版本都是错的。
*
* 假设你有 n 个版本 [1, 2, ..., n],你想找出导致之后所有版本出错的第一个错误的版本。
*
* 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version
* 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
*
*
* 示例 1:
*
*
* 输入:n = 5, bad = 4
* 输出:4
* 解释:
* 调用 isBadVersion(3) -> false
* 调用 isBadVersion(5) -> true
* 调用 isBadVersion(4) -> true
* 所以,4 是第一个错误的版本。
*
*
* 示例 2:
*
*
* 输入:n = 1, bad = 1
* 输出:1
*
*
*
*
* 提示:
*
*
* 1
*
*
*/.
* @lc app=leetcode.cn id=287 lang=golang
*
* [287] 寻找重复数
*
* https://leetcode.cn/problems/find-the-duplicate-number/description/
*
* algorithms
* Medium (64.51%)
* Likes: 1985
* Dislikes: 0
* Total Accepted: 289.9K
* Total Submissions: 449.4K
* Testcase Example: '[1,3,4,2,2]'
*
* 给定一个包含 n + 1 个整数的数组 nums ,其数字都在 [1, n] 范围内(包括 1 和 n),可知至少存在一个重复的整数。
*
* 假设 nums 只有 一个重复的整数 ,返回 这个重复的数 。
*
* 你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。
*
*
*
* 示例 1:
*
*
* 输入:nums = [1,3,4,2,2]
* 输出:2
*
*
* 示例 2:
*
*
* 输入:nums = [3,1,3,4,2]
* 输出:3
*
*
*
*
* 提示:
*
*
* 1 <= n <= 10^5
* nums.length == n + 1
* 1 <= nums[i] <= n
* nums 中 只有一个整数 出现 两次或多次 ,其余整数均只出现 一次
*
*
*
*
* 进阶:
*
*
* 如何证明 nums 中至少存在一个重复的数字?
* 你可以设计一个线性级时间复杂度 O(n) 的解决方案吗?
*
*
*/.
* @lc app=leetcode.cn id=33 lang=golang
*
* [33] 搜索旋转排序数组
*
* https://leetcode.cn/problems/search-in-rotated-sorted-array/description/
*
* algorithms
* Medium (43.82%)
* Likes: 2415
* Dislikes: 0
* Total Accepted: 658.6K
* Total Submissions: 1.5M
* Testcase Example: '[4,5,6,7,0,1,2]\n0'
*
* 整数数组 nums 按升序排列,数组中的值 互不相同 。
*
* 在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转,使数组变为 [nums[k],
* nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始
* 计数)。例如, [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
*
* 给你 旋转后 的数组 nums 和一个整数 target ,如果 nums 中存在这个目标值 target ,则返回它的下标,否则返回 -1 。
*
* 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
*
*
*
* 示例 1:
*
*
* 输入:nums = [4,5,6,7,0,1,2], target = 0
* 输出:4
*
*
* 示例 2:
*
*
* 输入:nums = [4,5,6,7,0,1,2], target = 3
* 输出:-1
*
* 示例 3:
*
*
* 输入:nums = [1], target = 0
* 输出:-1
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 5000
* -10^4 <= nums[i] <= 10^4
* nums 中的每个值都 独一无二
* 题目数据保证 nums 在预先未知的某个下标上进行了旋转
* -10^4 <= target <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=34 lang=golang
*
* [34] 在排序数组中查找元素的第一个和最后一个位置
*
* https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/description/
*
* algorithms
* Medium (42.34%)
* Likes: 2025
* Dislikes: 0
* Total Accepted: 688.7K
* Total Submissions: 1.6M
* Testcase Example: '[5,7,7,8,8,10]\n8'
*
* 给你一个按照非递减顺序排列的整数数组 nums,和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
*
* 如果数组中不存在目标值 target,返回 [-1, -1]。
*
* 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
*
*
*
* 示例 1:
*
*
* 输入:nums = [5,7,7,8,8,10], target = 8
* 输出:[3,4]
*
* 示例 2:
*
*
* 输入:nums = [5,7,7,8,8,10], target = 6
* 输出:[-1,-1]
*
* 示例 3:
*
*
* 输入:nums = [], target = 0
* 输出:[-1,-1]
*
*
*
* 提示:
*
*
* 0 <= nums.length <= 10^5
* -10^9 <= nums[i] <= 10^9
* nums 是一个非递减数组
* -10^9 <= target <= 10^9
*
*
*/.
* @lc app=leetcode.cn id=35 lang=golang
*
* [35] 搜索插入位置
*
* https://leetcode.cn/problems/search-insert-position/description/
*
* algorithms
* Easy (45.05%)
* Likes: 1838
* Dislikes: 0
* Total Accepted: 1M
* Total Submissions: 2.3M
* Testcase Example: '[1,3,5,6]\n5'
*
* 给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
*
* 请必须使用时间复杂度为 O(log n) 的算法。
*
*
*
* 示例 1:
*
*
* 输入: nums = [1,3,5,6], target = 5
* 输出: 2
*
*
* 示例 2:
*
*
* 输入: nums = [1,3,5,6], target = 2
* 输出: 1
*
*
* 示例 3:
*
*
* 输入: nums = [1,3,5,6], target = 7
* 输出: 4
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 10^4
* -10^4 <= nums[i] <= 10^4
* nums 为 无重复元素 的 升序 排列数组
* -10^4 <= target <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=367 lang=golang
*
* [367] 有效的完全平方数
*
* https://leetcode.cn/problems/valid-perfect-square/description/
*
* algorithms
* Easy (44.85%)
* Likes: 462
* Dislikes: 0
* Total Accepted: 203K
* Total Submissions: 452.2K
* Testcase Example: '16'
*
* 给你一个正整数 num 。如果 num 是一个完全平方数,则返回 true ,否则返回 false 。
*
* 完全平方数 是一个可以写成某个整数的平方的整数。换句话说,它可以写成某个整数和自身的乘积。
*
* 不能使用任何内置的库函数,如 sqrt 。
*
*
*
* 示例 1:
*
*
* 输入:num = 16
* 输出:true
* 解释:返回 true ,因为 4 * 4 = 16 且 4 是一个整数。
*
*
* 示例 2:
*
*
* 输入:num = 14
* 输出:false
* 解释:返回 false ,因为 3.742 * 3.742 = 14 但 3.742 不是一个整数。
*
*
*
*
* 提示:
*
*
* 1 <= num <= 2^31 - 1
*
*
*/.
* @lc app=leetcode.cn id=374 lang=golang
*
* [374] 猜数字大小
*
* https://leetcode.cn/problems/guess-number-higher-or-lower/description/
*
* algorithms
* Easy (52.09%)
* Likes: 274
* Dislikes: 0
* Total Accepted: 146.4K
* Total Submissions: 280.7K
* Testcase Example: '10\n6'
*
* 猜数字游戏的规则如下:
*
*
* 每轮游戏,我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
* 如果你猜错了,我会告诉你,你猜测的数字比我选出的数字是大了还是小了。
*
*
* 你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果,返回值一共有 3 种可能的情况(-1,1 或
* 0):
*
*
* -1:我选出的数字比你猜的数字小 pick < num
* 1:我选出的数字比你猜的数字大 pick > num
* 0:我选出的数字和你猜的数字一样。恭喜!你猜对了!pick == num
*
*
* 返回我选出的数字。
*
*
*
* 示例 1:
*
*
* 输入:n = 10, pick = 6
* 输出:6
*
*
* 示例 2:
*
*
* 输入:n = 1, pick = 1
* 输出:1
*
*
* 示例 3:
*
*
* 输入:n = 2, pick = 1
* 输出:1
*
*
* 示例 4:
*
*
* 输入:n = 2, pick = 2
* 输出:2
*
*
*
*
* 提示:
*
*
* 1
* 1
*
*
*/.
* @lc app=leetcode.cn id=441 lang=golang
*
* [441] 排列硬币
*
* https://leetcode.cn/problems/arranging-coins/description/
*
* algorithms
* Easy (45.48%)
* Likes: 256
* Dislikes: 0
* Total Accepted: 112K
* Total Submissions: 246.3K
* Testcase Example: '5'
*
* 你总共有 n 枚硬币,并计划将它们按阶梯状排列。对于一个由 k 行组成的阶梯,其第 i 行必须正好有 i 枚硬币。阶梯的最后一行 可能 是不完整的。
*
* 给你一个数字 n ,计算并返回可形成 完整阶梯行 的总行数。
*
*
*
* 示例 1:
*
*
* 输入:n = 5
* 输出:2
* 解释:因为第三行不完整,所以返回 2 。
*
*
* 示例 2:
*
*
* 输入:n = 8
* 输出:3
* 解释:因为第四行不完整,所以返回 3 。
*
*
*
*
* 提示:
*
*
* 1 <= n <= 2^31 - 1
*
*
*/.
* @lc app=leetcode.cn id=528 lang=golang
*
* [528] 按权重随机选择
*
* https://leetcode.cn/problems/random-pick-with-weight/description/
*
* algorithms
* Medium (48.20%)
* Likes: 276
* Dislikes: 0
* Total Accepted: 51.7K
* Total Submissions: 107.3K
* Testcase Example: '["Solution","pickIndex"]\n[[[1]],[]]'
*
* 给你一个 下标从 0 开始 的正整数数组 w ,其中 w[i] 代表第 i 个下标的权重。
*
* 请你实现一个函数 pickIndex ,它可以 随机地 从范围 [0, w.length - 1] 内(含 0 和 w.length -
* 1)选出并返回一个下标。选取下标 i 的 概率 为 w[i] / sum(w) 。
*
*
*
*
*
* 例如,对于 w = [1, 3],挑选下标 0 的概率为 1 / (1 + 3) = 0.25 (即,25%),而选取下标 1 的概率为 3 / (1
* + 3) = 0.75(即,75%)。
*
*
*
*
* 示例 1:
*
*
* 输入:
* ["Solution","pickIndex"]
* [[[1]],[]]
* 输出:
* [null,0]
* 解释:
* Solution solution = new Solution([1]);
* solution.pickIndex(); // 返回 0,因为数组中只有一个元素,所以唯一的选择是返回下标 0。
*
* 示例 2:
*
*
* 输入:
* ["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
* [[[1,3]],[],[],[],[],[]]
* 输出:
* [null,1,1,1,1,0]
* 解释:
* Solution solution = new Solution([1, 3]);
* solution.pickIndex(); // 返回 1,返回下标 1,返回该下标概率为 3/4 。
* solution.pickIndex(); // 返回 1
* solution.pickIndex(); // 返回 1
* solution.pickIndex(); // 返回 1
* solution.pickIndex(); // 返回 0,返回下标 0,返回该下标概率为 1/4 。
*
* 由于这是一个随机问题,允许多个答案,因此下列输出都可以被认为是正确的:
* [null,1,1,1,1,0]
* [null,1,1,1,1,1]
* [null,1,1,1,0,0]
* [null,1,1,1,0,1]
* [null,1,0,1,0,0]
* .....
* @lc app=leetcode.cn id=540 lang=golang
*
* [540] 有序数组中的单一元素
*
* https://leetcode.cn/problems/single-element-in-a-sorted-array/description/
*
* algorithms
* Medium (60.60%)
* Likes: 565
* Dislikes: 0
* Total Accepted: 108.7K
* Total Submissions: 179.4K
* Testcase Example: '[1,1,2,3,3,4,4,8,8]'
*
* 给你一个仅由整数组成的有序数组,其中每个元素都会出现两次,唯有一个数只会出现一次。
*
* 请你找出并返回只出现一次的那个数。
*
* 你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。
*
*
*
* 示例 1:
*
*
* 输入: nums = [1,1,2,3,3,4,4,8,8]
* 输出: 2
*
*
* 示例 2:
*
*
* 输入: nums = [3,3,7,7,10,11,11]
* 输出: 10
*
*
*
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 10^5
* 0 <= nums[i] <= 10^5
*
*
*/.
* @lc app=leetcode.cn id=633 lang=golang
*
* [633] 平方数之和
*
* https://leetcode.cn/problems/sum-of-square-numbers/description/
*
* algorithms
* Medium (38.52%)
* Likes: 409
* Dislikes: 0
* Total Accepted: 125.5K
* Total Submissions: 325.9K
* Testcase Example: '5'
*
* 给定一个非负整数 c ,你要判断是否存在两个整数 a 和 b,使得 a^2 + b^2 = c 。
*
*
*
* 示例 1:
*
*
* 输入:c = 5
* 输出:true
* 解释:1 * 1 + 2 * 2 = 5
*
*
* 示例 2:
*
*
* 输入:c = 3
* 输出:false
*
*
*
*
* 提示:
*
*
* 0 <= c <= 2^31 - 1
*
*
*/.
* @lc app=leetcode.cn id=658 lang=golang
*
* [658] 找到 K 个最接近的元素
*
* https://leetcode.cn/problems/find-k-closest-elements/description/
*
* algorithms
* Medium (48.11%)
* Likes: 463
* Dislikes: 0
* Total Accepted: 83.1K
* Total Submissions: 172.7K
* Testcase Example: '[1,2,3,4,5]\n4\n3'
*
* 给定一个 排序好 的数组 arr ,两个整数 k 和 x ,从数组中找到最靠近 x(两数之差最小)的 k 个数。返回的结果必须要是按升序排好的。
*
* 整数 a 比整数 b 更接近 x 需要满足:
*
*
* |a - x| < |b - x| 或者
* |a - x| == |b - x| 且 a < b
*
*
*
*
* 示例 1:
*
*
* 输入:arr = [1,2,3,4,5], k = 4, x = 3
* 输出:[1,2,3,4]
*
*
* 示例 2:
*
*
* 输入:arr = [1,2,3,4,5], k = 4, x = -1
* 输出:[1,2,3,4]
*
*
*
*
* 提示:
*
*
* 1 <= k <= arr.length
* 1 <= arr.length <= 10^4
* arr 按 升序 排列
* -10^4 <= arr[i], x <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=69 lang=golang
*
* [69] x 的平方根
*
* https://leetcode.cn/problems/sqrtx/description/
*
* algorithms
* Easy (38.69%)
* Likes: 1219
* Dislikes: 0
* Total Accepted: 665.1K
* Total Submissions: 1.7M
* Testcase Example: '4'
*
* 给你一个非负整数 x ,计算并返回 x 的 算术平方根 。
*
* 由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。
*
* 注意:不允许使用任何内置指数函数和算符,例如 pow(x, 0.5) 或者 x ** 0.5 。
*
*
*
* 示例 1:
*
*
* 输入:x = 4
* 输出:2
*
*
* 示例 2:
*
*
* 输入:x = 8
* 输出:2
* 解释:8 的算术平方根是 2.82842..., 由于返回类型是整数,小数部分将被舍去。
*
*
*
*
* 提示:
*
*
* 0 <= x <= 2^31 - 1
*
*
*/.
* @lc app=leetcode.cn id=704 lang=golang
*
* [704] 二分查找
*
* https://leetcode.cn/problems/binary-search/description/
*
* algorithms
* Easy (54.55%)
* Likes: 1105
* Dislikes: 0
* Total Accepted: 843.1K
* Total Submissions: 1.5M
* Testcase Example: '[-1,0,3,5,9,12]\n9'
*
* 给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的
* target,如果目标值存在返回下标,否则返回 -1。
*
*
* 示例 1:
*
* 输入: nums = [-1,0,3,5,9,12], target = 9
* 输出: 4
* 解释: 9 出现在 nums 中并且下标为 4
*
*
* 示例 2:
*
* 输入: nums = [-1,0,3,5,9,12], target = 2
* 输出: -1
* 解释: 2 不存在 nums 中因此返回 -1
*
*
*
*
* 提示:
*
*
* 你可以假设 nums 中的所有元素是不重复的。
* n 将在 [1, 10000]之间。
* nums 的每个元素都将在 [-9999, 9999]之间。
*
*
*/.
* @lc app=leetcode.cn id=74 lang=golang
*
* [74] 搜索二维矩阵
*
* https://leetcode.cn/problems/search-a-2d-matrix/description/
*
* algorithms
* Medium (48.36%)
* Likes: 745
* Dislikes: 0
* Total Accepted: 284K
* Total Submissions: 587.2K
* Testcase Example: '[[1,3,5,7],[10,11,16,20],[23,30,34,60]]\n3'
*
* 编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值。该矩阵具有如下特性:
*
*
* 每行中的整数从左到右按升序排列。
* 每行的第一个整数大于前一行的最后一个整数。
*
*
*
*
* 示例 1:
*
*
* 输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
* 输出:true
*
*
* 示例 2:
*
*
* 输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
* 输出:false
*
*
*
*
* 提示:
*
*
* m == matrix.length
* n == matrix[i].length
* 1
* -10^4
*
*
*/.
* @lc app=leetcode.cn id=744 lang=golang
*
* [744] 寻找比目标字母大的最小字母
*
* https://leetcode.cn/problems/find-smallest-letter-greater-than-target/description/
*
* algorithms
* Easy (48.21%)
* Likes: 252
* Dislikes: 0
* Total Accepted: 104.8K
* Total Submissions: 217.2K
* Testcase Example: '["c","f","j"]\n"a"'
*
* 给你一个字符数组 letters,该数组按非递减顺序排序,以及一个字符 target。letters 里至少有两个不同的字符。
*
* 返回 letters 中大于 target 的最小的字符。如果不存在这样的字符,则返回 letters 的第一个字符。
*
*
*
* 示例 1:
*
*
* 输入: letters = ["c", "f", "j"],target = "a"
* 输出: "c"
* 解释:letters 中字典上比 'a' 大的最小字符是 'c'。
*
* 示例 2:
*
*
* 输入: letters = ["c","f","j"], target = "c"
* 输出: "f"
* 解释:letters 中字典顺序上大于 'c' 的最小字符是 'f'。
*
* 示例 3:
*
*
* 输入: letters = ["x","x","y","y"], target = "z"
* 输出: "x"
* 解释:letters 中没有一个字符在字典上大于 'z',所以我们返回 letters[0]。
*
*
*
* 提示:
*
*
* 2 <= letters.length <= 10^4
* letters[i] 是一个小写字母
* letters 按非递减顺序排序
* letters 最少包含两个不同的字母
* target 是一个小写字母
*
*
*/.
* @lc app=leetcode.cn id=852 lang=golang
*
* [852] 山脉数组的峰顶索引
*
* https://leetcode.cn/problems/peak-index-in-a-mountain-array/description/
*
* algorithms
* Medium (68.83%)
* Likes: 324
* Dislikes: 0
* Total Accepted: 130.6K
* Total Submissions: 189.7K
* Testcase Example: '[0,1,0]'
*
* 符合下列属性的数组 arr 称为 山脉数组 :
*
* arr.length >= 3
* 存在 i(0 < i < arr.length - 1)使得:
*
* arr[0] < arr[1] < ..
* @lc app=leetcode.cn id=875 lang=golang
*
* [875] 爱吃香蕉的珂珂
*
* https://leetcode.cn/problems/koko-eating-bananas/description/
*
* algorithms
* Medium (49.41%)
* Likes: 559
* Dislikes: 0
* Total Accepted: 141.1K
* Total Submissions: 285.6K
* Testcase Example: '[3,6,7,11]\n8'
*
* 珂珂喜欢吃香蕉。这里有 n 堆香蕉,第 i 堆中有 piles[i] 根香蕉。警卫已经离开了,将在 h 小时后回来。
*
* 珂珂可以决定她吃香蕉的速度 k (单位:根/小时)。每个小时,她将会选择一堆香蕉,从中吃掉 k 根。如果这堆香蕉少于 k
* 根,她将吃掉这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉。
*
* 珂珂喜欢慢慢吃,但仍然想在警卫回来前吃掉所有的香蕉。
*
* 返回她可以在 h 小时内吃掉所有香蕉的最小速度 k(k 为整数)。
*
*
*
*
*
*
* 示例 1:
*
*
* 输入:piles = [3,6,7,11], h = 8
* 输出:4
*
*
* 示例 2:
*
*
* 输入:piles = [30,11,23,4,20], h = 5
* 输出:30
*
*
* 示例 3:
*
*
* 输入:piles = [30,11,23,4,20], h = 6
* 输出:23
*
*
*
*
* 提示:
*
*
* 1 <= piles.length <= 10^4
* piles.length <= h <= 10^9
* 1 <= piles[i] <= 10^9
*
*
*/.