package
0.0.0-20240920062246-d0657495930a
Repository: https://github.com/yigmmk/leetcode.git
Documentation: pkg.go.dev

# README

binary search

sort.SearchInts使用技巧

lowerBound := sort.SearchInts
upperBound := func(a []int, x int) int { return sort.SearchInts(a, x+1) }
upperBound = func(a []int, x int) int { return sort.Search(len(a), func(i int) bool { return a[i] > x }) }

等于 x 的下标范围:[lowerBound(x), upperBound(x)) lowerBound-1 为 <x 的最大值的下标(-1 表示不存在),存在多个最大值时下标取最大的 upperBound-1 为 <=x 的最大值的下标(-1 表示不存在),存在多个最大值时下标取最大的

sort.Search的使用技巧

// go.Search注释
// Search uses binary search to find and return the smallest index i
// in [0, n) at which f(i) is true, assuming that on the range [0, n),
// f(i) == true implies f(i+1) == true
// 使用二分查找,返回最小的i使f(i)为true,没有找到为true的i,将返回n

// Note that the "not found" return value is not -1 as in, for instance,
// strings.Index.
// 未找到不返回-1(和strings.Index行为不同)

sort.Search(n, f) 需要满足当 x 从小到大时,f(x) 先 false 后 true 若 f(x) 是先 true 后 false,且目标是找到最大的使 f(x) 为 true 的 x 这种情况可以考虑二分 !f(x),则二分结果是最小的使 f(x) 为 false 的 x,将其 -1 就得到了最大的使 f(x) 为 true 的 x 由于要对结果 -1,sort.Search 传入的上界需要 +1 更加简单的写法是,在 f(x) 内部将 x++,这样就不需要对上界和结果调整 ±1 了

下面以二分求 int(sqrt(90)) 为例来说明这一技巧 这相当于求最大的满足 xx<=90 的 x 于是定义 f(x) 返回 xx<=90, 注意这是一个先 true 后 false 的 f(x) 我们可以改为判断 f(x+1),即用 f(x+1) 的返回结果代替 f(x) 的返回结果 同时, 将 f(x) 改为先 false 后 true,即返回 x*x>90 这样二分的结果就恰好停在最大的满足原 f(x) 为 true 的 x 上

sort.Search(10, func(x int) bool {
  x++
  return x*x > 90
})

套路

最大化最小值/最小化最大值

看到「最大化最小值」或者「最小化最大值」就要想到二分答案,这是一个固定的套路。 为什么?一般来说,二分的值越大,越能/不能满足要求;二分的值越小,越不能/能满足要求,有单调性,可以二分。

例题

参考

蓝红二分

主体思路:l 指针掌管左边蓝色区域,r 指针掌管右边红色区域,两者互不冲突 通过不断向目标元素靠近扩大掌管区域,直到两者掌管区域接壤,即 l + 1 == r时终止。

开始时,l 指针和 r 指针取在搜索区间界外,l = 首个元素下标 - 1,r = 末尾元素下标,此时所有元素均未着色; 循环条件始终为 l + 1 ≠ r,当 l + 1 == r时跳出循环,此时蓝红区域划分完成,所有元素均已着色; mid指针取值始终为 mid = floor (l + r) / 2 l 指针和 r 指针变化的时候直接变为 mid指针,即对 mid指针所指向元素进行染色,无需 +1或者 -1; 本模板唯一变化的地方是判断目标元素最终落在左边蓝色区域还是右边红色区域

l,r:=-1,len(v)-1
for l+1<r{
  m:=int(unit(l+r)>>1)
  if isBlue(m)
    l = m
  else
    r = m
}

// 或
l,r:=-1,len(v)-1
for l+1<r{
  m:=int(unit(l+r)>>1)
  if isRed(m)
    r = m
  else
    l = m
}

作者:sui-xin-yuan 链接:https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-aray/solution/lan-hong-hua-fen-fa-dan-mo-ban-miao-sha-e7r40/ 来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

< 、≤ 、≥ 、> 目标元素 target 对应的蓝红区域划分 binarysearch

# Packages

* @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 * * */.

# Functions

func SearchInts(a []int, x int) int { return Search(len(a), func(i int) bool { return a[i] >= x }) } */.
No description provided by the author
No description provided by the author