给定一个整数数组 nums 和一个整数目标值 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 <= 103-109 <= nums[i] <= 109-109 <= target <= 109给定一个整数数组 nums 和一个整数目标值 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 <= 103-109 <= nums[i] <= 109-109 <= target <= 109以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/14_\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/14_\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" index 1adc01f42777b7bcca9f743a969dd0964e950fef..3cbafaa77d47660c3f9a82abd77ce9f529531356 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/14_\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/14_\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" @@ -1,7 +1,6 @@ # 三数之和给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
提示：
0 <= nums.length <= 3000-105 <= nums[i] <= 105给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
提示：
0 <= nums.length <= 3000-105 <= nums[i] <= 105以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/17_\345\233\233\346\225\260\344\271\213\345\222\214/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/17_\345\233\233\346\225\260\344\271\213\345\222\214/solution.md" index f68abb3b9bdde46e840b49e4afa438ec3bd40d6f..7a046659d22b86bee2ea477c6744a76a804ea94a 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/17_\345\233\233\346\225\260\344\271\213\345\222\214/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/17_\345\233\233\346\225\260\344\271\213\345\222\214/solution.md" @@ -1,7 +1,6 @@ # 四数之和给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：答案中不可以包含重复的四元组。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [], target = 0
输出：[]
提示：
0 <= nums.length <= 200-109 <= nums[i] <= 109-109 <= target <= 109给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：答案中不可以包含重复的四元组。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [], target = 0
输出：[]
提示：
0 <= nums.length <= 200-109 <= nums[i] <= 109-109 <= target <= 109以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" index 9321cfd7a6304ed7cb8a5c8f3aec58af59d5df3b..4dabd4d961a996328d541804aa74a00a93f450da 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" @@ -25,33 +25,7 @@
进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？
整数数组 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 。
-
-
示例 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^4nums 中的每个值都 独一无二nums 在预先未知的某个下标上进行了旋转-10^4 <= target <= 10^4-
进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/33_\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/33_\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/solution.md" index d1d5085da15114673b630fd5c7a26b6d9bfa0f45..75e35d6f712ea8709197e373eb2e35d3853a17f3 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/33_\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/33_\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/solution.md" @@ -20,28 +20,7 @@nums 是一个非递减数组-109 <= target <= 109给定一个按照升序排列的整数数组 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 <= 105-109 <= nums[i] <= 109nums 是一个非递减数组-109 <= target <= 109以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/34_\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/34_\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/solution.md" index 55fe4ca221c21cd4d7d7901584992b56f1b111f3..53ea242c861e9f0ca993ead3074027427b38cb0d 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/34_\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/34_\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/solution.md" @@ -1,7 +1,6 @@ # 搜索插入位置给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0-
输出: 0
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0-
输出: 0
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/3_\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/3_\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/solution.md" index 576a32c27917c8da3cc90e8ecbe9f2abade38956..e87eb833df3e4408e6648798ea2c88718238648f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/3_\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/3_\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/solution.md" @@ -1,7 +1,6 @@ # 寻找两个正序数组的中位数给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000
提示：
nums1.length == mnums2.length == n0 <= m <= 10000 <= n <= 10001 <= m + n <= 2000-106 <= nums1[i], nums2[i] <= 106
进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000
提示：
nums1.length == mnums2.length == n0 <= m <= 10000 <= n <= 10001 <= m + n <= 2000-106 <= nums1[i], nums2[i] <= 106
进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/47_\346\227\213\350\275\254\345\233\276\345\203\217/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/47_\346\227\213\350\275\254\345\233\276\345\203\217/solution.md" index 6405d5688b59d07f5d880fce0ed5d61f349e0de1..d3885064164a35a6f3d998a89627f296e93842db 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/47_\346\227\213\350\275\254\345\233\276\345\203\217/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode\346\225\260\347\273\204/47_\346\227\213\350\275\254\345\233\276\345\203\217/solution.md" @@ -1,7 +1,6 @@ # 旋转图像给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
示例 3：
输入：matrix = [[1]]
输出：[[1]]
示例 4：
输入：matrix = [[1,2],[3,4]]
输出：[[3,1],[4,2]]
提示：
matrix.length == nmatrix[i].length == n1 <= n <= 20-1000 <= matrix[i][j] <= 1000给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
示例 3：
输入：matrix = [[1]]
输出：[[1]]
示例 4：
输入：matrix = [[1,2],[3,4]]
输出：[[3,1],[4,2]]
提示：
matrix.length == nmatrix[i].length == n1 <= n <= 20-1000 <= matrix[i][j] <= 1000以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/21_\346\213\254\345\217\267\347\224\237\346\210\220/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/21_\346\213\254\345\217\267\347\224\237\346\210\220/solution.md" index 7f5457350a3af2fc532efaf73ba5ea1658224f9a..d1e064403f29c4cb74b22e6339095d8ca69cc488 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/21_\346\213\254\345\217\267\347\224\237\346\210\220/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/21_\346\213\254\345\217\267\347\224\237\346\210\220/solution.md" @@ -1,7 +1,6 @@ # 括号生成数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
1 <= n <= 8数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
1 <= n <= 8以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/31_\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/31_\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/solution.md" index d29a631b951a089a1a1dbe82a5f917e3afce8ecd..b20aca479cfc26eccddacd3a6dbefb4f5fd34289 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/31_\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/31_\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/solution.md" @@ -1,7 +1,6 @@ # 最长有效括号给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
示例 1：
输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"
示例 2：
输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"
示例 3：
输入：s = ""
输出：0
提示：
0 <= s.length <= 3 * 104s[i] 为 '(' 或 ')'给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
示例 1：
输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"
示例 2：
输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"
示例 3：
输入：s = ""
输出：0
提示：
0 <= s.length <= 3 * 104s[i] 为 '(' 或 ')'以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/43_\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/43_\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/solution.md" index 07d293818653a5e621fd71c3948ca8e3c5d85685..f9836ababf661942ed8dd6cef91327e741ebf387 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/43_\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/43_\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/solution.md" @@ -1,7 +1,6 @@ # 通配符匹配给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。
'?' 可以匹配任何单个字符。'*' 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。
说明:
s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。示例 1:
输入:s = "aa"p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:s = "aa"p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
示例 3:
输入:s = "cb"p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
示例 4:
输入:s = "adceb"p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
示例 5:
输入:s = "acdcb"p = "a*c?b"-
输出: false
给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。
'?' 可以匹配任何单个字符。'*' 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。
说明:
s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。示例 1:
输入:s = "aa"p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:s = "aa"p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
示例 3:
输入:s = "cb"p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
示例 4:
输入:s = "adceb"p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
示例 5:
输入:s = "acdcb"p = "a*c?b"-
输出: false
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/4_\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/4_\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/solution.md" index fa41147d0ee9d0204b4ce7671cb8ee65617daf8a..b4f2baed734ecaab1918edc1eee9edc93aecfc7b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/4_\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/4_\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/solution.md" @@ -1,7 +1,6 @@ # 最长回文子串给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
示例 3：
输入：s = "a"
输出："a"
示例 4：
输入：s = "ac"
输出："a"
提示：
1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
示例 3：
输入：s = "a"
输出："a"
示例 4：
输入：s = "ac"
输出："a"
提示：
1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/9_\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\214\271\351\205\215/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/9_\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\214\271\351\205\215/solution.md" index bd1fa29436ea5580e821037a93eaa173c61e862f..755787bd368e9baf4f7ff9680c020420db908c5e 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/9_\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\214\271\351\205\215/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/11.leetcode\345\212\250\346\200\201\350\247\204\345\210\222/9_\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\214\271\351\205\215/solution.md" @@ -1,7 +1,6 @@ # 正则表达式匹配给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
示例 1：
输入：s = "aa" p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
示例 2:
输入：s = "aa" p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：
输入：s = "ab" p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4：
输入：s = "aab" p = "c*a*b"
输出：true
解释：因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5：
输入：s = "mississippi" p = "mis*is*p*."
输出：false
提示：
0 <= s.length <= 200 <= p.length <= 30s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。* 时，前面都匹配到有效的字符给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
示例 1：
输入：s = "aa" p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
示例 2:
输入：s = "aa" p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：
输入：s = "ab" p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4：
输入：s = "aab" p = "c*a*b"
输出：true
解释：因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5：
输入：s = "mississippi" p = "mis*is*p*."
输出：false
提示：
0 <= s.length <= 200 <= p.length <= 30s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。* 时，前面都匹配到有效的字符以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/16_\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/16_\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/solution.md" index 41e7bd4395a5fac14f063a7c12189f774a0c31b8..3214a61675a4b6867cc7b5dbf9c3e9d180b13224 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/16_\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/16_\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/solution.md" @@ -1,7 +1,6 @@ # 电话号码的字母组合给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：
输入：digits = ""
输出：[]
示例 3：
输入：digits = "2"
输出：["a","b","c"]
提示：
0 <= digits.length <= 4digits[i] 是范围 ['2', '9'] 的一个数字。给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：
输入：digits = ""
输出：[]
示例 3：
输入：digits = "2"
输出：["a","b","c"]
提示：
0 <= digits.length <= 4digits[i] 是范围 ['2', '9'] 的一个数字。以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/36_\350\247\243\346\225\260\347\213\254/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/36_\350\247\243\346\225\260\347\213\254/solution.md" index 9b7a123ad86a943f81982cafac8ca97c200fb421..6e6c16619eaff396762514b3d1fa3072de7691dd 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/36_\350\247\243\346\225\260\347\213\254/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/36_\350\247\243\346\225\260\347\213\254/solution.md" @@ -50,58 +50,7 @@ -编写一个程序，通过填充空格来解决数独问题。
-数独的解法需 遵循如下规则：
-1-9 在每一行只能出现一次。1-9 在每一列只能出现一次。1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用 '.' 表示。
-
示例：
- 输入：board = - [["5","3",".",".","7",".",".",".","."], - ["6",".",".","1","9","5",".",".","."], - [".","9","8",".",".",".",".","6","."], - ["8",".",".",".","6",".",".",".","3"], - ["4",".",".","8",".","3",".",".","1"], - ["7",".",".",".","2",".",".",".","6"], - [".","6",".",".",".",".","2","8","."], - [".",".",".","4","1","9",".",".","5"], - [".",".",".",".","8",".",".","7","9"]] --
输出： - [["5","3","4","6","7","8","9","1","2"], - ["6","7","2","1","9","5","3","4","8"], - ["1","9","8","3","4","2","5","6","7"], - ["8","5","9","7","6","1","4","2","3"], - ["4","2","6","8","5","3","7","9","1"], - ["7","1","3","9","2","4","8","5","6"], - ["9","6","1","5","3","7","2","8","4"], - ["2","8","7","4","1","9","6","3","5"], - ["3","4","5","2","8","6","1","7","9"]] -
解释：输入的数独如上图所示，唯一有效的解决方案如下所示： --
-
- -
提示：
-board.length == 9board[i].length == 9board[i][j] 是一位数字或者 '.'以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/38_\347\273\204\345\220\210\346\200\273\345\222\214/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/38_\347\273\204\345\220\210\346\200\273\345\222\214/solution.md" index 83244e7e812ef89949f87b6115980f174d31bfd4..82e606ecb333618db5a43066381c0616839982cf 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/38_\347\273\204\345\220\210\346\200\273\345\222\214/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/38_\347\273\204\345\220\210\346\200\273\345\222\214/solution.md" @@ -19,27 +19,7 @@candidate 中的每个元素都是独一无二的。1 <= target <= 500给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
-
candidates 中的数字可以无限制重复被选取。
说明：
-target）都是正整数。示例 1：
-输入：candidates = [2,3,6,7], target = 7,-
输出：[[7],[2,2,3]]
示例 2：
-输入：candidates = [2,3,5], target = 8,-
输出：[[2,2,2,2],[2,3,3],[3,5]]
-
提示：
-1 <= candidates.length <= 301 <= candidates[i] <= 200candidate 中的每个元素都是独一无二的。1 <= target <= 500以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/39_\347\273\204\345\220\210\346\200\273\345\222\214 II/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/39_\347\273\204\345\220\210\346\200\273\345\222\214 II/solution.md" index 5b02f8d55d737430cd7cbeed821180286a003524..e7be7046c3208358f54728fc5e39d5bebc38bfab 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/39_\347\273\204\345\220\210\346\200\273\345\222\214 II/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/39_\347\273\204\345\220\210\346\200\273\345\222\214 II/solution.md" @@ -11,19 +11,7 @@输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:[[1, 7],[1, 2, 5],[2, 6],[1, 1, 6]]
示例 2:
输入: candidates = [2,5,2,1,2], target = 5,-
所求解集为:[[1,2,2],[5]]
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
-
candidates 中的每个数字在每个组合中只能使用一次。
说明：
-示例 1:
-输入: candidates = [10,1,2,7,6,1,5], target = 8,-
所求解集为:[[1, 7],[1, 2, 5],[2, 6],[1, 1, 6]]
示例 2:
-输入: candidates = [2,5,2,1,2], target = 5,-
所求解集为:[[1,2,2],[5]]
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/45_\345\205\250\346\216\222\345\210\227/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/45_\345\205\250\346\216\222\345\210\227/solution.md" index bc4183559e2bdf5eefcb009a80073e766577cf32..12d5fb37ba606e96f800383ddbb30574ddf4f862 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/45_\345\205\250\346\216\222\345\210\227/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/45_\345\205\250\346\216\222\345\210\227/solution.md" @@ -1,7 +1,6 @@ # 全排列给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]-
输出:[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]-
输出:[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/46_\345\205\250\346\216\222\345\210\227 II/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/46_\345\205\250\346\216\222\345\210\227 II/solution.md" index bee38032eea21a3e56dd3599c23e16a4548e381e..bdaa3d0595574add2d760e44df293b066415d33c 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/46_\345\205\250\346\216\222\345\210\227 II/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/46_\345\205\250\346\216\222\345\210\227 II/solution.md" @@ -1,7 +1,6 @@ # 全排列 II给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出：[[1,1,2], [1,2,1], [2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：
1 <= nums.length <= 8-10 <= nums[i] <= 10给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出：[[1,1,2], [1,2,1], [2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：
1 <= nums.length <= 8-10 <= nums[i] <= 10以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/50_N \347\232\207\345\220\216/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/50_N \347\232\207\345\220\216/solution.md" index e79d79aac0e620e82f8b045a163106a1c65fc7dc..698a3dfe197af2e04c41211bde442fcf9f1c2d98 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/50_N \347\232\207\345\220\216/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/50_N \347\232\207\345\220\216/solution.md" @@ -1,7 +1,6 @@ # N 皇后n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例 1：
输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1
输出：[["Q"]]
提示：
1 <= n <= 9n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例 1：
输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1
输出：[["Q"]]
提示：
1 <= n <= 9以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/51_N\347\232\207\345\220\216 II/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/51_N\347\232\207\345\220\216 II/solution.md" index b21f0e549286eb19c3a6de6b74144ee3d9a3b6b6..b872d5e78c4801023c9725606fb81f0924c52b66 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/51_N\347\232\207\345\220\216 II/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/12.leetcode\345\233\236\346\272\257\347\256\227\346\263\225/51_N\347\232\207\345\220\216 II/solution.md" @@ -33,41 +33,7 @@ -n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。
- -
示例 1：
-
- 输入：n = 4 -- -
输出：2 -
解释：如上图所示，4 皇后问题存在两个不同的解法。 -
示例 2：
- -输入：n = 1 -- -
输出：1 -
- -
提示：
- -1 <= n <= 9以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/13.leetcode\350\264\252\345\277\203/44_\350\267\263\350\267\203\346\270\270\346\210\217 II/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/13.leetcode\350\264\252\345\277\203/44_\350\267\263\350\267\203\346\270\270\346\210\217 II/solution.md" index 51ab41c38ff3c7ef61e39fd604ea2e37b5b63179..d4eb67ad6c0a560a7c59620cb7b8dd6d636f7815 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/13.leetcode\350\264\252\345\277\203/44_\350\267\263\350\267\203\346\270\270\346\210\217 II/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/13.leetcode\350\264\252\345\277\203/44_\350\267\263\350\267\203\346\270\270\346\210\217 II/solution.md" @@ -6,14 +6,7 @@输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明:
假设你总是可以到达数组的最后一个位置。
-给定一个非负整数数组，你最初位于数组的第一个位置。
-数组中的每个元素代表你在该位置可以跳跃的最大长度。
-你的目标是使用最少的跳跃次数到达数组的最后一个位置。
-示例:
-输入: [2,3,1,1,4]-
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明:
-假设你总是可以到达数组的最后一个位置。
-以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/10_\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/10_\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/solution.md" index efb8cafb0fc9199a99d7332b8309db499cc1255c..d4869915fa5a3cf2544ef98218335b5ac9a6efa9 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/10_\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/10_\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/solution.md" @@ -1,7 +1,6 @@ # 盛最多水的容器给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
示例 3：
输入：height = [4,3,2,1,4]
输出：16
示例 4：
输入：height = [1,2,1]
输出：2
提示：
n = height.length2 <= n <= 3 * 1040 <= height[i] <= 3 * 104给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
示例 3：
输入：height = [4,3,2,1,4]
输出：16
示例 4：
输入：height = [1,2,1]
输出：2
提示：
n = height.length2 <= n <= 3 * 1040 <= height[i] <= 3 * 104以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/15_\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/15_\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" index 0eabbda0ac2aa0025d7518935d47d879785895b7..6e5e5bef90dd13df17695d0ad6cb919236beb163 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/15_\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/15_\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/solution.md" @@ -1,7 +1,6 @@ # 最接近的三数之和给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
提示：
3 <= nums.length <= 10^3-10^3 <= nums[i] <= 10^3-10^4 <= target <= 10^4给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
提示：
3 <= nums.length <= 10^3-10^3 <= nums[i] <= 10^3-10^4 <= target <= 10^4以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/25_\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/25_\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/solution.md" index 951264c3323252bd9023f16af5d02afb4fd3f3fc..ff56e5198c16540e2bdf45aa4fb4f355793b74bf 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/25_\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/25_\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/solution.md" @@ -53,61 +53,7 @@ for (int i = 0; i < len; i++) {-
给你一个有序数组 nums ，请你
- 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 - 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
- -- -
说明:
- -为什么返回数值是整数，但输出的答案是数组呢?
- -请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
- -你可以想象内部操作如下:
- -// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
-int len = removeDuplicates(nums);
-
-// 在函数里修改输入数组对于调用者是可见的。
-// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
-for (int i = 0; i < len; i++) {
- print(nums[i]);
-}
-
-
-
- 示例 1：
- -输入：nums = [1,1,2] -- -
输出：2, nums = [1,2] -
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。 -
示例 2：
- -输入：nums = [0,0,1,1,1,2,2,3,3,4] -- -
输出：5, nums = [0,1,2,3,4] -
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。 -
- -
提示：
- -0 <= nums.length <= 3 * 104-104 <= nums[i] <= 104nums 已按升序排列-
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" index eafc76e7641a5fcce980789399ab6b65cc3b8429..4823c6b4bc2000dc5dd56ee70a498ce7ce303905 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" @@ -55,63 +55,7 @@ for (int i = 0; i < len; i++) {0 <= val <= 100给你一个数组 nums 和一个值 val，你需要 原地
- 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
- -- -
说明:
- -为什么返回数值是整数，但输出的答案是数组呢?
- -请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
- -你可以想象内部操作如下:
- -// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
-int len = removeElement(nums, val);
-
-// 在函数里修改输入数组对于调用者是可见的。
-// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
-for (int i = 0; i < len; i++) {
- print(nums[i]);
-}
-
-
- - -
示例 1：
- -输入：nums = [3,2,2,3], val = 3 -- -
输出：2, nums = [2,2] -
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。 -
示例 2：
- -输入：nums = [0,1,2,2,3,0,4,2], val = 2 -- -
输出：5, nums = [0,1,4,0,3] -
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。 -
- -
提示：
- -0 <= nums.length <= 1000 <= nums[i] <= 500 <= val <= 100以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" index 90b199c4425805a8a46e5ff061a1988606db3d60..2c8ad218e69230133eeeb1baa7ab0383bc8805b5 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/14.leetcode\345\217\214\346\214\207\351\222\210/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" @@ -1,7 +1,6 @@ # 下一个排列实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。
示例 1：
输入：nums = [1,2,3]
输出：[1,3,2]
示例 2：
输入：nums = [3,2,1]
输出：[1,2,3]
示例 3：
输入：nums = [1,1,5]
输出：[1,5,1]
示例 4：
输入：nums = [1]
输出：[1]
提示：
1 <= nums.length <= 1000 <= nums[i] <= 100实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。
示例 1：
输入：nums = [1,2,3]
输出：[1,3,2]
示例 2：
输入：nums = [3,2,1]
输出：[1,2,3]
示例 3：
输入：nums = [1,1,5]
输出：[1,5,1]
示例 4：
输入：nums = [1]
输出：[1]
提示：
1 <= nums.length <= 1000 <= nums[i] <= 100以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/18_\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/18_\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271/solution.md" index 973d20d579f0a71dbef07f7d6d54036915c728cc..564c68718f21e48ea37aba1103059254792a3fe7 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/18_\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/18_\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271/solution.md" @@ -1,7 +1,6 @@ # 删除链表的倒数第 N 个结点给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
sz1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
sz1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/1_\344\270\244\346\225\260\347\233\270\345\212\240/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/1_\344\270\244\346\225\260\347\233\270\345\212\240/solution.md" index 287328cbd64e8aaebe7194bd51d5679c3671e6af..3c618969340c3346ba9f815f09677e61dd4e54d9 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/1_\344\270\244\346\225\260\347\233\270\345\212\240/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/1_\344\270\244\346\225\260\347\233\270\345\212\240/solution.md" @@ -1,7 +1,6 @@ # 两数相加给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
[1, 100] 内0 <= Node.val <= 9给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
[1, 100] 内0 <= Node.val <= 9以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/20_\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/20_\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/solution.md" index 951ea5a66e00b5d3a76fd3a733e49f9fbb45563b..53a2ccb066a6674df4d5be2558505b00d2782a83 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/20_\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/20_\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/solution.md" @@ -1,7 +1,6 @@ # 合并两个有序链表将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
提示：
[0, 50]-100 <= Node.val <= 100l1 和 l2 均按 非递减顺序 排列将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
提示：
[0, 50]-100 <= Node.val <= 100l1 和 l2 均按 非递减顺序 排列以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/22_\345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/22_\345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250/solution.md" index 30db6d94a1e364862d98e07607277c0c74bb8a8f..de4aa632796bc4a8f64e7b55354f9b061cc66c27 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/22_\345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/22_\345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250/solution.md" @@ -1,7 +1,6 @@ # 合并K个升序链表给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：[ 1->4->5, 1->3->4, 2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]
提示：
k == lists.length0 <= k <= 10^40 <= lists[i].length <= 500-10^4 <= lists[i][j] <= 10^4lists[i] 按 升序 排列lists[i].length 的总和不超过 10^4给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：[ 1->4->5, 1->3->4, 2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]
提示：
k == lists.length0 <= k <= 10^40 <= lists[i].length <= 500-10^4 <= lists[i][j] <= 10^4lists[i] 按 升序 排列lists[i].length 的总和不超过 10^4以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/23_\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/23_\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/solution.md" index c2cd906251bce0c3c7d9c9997a7ded53af2b775c..0ffc7e61183b2954dc504b6e99ec7ae07b4a105b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/23_\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/23_\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/solution.md" @@ -1,7 +1,6 @@ # 两两交换链表中的节点给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
[0, 100] 内0 <= Node.val <= 100
进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）
-给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
[0, 100] 内0 <= Node.val <= 100
进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）
-以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/24_K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/24_K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250/solution.md" index 3b1aa08c21da8bdbd18ebda9a7c92b02046c3a16..81934d10436f511a34474e7b2d821b3b17561a14 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/24_K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/2.leetcode\351\223\276\350\241\250/24_K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250/solution.md" @@ -1,7 +1,6 @@ # K 个一组翻转链表给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：
输入：head = [1], k = 1
输出：[1]
提示：
sz 内1 <= sz <= 50000 <= Node.val <= 10001 <= k <= sz给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：
输入：head = [1], k = 1
输出：[1]
提示：
sz 内1 <= sz <= 50000 <= Node.val <= 10001 <= k <= sz以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/13_\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/13_\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/solution.md" index 5a22720ac994e4d15116f3bf7aa802712e001b53..ca3de429e3f53282d50e401833ac0a9f030ec1b8 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/13_\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/13_\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/solution.md" @@ -1,7 +1,6 @@ # 最长公共前缀编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
提示：
0 <= strs.length <= 2000 <= strs[i].length <= 200strs[i] 仅由小写英文字母组成编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
提示：
0 <= strs.length <= 2000 <= strs[i].length <= 200strs[i] 仅由小写英文字母组成以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/27_\345\256\236\347\216\260 strStr()/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/27_\345\256\236\347\216\260 strStr()/solution.md" index 902882437976614c70749496c1f6a7ae475357b8..fd4b512cad3b5416345c2a1cf5d6c9facc7a6b97 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/27_\345\256\236\347\216\260 strStr()/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/27_\345\256\236\347\216\260 strStr()/solution.md" @@ -22,30 +22,7 @@0 <= haystack.length, needle.length <= 5 * 104haystack 和 needle 仅由小写英文字符组成实现 strStr() 函数。
-给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle
- 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
-
说明：
-当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。
-
示例 1：
-输入：haystack = "hello", needle = "ll"-
输出：2
示例 2：
-输入：haystack = "aaaaa", needle = "bba"-
输出：-1
示例 3：
-输入：haystack = "", needle = ""-
输出：0
-
提示：
-0 <= haystack.length, needle.length <= 5 * 104haystack 和 needle 仅由小写英文字符组成以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/2_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/2_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/solution.md" index 8b14ba1325c66306b403d7bde28135a37ab96d66..7340c0e7e71b37fd5e306ea45698222edb277b00 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/2_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/2_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/solution.md" @@ -1,9 +1,7 @@ # 无重复字符的最长子串给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0
提示：
0 <= s.length <= 5 * 104s 由英文字母、数字、符号和空格组成给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 -请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0
提示：
0 <= s.length <= 5 * 104s 由英文字母、数字、符号和空格组成以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/37_\345\244\226\350\247\202\346\225\260\345\210\227/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/37_\345\244\226\350\247\202\346\225\260\345\210\227/solution.md" index d27f99936961cb1b1d54ae33b1735df17408ecfa..30a7e166a8c560bf8371aa07453b66570dc5fa60 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/37_\345\244\226\350\247\202\346\225\260\345\210\227/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/37_\345\244\226\350\247\202\346\225\260\345\210\227/solution.md" @@ -64,72 +64,7 @@ countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"1 <= n <= 30给定一个正整数 n ，输出外观数列的第 n 项。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
- -你可以将其视作是由递归公式定义的数字字符串序列：
- -countAndSay(1) = "1"countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。前五项如下：
- -- 1. 1 - 2. 11 - 3. 21 - 4. 1211 - 5. 111221 - 第一项是数字 1 - 描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11" - 描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21" - 描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211" - 描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221" -- -
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 - 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
- -例如，数字字符串 "3322251" 的描述如下图：
- - -
示例 1：
- -输入：n = 1 -- -
输出："1" -
解释：这是一个基本样例。 -
示例 2：
- -输入：n = 4 -- -
输出："1211" -
解释： -countAndSay(1) = "1" -countAndSay(2) = 读 "1" = 一 个 1 = "11" -countAndSay(3) = 读 "11" = 二 个 1 = "21" -countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211" -
- -
提示：
- -1 <= n <= 30以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/42_\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/42_\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/solution.md" index 44e233a9dc1c7ee138eff6a5f4e2fd19a541bb79..f8efe63ffbe122d00393bdebddadced93fa5d36f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/42_\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/42_\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/solution.md" @@ -1,7 +1,6 @@ # 字符串相乘给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。
示例 1:
输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:
输入: num1 = "123", num2 = "456"
输出: "56088"
说明：
num1 和 num2 的长度小于110。num1 和 num2 只包含数字 0-9。num1 和 num2 均不以零开头，除非是数字 0 本身。给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。
示例 1:
输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:
输入: num1 = "123", num2 = "456"
输出: "56088"
说明：
num1 和 num2 的长度小于110。num1 和 num2 只包含数字 0-9。num1 和 num2 均不以零开头，除非是数字 0 本身。以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/5_Z \345\255\227\345\275\242\345\217\230\346\215\242/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/5_Z \345\255\227\345\275\242\345\217\230\346\215\242/solution.md" index 83e670d5b3c9181263e09d45962b3eb1d298bd5e..6ce6cdafa25eb7939ef8fa9c169234459358729f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/5_Z \345\255\227\345\275\242\345\217\230\346\215\242/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/5_Z \345\255\227\345\275\242\345\217\230\346\215\242/solution.md" @@ -49,57 +49,7 @@ P I1 <= numRows <= 1000将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：
- P A H N - A P L S I I G - Y I R- -
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
请你实现这个将字符串进行指定行数变换的函数：
- -string convert(string s, int numRows);- -
- -
示例 1：
- -输入：s = "PAYPALISHIRING", numRows = 3 -- 示例 2： - -
输出："PAHNAPLSIIGYIR" -
输入：s = "PAYPALISHIRING", numRows = 4 -- -
输出："PINALSIGYAHRPI" -
解释： -P I N -A L S I G -Y A H R -P I -
示例 3：
- -输入：s = "A", numRows = 1 -- -
输出："A" -
- -
提示：
- -1 <= s.length <= 1000s 由英文字母（小写和大写）、',' 和 '.' 组成1 <= numRows <= 1000以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/7_\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260 (atoi)/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/7_\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260 (atoi)/solution.md" index 0673a730ab2cf2c8f12ebdace29e12a94ca0b36b..6e2f64a1d9a9072cd459fafcbf889a6add47c6da 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/7_\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260 (atoi)/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/3.leetcode\345\255\227\347\254\246\344\270\262/7_\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260 (atoi)/solution.md" @@ -108,116 +108,7 @@ -请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：
0 。必要时更改符号（从步骤 2 开始）。[−231, 231 − 1]
- ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于
- 231 − 1 的整数应该被固定为 231 − 1 。
- 注意：
- -' ' 。- -
示例 1：
- -输入：s = "42" -- -
输出：42 -
解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。 -第 1 步："42"（当前没有读入字符，因为没有前导空格） - ^ -第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'） - ^ -第 3 步："42"（读入 "42"） - ^ -解析得到整数 42 。 -由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。
示例 2：
- -输入：s = " -42" -- -
输出：-42 -
解释： -第 1 步：" -42"（读入前导空格，但忽视掉） - ^ -第 2 步：" -42"（读入 '-' 字符，所以结果应该是负数） - ^ -第 3 步：" -42"（读入 "42"） - ^ -解析得到整数 -42 。 -由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。 -
示例 3：
- -输入：s = "4193 with words" -- -
输出：4193 -
解释： -第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格） - ^ -第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'） - ^ -第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止） - ^ -解析得到整数 4193 。 -由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。 -
示例 4：
- -输入：s = "words and 987" -- -
输出：0 -
解释： -第 1 步："words and 987"（当前没有读入字符，因为没有前导空格） - ^ -第 2 步："words and 987"（当前没有读入字符，因为这里不存在 '-' 或者 '+'） - ^ -第 3 步："words and 987"（由于当前字符 'w' 不是一个数字，所以读入停止） - ^ -解析得到整数 0 ，因为没有读入任何数字。 -由于 0 在范围 [-231, 231 - 1] 内，最终结果为 0 。
示例 5：
- -输入：s = "-91283472332" -- -
输出：-2147483648 -
解释： -第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格） - ^ -第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数） - ^ -第 3 步："-91283472332"（读入 "91283472332"） - ^ -解析得到整数 -91283472332 。 -由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 。
- -
提示：
- -0 <= s.length <= 200s 由英文字母（大写和小写）、数字（0-9）、' '、'+'、'-' 和
- '.' 组成
- 以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/19_\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/19_\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/solution.md" index 23670ab8f846de839082ed4fc27bdb2d3e2c2c4e..e1dfbc8fb1ab336123bd6044d2afedb6a96ef394 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/19_\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/19_\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/solution.md" @@ -1,7 +1,6 @@ # 有效的括号给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true示例 3：
输入：s = "(]"
输出：false
示例 4：
输入：s = "([)]"
输出：false
示例 5：
输入：s = "{[]}"
输出：true
提示：
1 <= s.length <= 104s 仅由括号 '()[]{}' 组成给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true示例 3：
输入：s = "(]"
输出：false
示例 4：
输入：s = "([)]"
输出：false
示例 5：
输入：s = "{[]}"
输出：true
提示：
1 <= s.length <= 104s 仅由括号 '()[]{}' 组成以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/41_\346\216\245\351\233\250\346\260\264/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/41_\346\216\245\351\233\250\346\260\264/solution.md" index 4444b6168e2f19ada7cf307b10817b5ae0274f79..03f8ec294e74cee82cfa919e97b9e683dd3798a4 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/41_\346\216\245\351\233\250\346\260\264/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/4.leetcode\346\240\210\344\270\216\351\230\237\345\210\227/41_\346\216\245\351\233\250\346\260\264/solution.md" @@ -1,7 +1,6 @@ # 接雨水给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：
输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：
输入：height = [4,2,0,3,2,5]
输出：9
提示：
n == height.length0 <= n <= 3 * 1040 <= height[i] <= 105给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：
输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：
输入：height = [4,2,0,3,2,5]
输出：9
提示：
n == height.length0 <= n <= 3 * 1040 <= height[i] <= 105以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" index 079c2681021206a5511ae4334454a6e4e3be4c87..81f672eef411c4af02eb420051c761cc62b8ae55 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" @@ -7,15 +7,7 @@输入： s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。输出的顺序不重要, [9,0] 也是有效答案。
示例 2：
输入： s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]-
输出：[]
给定一个字符串 s 和一些长度相同的单词 words。找出 s - 中恰好可以由 words 中所有单词串联形成的子串的起始位置。
-注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。
--
示例 1：
-输入： s = "barfoothefoobarman", words = ["foo","bar"]-
输出：[0,9]
解释：从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。输出的顺序不重要, [9,0] 也是有效答案。
示例 2：
-输入： s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]-
输出：[]
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/35_\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/35_\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/solution.md" index 823970d0dd426366d9dcaf5e6c5aeaa8e2c35d66..0090e2461f686e285b8c7bb7efe9eac8c7763ba0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/35_\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/35_\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/solution.md" @@ -47,55 +47,7 @@board[i].length == 9board[i][j] 是一位数字或者 '.'请你判断一个 9x9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
1-9 在每一行只能出现一次。1-9 在每一列只能出现一次。1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用 '.' 表示。
注意：
--
示例 1：
-输入：board = - [["5","3",".",".","7",".",".",".","."] - ,["6",".",".","1","9","5",".",".","."] - ,[".","9","8",".",".",".",".","6","."] - ,["8",".",".",".","6",".",".",".","3"] - ,["4",".",".","8",".","3",".",".","1"] - ,["7",".",".",".","2",".",".",".","6"] - ,[".","6",".",".",".",".","2","8","."] - ,[".",".",".","4","1","9",".",".","5"] - ,[".",".",".",".","8",".",".","7","9"]] --
输出：true -
示例 2：
-输入：board = - [["8","3",".",".","7",".",".",".","."] - ,["6",".",".","1","9","5",".",".","."] - ,[".","9","8",".",".",".",".","6","."] - ,["8",".",".",".","6",".",".",".","3"] - ,["4",".",".","8",".","3",".",".","1"] - ,["7",".",".",".","2",".",".",".","6"] - ,[".","6",".",".",".",".","2","8","."] - ,[".",".",".","4","1","9",".",".","5"] - ,[".",".",".",".","8",".",".","7","9"]] --
输出：false -
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
-
提示：
-board.length == 9board[i].length == 9board[i][j] 是一位数字或者 '.'以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/40_\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/40_\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/solution.md" index b789a7ef06f9a53fa928f063d5d13f0d2e1a736e..53ed804c394ae0ba1db60dfee8a90565db512395 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/40_\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/40_\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/solution.md" @@ -1,7 +1,6 @@ # 缺失的第一个正数给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
进阶：你可以实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案吗？
示例 1：
输入：nums = [1,2,0]
输出：3
示例 2：
输入：nums = [3,4,-1,1]
输出：2
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
提示：
0 <= nums.length <= 300-231 <= nums[i] <= 231 - 1给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
进阶：你可以实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案吗？
示例 1：
输入：nums = [1,2,0]
输出：3
示例 2：
输入：nums = [3,4,-1,1]
输出：2
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
提示：
0 <= nums.length <= 300-231 <= nums[i] <= 231 - 1以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/48_\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/48_\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/solution.md" index 364cad0a6c2af1ee79ac58223d8b2666b23fbe9e..d18f12b08814caee1d622bba258408af0f828520 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/48_\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/6.leetcode\345\223\210\345\270\214\350\241\250/48_\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/solution.md" @@ -7,15 +7,7 @@给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
-示例:
-输入:[eat", "tea", "tan", "ate", "nat", "bat"]-
输出:[[ate","eat","tea"],["nat","tan"],["bat"]]
说明：
-以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/11_\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/11_\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227/solution.md" index 076ca22ade4886324ec62c17fdb2ca224b8ab444..02753f15d5bd80f3a5f4b9114d344470c1f32c0b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/11_\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/11_\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227/solution.md" @@ -68,76 +68,7 @@ M 10001 <= num <= 3999罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
-
字符 数值 -I 1 -V 5 -X 10 -L 50 -C 100 -D 500 -M 1000- -
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12
- 写做 XII ，即为 X + II 。 27
- 写做 XXVII,
- 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
- 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40
- 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400
- 和 900。给你一个整数，将其转为罗马数字。
- -- -
示例 1:
- -输入: num = 3 -- -
输出: "III"
示例 2:
- -输入: num = 4 -- -
输出: "IV"
示例 3:
- -输入: num = 9 -- -
输出: "IX"
示例 4:
- -输入: num = 58 -- -
输出: "LVIII" -
解释: L = 50, V = 5, III = 3. -
示例 5:
- -输入: num = 1994 -- -
输出: "MCMXCIV" -
解释: M = 1000, CM = 900, XC = 90, IV = 4.
- -
提示：
- -1 <= num <= 3999以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/12_\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/12_\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260/solution.md" index 1d872780dc00551331dff62f481e2ab2da1a2247..b6ce3ae8b37d98f9e1e5b5adf8cc323c3294cefd 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/12_\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/12_\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260/solution.md" @@ -68,76 +68,7 @@ M 10001 <= num <= 3999罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
-
字符 数值 -I 1 -V 5 -X 10 -L 50 -C 100 -D 500 -M 1000- -
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12
- 写做 XII ，即为 X + II 。 27
- 写做 XXVII,
- 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
- 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40
- 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400
- 和 900。给你一个整数，将其转为罗马数字。
- -- -
示例 1:
- -输入: num = 3 -- -
输出: "III"
示例 2:
- -输入: num = 4 -- -
输出: "IV"
示例 3:
- -输入: num = 9 -- -
输出: "IX"
示例 4:
- -输入: num = 58 -- -
输出: "LVIII" -
解释: L = 50, V = 5, III = 3. -
示例 5:
- -输入: num = 1994 -- -
输出: "MCMXCIV" -
解释: M = 1000, CM = 900, XC = 90, IV = 4.
- -
提示：
- -1 <= num <= 3999以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" index ae9b8c68dc8678c12937d390677ddbfd94eeb6f3..c86b9b4c52489574ada9e085bf1a796242af4993 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" @@ -1,7 +1,6 @@ # 两数相除给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
示例 2:
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
提示：
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
示例 2:
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
提示：
以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/49_Pow(x, n)/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/49_Pow(x, n)/solution.md" index 0b0540b4088619297095a61bb29dc78f7063b151..1f05664319535bab4c365aee1dc3ef97c9a3a4de 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/49_Pow(x, n)/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/49_Pow(x, n)/solution.md" @@ -1,7 +1,6 @@ # Pow(x, n)实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提示：
-100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提示：
-100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/6_\346\225\264\346\225\260\345\217\215\350\275\254/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/6_\346\225\264\346\225\260\345\217\215\350\275\254/solution.md" index 5a4b286cf34eb4e4c3fe1e3894406f1798223f27..ff6d898e12ab6592fcacd5dc519d328d1c3e2c9a 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/6_\346\225\264\346\225\260\345\217\215\350\275\254/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/6_\346\225\264\346\225\260\345\217\215\350\275\254/solution.md" @@ -1,7 +1,6 @@ # 整数反转给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
示例 1：
输入：x = 123
输出：321
示例 2：
输入：x = -123
输出：-321
示例 3：
输入：x = 120
输出：21
示例 4：
输入：x = 0
输出：0
提示：
-231 <= x <= 231 - 1给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
示例 1：
输入：x = 123
输出：321
示例 2：
输入：x = -123
输出：-321
示例 3：
输入：x = 120
输出：21
示例 4：
输入：x = 0
输出：0
提示：
-231 <= x <= 231 - 1以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/8_\345\233\236\346\226\207\346\225\260/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/8_\345\233\236\346\226\207\346\225\260/solution.md" index 142213863319916731c8ac9551690f1841cbb10f..c7f66861f30a7d8e32115704cfb8e583aca29947 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/8_\345\233\236\346\226\207\346\225\260/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/8.leetcode\346\225\260\345\255\246/8_\345\233\236\346\226\207\346\225\260/solution.md" @@ -1,7 +1,6 @@ # 回文数给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：
输入：x = -101
输出：false
提示：
-231 <= x <= 231 - 1
进阶：你能不将整数转为字符串来解决这个问题吗？
-给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：
输入：x = -101
输出：false
提示：
-231 <= x <= 231 - 1
进阶：你能不将整数转为字符串来解决这个问题吗？
-以下错误的选项是？
+以下错误的选项是？
## aop ### before ```cpp