├── .gitignore ├── 1004_最大连续1的个数III ├── 1004_longestOnes.go ├── 1004_longestOnes_test.go ├── request.txt └── result.txt ├── 101_对称二叉树 ├── 101_isSymmetric.go └── request.txt ├── 1025_除数博弈 ├── 1025_divisorGame.go ├── request.txt └── result.txt ├── 10_正则表达式匹配 ├── 10_isMatch.go ├── 10_isMatch_test.go └── request.txt ├── 1108_IP地址无效化 ├── 1108_defangIPaddr.go ├── 1108_defangIPaddr_test.go └── request.txt ├── 118_杨辉三角 ├── 118_generat_test.go ├── 118_generate.go └── request.txt ├── 11_盛最多水的容器 ├── 11_maxArea.go ├── 11_maxArea_test.go ├── question_11.jpg └── request.txt ├── 121_买卖股票的最佳时机 ├── 121_maxProfit.go ├── 121_maxProfit_test.go └── request.txt ├── 122_买卖股票的最佳时机2 ├── 122_maxProfit.go ├── 122_maxProfit_test.go └── request.txt ├── 12_整数转罗马数字 ├── 12_intToRoman.go ├── 12_intToRoman_test.go └── request.txt ├── 136_只出现一次的数字 ├── 136_singleNumber.go ├── 136_singleNumber_test.go ├── request.txt └── result.txt ├── 14_最长公共前缀 ├── 14_longestCommonPrefix.go ├── 14_longestCommonPrefix_test.go └── request.txt ├── 15_threeSum ├── 15_threeSum.go └── request.txt ├── 17_电话号码的字母组合 ├── 17_letterCombinations.go ├── 17_letterCombinations_test.go ├── 17_telephone_keypad.png ├── request.txt └── result.txt ├── 198_打家劫舍 ├── 198_rob.go ├── 198_rob_test.go └── request.txt ├── 1_twoSum ├── 1_twoSum.go └── request.txt ├── 202_快乐数 ├── 202_isHappy.go ├── 202_isHappy_test.go └── request.txt ├── 20_有效的括号 ├── 20_isValid.go ├── 20_isValid_test.go └── request.txt ├── 226_翻转二叉树 ├── 226_invertTree.go ├── 226_invertTree_test.go └── request.txt ├── 283_移动零 ├── 283_moveZeroes.go ├── 283_moveZeroes_test.go └── request.txt ├── 292_Nim游戏 ├── 292_canWinNim.go ├── 292_canWinNim_test.go └── request.txt ├── 2_addTwoNumbers ├── 2_addTwoNumbers.go ├── 2_addTwoNumbers_test.go └── request.txt ├── 3_lengthOfLongestSubstring ├── 3_lengthOfLongestSubstring.go ├── 3_lengthOfLongestSubstring_test.go └── request.txt ├── 461_汉明距离 ├── 461_hammingDistance.go ├── 461_hammingDistance_test.go └── request.txt ├── 509_斐波那契数 ├── 509_fib.go ├── 509_fib_test.go └── request.txt ├── 53_最大子序和 ├── 53_maxSubArray.go ├── 53_maxSubArray_test.go └── request.txt ├── 5_longestPalindrome ├── 5_longestPalindrome.go ├── 5_longestPalindrome_test.go └── request.txt ├── 64_最小路径和 ├── 64_minPathSum.go ├── 64_minPathSum_test.go ├── request.txt └── result.txt ├── 66_加一 ├── 66_plusOne.go ├── 66_plusOne_test.go └── request.txt ├── 6_Z字形变换 ├── 6_convert.go ├── 6_convert_test.go └── request.txt ├── 70_爬楼梯 ├── 70_climbStairs.go ├── 70_climbStairs_test.go └── request.txt ├── 728_自除数 ├── 728_selfDividingNumbers.go ├── 728_selfDividingNumbers_test.go └── request.txt ├── 771_宝石与石头 ├── 771_numJewelsInStones.go ├── 771_numJewelsInStones_test.go └── request.txt ├── 7_reverse ├── 7_reverse.go ├── 7_reverse_test.go └── request.txt ├── 832_翻转图像 ├── 832_flipAndInvertImage.go ├── 832_flipAndInvertImage_test.go └── request.txt ├── 842_将数组拆分成斐波那契序列<未完成> ├── 842_splitIntoFibonacci.go ├── 842_splitIntoFibonacci_test.go └── request.txt ├── 8_字符串转换整数 ├── 8_myAtoi.go ├── 8_myAtoi_test.go └── request.txt ├── 9_回文数 ├── 9_isPalindrome.go ├── 9_isPalindrome_test.go └── request.txt ├── LCP1_猜数字 ├── 1_game.go ├── 1_game_test.go └── request.txt ├── LICENSE ├── README.md ├── go.mod └── vscode ├── 1.两数之和.go ├── 18.四数之和.go ├── 2.两数相加.go ├── 2.两数相加_test.go ├── 27.移除元素.go └── common.go /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/* 2 | -------------------------------------------------------------------------------- /1004_最大连续1的个数III/1004_longestOnes.go: -------------------------------------------------------------------------------- 1 | package longestOnes 2 | 3 | func longestOnes(A []int, K int) int { 4 | i, j, ret := 0, 0, 0 5 | 6 | for j < len(A) { 7 | if A[j] == 1 { 8 | j++ 9 | } else { 10 | if K == 0 { // 没有容量了 11 | if A[i] == 0 { //排除尾部 12 | K++ 13 | } 14 | i++ 15 | } else { 16 | K-- 17 | j++ 18 | } 19 | } 20 | 21 | if ret < j-i { 22 | ret = j - i 23 | } 24 | } 25 | 26 | return ret 27 | } 28 | -------------------------------------------------------------------------------- /1004_最大连续1的个数III/1004_longestOnes_test.go: -------------------------------------------------------------------------------- 1 | package longestOnes 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestLongestOnes(t *testing.T) { 9 | 10 | assert.Equal(t, 6, longestOnes([]int{1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0}, 2)) 11 | assert.Equal(t, 10, longestOnes([]int{0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1}, 3)) 12 | 13 | } 14 | -------------------------------------------------------------------------------- /1004_最大连续1的个数III/request.txt: -------------------------------------------------------------------------------- 1 | 1004. 最大连续1的个数 III 2 | 3 | 给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。 4 | 5 | 返回仅包含 1 的最长（连续）子数组的长度。 6 | 7 |   8 | 9 | 示例 1： 10 | 11 | 输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2 12 | 输出：6 13 | 解释： 14 | [1,1,1,0,0,1,1,1,1,1,1] 15 | 粗体数字从 0 翻转到 1，最长的子数组长度为 6。 16 | 示例 2： 17 | 18 | 输入：A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3 19 | 输出：10 20 | 解释： 21 | [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1] 22 | 粗体数字从 0 翻转到 1，最长的子数组长度为 10。 23 |   24 | 25 | 提示： 26 | 27 | 1 <= A.length <= 20000 28 | 0 <= K <= A.length 29 | A[i] 为 0 或 1  30 | 31 | 来源：力扣（LeetCode） 32 | 链接：https://leetcode-cn.com/problems/max-consecutive-ones-iii 33 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /1004_最大连续1的个数III/result.txt: -------------------------------------------------------------------------------- 1 | 1004. 最大连续1的个数 III 2 | 3 | 想象有条这样的贪吃蛇：它的肚子的容量为K，每吃掉一块食物（1代表食物），肚子的容量不变大也不变小，每吃掉一块石头（0代表石头，肚子的容量变小），不管是吃掉食物还是石头，身长都会增加1。 4 | 每当贪吃蛇无法再吃掉任何东西的时候，就无法再进食了，它必须等待他的肚子容量增加了才能继续吃，每排出来一块石头（0代表石头），肚子的容量又恢复了一格。 5 | 只要肚子不空，那么就一直吃，直到没得吃了为止。 6 | 因此我们可以定义贪吃蛇的头部为：j,尾部为i,肚子的容量为left,最大长度为res 7 | 8 | -------------------------------------------------------------------------------- /101_对称二叉树/101_isSymmetric.go: -------------------------------------------------------------------------------- 1 | package isSymmetric 2 | 3 | //Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func isSymmetric(root *TreeNode) bool { 11 | return _isSymmetric(root, root) 12 | } 13 | 14 | func _isSymmetric(left, right *TreeNode) bool { 15 | if left == nil && right == nil { 16 | return true 17 | } 18 | if left != nil || right != nil { 19 | return false 20 | } 21 | 22 | return _isSymmetric(left.Left, right.Right) && _isSymmetric(right.Left, left.Right) && left.Val == right.Val 23 | 24 | } 25 | -------------------------------------------------------------------------------- /101_对称二叉树/request.txt: -------------------------------------------------------------------------------- 1 | 101. 对称二叉树 2 | 3 | 给定一个二叉树，检查它是否是镜像对称的。 4 | 5 | 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 6 | 7 | 1 8 | / \ 9 | 2 2 10 | / \ / \ 11 | 3 4 4 3 12 | 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 13 | 14 | 1 15 | / \ 16 | 2 2 17 | \ \ 18 | 3 3 19 | 说明: 20 | 21 | 如果你可以运用递归和迭代两种方法解决这个问题，会很加分。 22 | 23 | 24 | 25 | 来源：力扣（LeetCode） 26 | 链接：https://leetcode-cn.com/problems/symmetric-tree 27 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /1025_除数博弈/1025_divisorGame.go: -------------------------------------------------------------------------------- 1 | package divisorGame 2 | 3 | func divisorGame(N int) bool { 4 | return N%2 == 0 5 | } 6 | -------------------------------------------------------------------------------- /1025_除数博弈/request.txt: -------------------------------------------------------------------------------- 1 | 1025. 除数博弈 2 | 3 | 爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。 4 | 5 | 最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作： 6 | 7 | 选出任一 x，满足 0 < x < N 且 N % x == 0 。 8 | 用 N - x 替换黑板上的数字 N 。 9 | 如果玩家无法执行这些操作，就会输掉游戏。 10 | 11 | 只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。 12 | 13 |   14 | 15 | 示例 1： 16 | 17 | 输入：2 18 | 输出：true 19 | 解释：爱丽丝选择 1，鲍勃无法进行操作。 20 | 示例 2： 21 | 22 | 输入：3 23 | 输出：false 24 | 解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。 25 |   26 | 27 | 提示： 28 | 29 | 1 <= N <= 1000 30 | 31 | 来源：力扣（LeetCode） 32 | 链接：https://leetcode-cn.com/problems/divisor-game 33 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /1025_除数博弈/result.txt: -------------------------------------------------------------------------------- 1 | 题目解析 2 | 对于这种博弈类的题目，如果没有思路的话我们不妨多举几个例子，尝试着从中找寻规律。 3 | 4 | 假设 N = 1，爱丽丝没得选择，直接失败，即 鲍勃获胜； 5 | 假设 N = 2，爱丽丝有选择，她可以选择 x = 1，鲍勃面对的就是 N = 2 - 1 = 1，无法操作，爱丽丝获胜； 6 | 假设 N = 3，爱丽丝只能选择 x = 1，因为选 x = 2 不满足 3 % 2 = 0，鲍勃面对的就是 N = 3 - 1 = 2，参考上面 N = 2 的情形，此时鲍勃为 N = 2 的先手，鲍勃获胜； 7 | 假设 N = 4，爱丽丝可以选择 x = 1 来使鲍勃遇到 N = 3 的情况，爱丽丝获胜； 8 | 貌似有个规律：N 为奇数时， 鲍勃获胜；N 为偶数时， 爱丽丝获胜。 9 | 10 | 是这样吗？ 11 | 12 | 是的。 13 | 14 | 事实上，无论 N 为多大，最终都是在 N = 2 这个临界点结束的。谁最后面对的是 N = 2 的情形，谁就能获胜（这句话不太理解的话，仔细看看 N = 2、N = 3 这两种情形）。 15 | 16 | 接下来，我们得知道一个数学小知识：奇数的因子（约数）只能是奇数，偶数的因子（约数）可以是奇数或偶数。 17 | 18 | 千万不要忽略 1 也是因子！ 19 | 20 | 爱丽丝是游戏开始时的先手。 21 | 22 | 当她面对的 N 为偶数时，她 一定可以 选到一个 N 的奇数因子 x（比如 1 ），将 N - x 这个奇数传给鲍勃；用 N - x 替换黑板上的数字 N ，鲍勃面对的就是奇数 N，只能选择 N 的奇数因子 x，奇数 - 奇数 = 偶数，此时传给爱丽丝的又是偶数。这样轮换下去爱丽丝会遇到 N = 2 的情形，然后获胜； 23 | 当爱丽丝遇到的 N 是奇数时，只能传给鲍勃偶数或无法操作 (N = 1) ，无法获胜。 24 | -------------------------------------------------------------------------------- /10_正则表达式匹配/10_isMatch.go: -------------------------------------------------------------------------------- 1 | package isMath 2 | 3 | func isMatch(s string, p string) bool { 4 | return false 5 | } -------------------------------------------------------------------------------- /10_正则表达式匹配/10_isMatch_test.go: -------------------------------------------------------------------------------- 1 | package isMath 2 | 3 | 4 | import ( 5 | "testing" 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestReverse(t *testing.T) { 10 | assert.Equal(t, false, isMatch("aa", "a")) 11 | assert.Equal(t, true, isMatch("aa", "a.")) 12 | assert.Equal(t, true, isMatch("aa", "a*")) 13 | 14 | assert.Equal(t, true, isMatch("ab", ".*")) 15 | 16 | } -------------------------------------------------------------------------------- /10_正则表达式匹配/request.txt: -------------------------------------------------------------------------------- 1 | 10. 正则表达式匹配 2 | 3 | 给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。 4 | 5 | '.' 匹配任意单个字符 6 | '*' 匹配零个或多个前面的那一个元素 7 | 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。 8 | 9 | 说明: 10 | 11 | s 可能为空，且只包含从 a-z 的小写字母。 12 | p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。 13 | 示例 1: 14 | 15 | 输入: 16 | s = "aa" 17 | p = "a" 18 | 输出: false 19 | 解释: "a" 无法匹配 "aa" 整个字符串。 20 | 示例 2: 21 | 22 | 输入: 23 | s = "aa" 24 | p = "a*" 25 | 输出: true 26 | 解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。 27 | 示例 3: 28 | 29 | 输入: 30 | s = "ab" 31 | p = ".*" 32 | 输出: true 33 | 解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。 34 | 示例 4: 35 | 36 | 输入: 37 | s = "aab" 38 | p = "c*a*b" 39 | 输出: true 40 | 解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。 41 | 示例 5: 42 | 43 | 输入: 44 | s = "mississippi" 45 | p = "mis*is*p*." 46 | 输出: false 47 | 48 | 来源：力扣（LeetCode） 49 | 链接：https://leetcode-cn.com/problems/regular-expression-matching 50 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /1108_IP地址无效化/1108_defangIPaddr.go: -------------------------------------------------------------------------------- 1 | package defangIPaddr 2 | 3 | import "strings" 4 | 5 | func defangIPaddr(address string) string { 6 | return strings.Replace(address, ".", "[.]", -1) 7 | } 8 | -------------------------------------------------------------------------------- /1108_IP地址无效化/1108_defangIPaddr_test.go: -------------------------------------------------------------------------------- 1 | package defangIPaddr 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestDefangIPaddr(t *testing.T) { 9 | assert.Equal(t, "1[.]1[.]1[.]1", defangIPaddr("1.1.1.1")) 10 | assert.Equal(t, "255[.]100[.]50[.]0", defangIPaddr("255.100.50.0")) 11 | } 12 | -------------------------------------------------------------------------------- /1108_IP地址无效化/request.txt: -------------------------------------------------------------------------------- 1 | 1108. IP 地址无效化 2 | 3 | 给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。 4 | 5 | 所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。 6 | 7 |   8 | 9 | 示例 1： 10 | 11 | 输入：address = "1.1.1.1" 12 | 输出："1[.]1[.]1[.]1" 13 | 示例 2： 14 | 15 | 输入：address = "255.100.50.0" 16 | 输出："255[.]100[.]50[.]0" 17 |   18 | 19 | 提示： 20 | 21 | 给出的 address 是一个有效的 IPv4 地址 22 | 23 | 来源：力扣（LeetCode） 24 | 链接：https://leetcode-cn.com/problems/defanging-an-ip-address 25 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /118_杨辉三角/118_generat_test.go: -------------------------------------------------------------------------------- 1 | package generate 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestGenerate(t *testing.T) { 8 | generate(5) 9 | } 10 | -------------------------------------------------------------------------------- /118_杨辉三角/118_generate.go: -------------------------------------------------------------------------------- 1 | package generate 2 | 3 | // 动态规划 4 | func generate(numRows int) [][]int { 5 | ret := make([][]int, 0) 6 | ret = append(ret, []int{1}) 7 | 8 | if numRows == 0 { 9 | return [][]int{} 10 | } else if numRows == 1 { 11 | return ret 12 | } 13 | ret = append(ret, []int{1, 1}) 14 | 15 | if numRows == 2 { 16 | return ret 17 | } 18 | 19 | for i := 2; i < numRows; i++ { 20 | for j := 0; j <= i; j++ { 21 | if j == 0 { 22 | // 第一个元素为1 23 | ret = append(ret, []int{1}) 24 | 25 | } else if i == j { 26 | // 最后一个元素为1 27 | ret[i] = append(ret[i], 1) 28 | 29 | } else { 30 | ret[i] = append(ret[i], ret[i-1][j-1]+ret[i-1][j]) 31 | 32 | } 33 | } 34 | } 35 | 36 | return ret 37 | } 38 | -------------------------------------------------------------------------------- /118_杨辉三角/request.txt: -------------------------------------------------------------------------------- 1 | 118. 杨辉三角 2 | 3 | 给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。 4 | 5 | 6 | 7 | 在杨辉三角中，每个数是它左上方和右上方的数的和。 8 | 9 | 示例: 10 | 11 | 输入: 5 12 | 输出: 13 | [ 14 | [1], 15 | [1,1], 16 | [1,2,1], 17 | [1,3,3,1], 18 | [1,4,6,4,1] 19 | ] 20 | 21 | 22 | 来源：力扣（LeetCode） 23 | 链接：https://leetcode-cn.com/problems/pascals-triangle 24 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /11_盛最多水的容器/11_maxArea.go: -------------------------------------------------------------------------------- 1 | package maxArea 2 | 3 | /* 4 | 官方解题 5 | 双指针法 6 | 7 | 这种方法背后的思路在于，两线段之间形成的区域总是会受到其中较短那条长度的限制。此外，两线段距离越远，得到的面积就越大。 8 | 9 | 我们在由线段长度构成的数组中使用两个指针，一个放在开始，一个置于末尾。 此外，我们会使用变量 maxareamaxarea 来持续存储到目前为止所获得的最大面积。 10 | 在每一步中，我们会找出指针所指向的两条线段形成的区域，更新 maxareamaxarea，并将指向较短线段的指针向较长线段那端移动一步。 11 | 12 | */ 13 | 14 | func Min(x, y int) int { 15 | if x < y { 16 | return x 17 | } 18 | return y 19 | } 20 | 21 | func maxArea(height []int) int { 22 | var maxA int 23 | i, j := 0, len(height)-1 24 | for i < j { 25 | area := (j - i) * Min(height[i], height[j]) 26 | if area > maxA { 27 | maxA = area 28 | } 29 | if height[i] < height[j] { 30 | i ++ 31 | } else { 32 | j -- 33 | } 34 | } 35 | 36 | return maxA 37 | } 38 | -------------------------------------------------------------------------------- /11_盛最多水的容器/11_maxArea_test.go: -------------------------------------------------------------------------------- 1 | package maxArea 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMaxArea(t *testing.T) { 9 | assert.Equal(t, 49, maxArea([]int{1, 8, 6, 2, 5, 4, 8, 3, 7})) 10 | } 11 | -------------------------------------------------------------------------------- /11_盛最多水的容器/question_11.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huangxingx/leetcode/f33a4fff608f62fc75aed02b7d3b1cded158c1da/11_盛最多水的容器/question_11.jpg -------------------------------------------------------------------------------- /11_盛最多水的容器/request.txt: -------------------------------------------------------------------------------- 1 | 11. 盛最多水的容器 2 | 3 | 给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 4 | 5 | 说明：你不能倾斜容器，且 n 的值至少为 2。 6 | 7 | 8 | 9 | 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 10 | 11 |   12 | 13 | 示例: 14 | 15 | 输入: [1,8,6,2,5,4,8,3,7] 16 | 输出: 49 17 | 18 | 来源：力扣（LeetCode） 19 | 链接：https://leetcode-cn.com/problems/container-with-most-water 20 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /121_买卖股票的最佳时机/121_maxProfit.go: -------------------------------------------------------------------------------- 1 | package maxProfit 2 | 3 | func maxProfit(prices []int) int { 4 | if len(prices) == 0 { 5 | return 0 6 | } 7 | 8 | minV := prices[0] 9 | maxV := 0 10 | 11 | for i := 0; i < len(prices); i++ { 12 | if prices[i] < minV{ 13 | minV = prices[i] 14 | } else if prices[i]- minV > maxV{ 15 | maxV = prices[i]- minV 16 | } 17 | } 18 | 19 | return maxV 20 | } 21 | -------------------------------------------------------------------------------- /121_买卖股票的最佳时机/121_maxProfit_test.go: -------------------------------------------------------------------------------- 1 | package maxProfit 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMaxProfit(t *testing.T) { 9 | assert.Equal(t, 5, maxProfit([]int{7,1,5,3,6,4})) 10 | } 11 | -------------------------------------------------------------------------------- /121_买卖股票的最佳时机/request.txt: -------------------------------------------------------------------------------- 1 | 121. 买卖股票的最佳时机 2 | 3 | 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 4 | 5 | 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 6 | 7 | 注意你不能在买入股票前卖出股票。 8 | 9 | 示例 1: 10 | 11 | 输入: [7,1,5,3,6,4] 12 | 输出: 5 13 | 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 14 | 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 15 | 示例 2: 16 | 17 | 输入: [7,6,4,3,1] 18 | 输出: 0 19 | 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 20 | 21 | 来源：力扣（LeetCode） 22 | 链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock 23 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /122_买卖股票的最佳时机2/122_maxProfit.go: -------------------------------------------------------------------------------- 1 | package maxProfit2 2 | 3 | func maxProfit(prices []int) int { 4 | ret := 0 5 | for i := 1; i < len(prices); i++ { 6 | 7 | if prices[i] > prices[i-1] { 8 | ret += prices[i] - prices[i-1] 9 | } 10 | } 11 | return ret 12 | } 13 | -------------------------------------------------------------------------------- /122_买卖股票的最佳时机2/122_maxProfit_test.go: -------------------------------------------------------------------------------- 1 | package maxProfit2 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMaxProfit(t *testing.T) { 9 | assert.Equal(t, 7, maxProfit([]int{7,1,5,3,6,4})) 10 | assert.Equal(t, 4, maxProfit([]int{1,2,3,4,5})) 11 | } 12 | -------------------------------------------------------------------------------- /122_买卖股票的最佳时机2/request.txt: -------------------------------------------------------------------------------- 1 | 122. 买卖股票的最佳时机2 2 | 3 | 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 4 | 5 | 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 6 | 7 | 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 8 | 9 | 示例 1: 10 | 11 | 输入: [7,1,5,3,6,4] 12 | 输出: 7 13 | 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 14 |   随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 15 | 示例 2: 16 | 17 | 输入: [1,2,3,4,5] 18 | 输出: 4 19 | 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 20 |   注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 21 |   因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 22 | 示例 3: 23 | 24 | 输入: [7,6,4,3,1] 25 | 输出: 0 26 | 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 27 | 28 | 来源：力扣（LeetCode） 29 | 链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii 30 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /12_整数转罗马数字/12_intToRoman.go: -------------------------------------------------------------------------------- 1 | package intToRoman 2 | 3 | // 整数转罗马数字 4 | func intToRoman(num int) string { 5 | numList := []int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1} 6 | strList := []string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"} 7 | 8 | ret := "" 9 | for num > 0 { 10 | for i := 0; i < len(numList); i++ { 11 | if num/numList[i] > 0 { 12 | for j := 0; j < num/numList[i]; j++ { 13 | ret += strList[i] 14 | } 15 | num %= numList[i] 16 | } 17 | } 18 | } 19 | 20 | return ret 21 | } 22 | -------------------------------------------------------------------------------- /12_整数转罗马数字/12_intToRoman_test.go: -------------------------------------------------------------------------------- 1 | package intToRoman 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestIntToRoman(t *testing.T) { 9 | assert.Equal(t, "III", intToRoman(3)) 10 | assert.Equal(t, "IV", intToRoman(4)) 11 | assert.Equal(t, "IX", intToRoman(9)) 12 | assert.Equal(t, "LVIII", intToRoman(58)) 13 | assert.Equal(t, "MCMXCIV", intToRoman(1994)) 14 | } 15 | -------------------------------------------------------------------------------- /12_整数转罗马数字/request.txt: -------------------------------------------------------------------------------- 1 | 12. 整数转罗马数字 2 | 3 | 罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。 4 | 5 | 字符 数值 6 | I 1 7 | V 5 8 | X 10 9 | L 50 10 | C 100 11 | D 500 12 | M 1000 13 | 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。 14 | 15 | 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况： 16 | 17 | I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 18 | X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。  19 | C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 20 | 给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。 21 | 22 | 示例 1: 23 | 24 | 输入: 3 25 | 输出: "III" 26 | 示例 2: 27 | 28 | 输入: 4 29 | 输出: "IV" 30 | 示例 3: 31 | 32 | 输入: 9 33 | 输出: "IX" 34 | 示例 4: 35 | 36 | 输入: 58 37 | 输出: "LVIII" 38 | 解释: L = 50, V = 5, III = 3. 39 | 示例 5: 40 | 41 | 输入: 1994 42 | 输出: "MCMXCIV" 43 | 解释: M = 1000, CM = 900, XC = 90, IV = 4. 44 | 45 | 来源：力扣（LeetCode） 46 | 链接：https://leetcode-cn.com/problems/integer-to-roman 47 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /136_只出现一次的数字/136_singleNumber.go: -------------------------------------------------------------------------------- 1 | package singleNumber 2 | 3 | // 位操作 4 | func singleNumber(nums []int) int { 5 | ret := 0 6 | for _, value := range nums { 7 | ret ^= value 8 | } 9 | return ret 10 | } 11 | 12 | /* 13 | 复杂度分析 14 | 15 | 时间复杂度： O(n) 。我们只需要将 nums 中的元素遍历一遍，所以时间复杂度就是 nums 中的元素个数。 16 | 空间复杂度：O(1)。 17 | 18 | */ 19 | -------------------------------------------------------------------------------- /136_只出现一次的数字/136_singleNumber_test.go: -------------------------------------------------------------------------------- 1 | package singleNumber 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestSingleNumber(t *testing.T) { 9 | assert.Equal(t, 1, singleNumber([]int{2, 2, 1})) 10 | assert.Equal(t, 4, singleNumber([]int{4,1,2,1,2})) 11 | 12 | } 13 | -------------------------------------------------------------------------------- /136_只出现一次的数字/request.txt: -------------------------------------------------------------------------------- 1 | 136. 只出现一次的数字 2 | 3 | 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 4 | 5 | 说明： 6 | 7 | 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 8 | 9 | 示例 1: 10 | 11 | 输入: [2,2,1] 12 | 输出: 1 13 | 示例 2: 14 | 15 | 输入: [4,1,2,1,2] 16 | 输出: 4 17 | 18 | 来源：力扣（LeetCode） 19 | 链接：https://leetcode-cn.com/problems/single-number 20 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /136_只出现一次的数字/result.txt: -------------------------------------------------------------------------------- 1 | 方法 1：列表操作 2 | 算法 3 | 4 | 遍历 \text{nums}nums 中的每一个元素 5 | 如果某个 \text{nums}nums 中的数字是新出现的，则将它添加到列表中 6 | 如果某个数字已经在列表中，删除它 7 | 8 | 9 | 方法 2：哈希表 10 | 算法 11 | 12 | 我们用哈希表避免每次查找元素是否存在需要的 O(n)O(n) 时间。 13 | 14 | 遍历 \text{nums}nums 中的每一个元素 15 | 查找 hash\_tablehash_table 中是否有当前元素的键 16 | 如果没有，将当前元素作为键插入 hash\_tablehash_table 17 | 最后， hash\_tablehash_table 中仅有一个元素，用 popitem 获得它 18 | 19 | 20 | 方法 3：数学 21 | 概念 22 | 23 | 2 * (a + b + c) - (a + a + b + b + c) = c2∗(a+b+c)−(a+a+b+b+c)=c 24 | 25 | 26 | 方法 4：位操作 27 | 概念 28 | 29 | 如果我们对 0 和二进制位做 XOR 运算，得到的仍然是这个二进制位 30 | a ^ 0 = a⊕0=a 31 | 如果我们对相同的二进制位做 XOR 运算，返回的结果是 0 32 | a ^ a = a⊕a=0 33 | XOR 满足交换律和结合律 34 | a ^ b ^ a = (a ^ a) ^ b = 0 ^ b = b 35 | 所以我们只需要将所有的数进行 XOR 操作，得到那个唯一的数字。 36 | -------------------------------------------------------------------------------- /14_最长公共前缀/14_longestCommonPrefix.go: -------------------------------------------------------------------------------- 1 | package longestCommonPrefix 2 | 3 | func longestCommonPrefix(strs []string) string { 4 | if len(strs) == 0 { 5 | return "" 6 | } 7 | 8 | if len(strs) == 1 { 9 | return strs[0] 10 | } 11 | flag := true 12 | ret := make([]byte, 0) 13 | for i := 0; i < len(strs[0]); i++ { 14 | for _, str := range strs[1:] { 15 | if i >= len(str) { 16 | flag = false 17 | break 18 | } 19 | 20 | if strs[0][i] != str[i] { 21 | flag = false 22 | break 23 | } 24 | } 25 | if !flag { 26 | break 27 | } 28 | 29 | ret = append(ret, strs[0][i]) 30 | 31 | } 32 | 33 | return string(ret) 34 | } 35 | -------------------------------------------------------------------------------- /14_最长公共前缀/14_longestCommonPrefix_test.go: -------------------------------------------------------------------------------- 1 | package longestCommonPrefix 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestLongestCommonPrefix(t *testing.T) { 9 | assert.Equal(t, "fl", longestCommonPrefix([]string{"flower", "flow", "flight"})) 10 | assert.Equal(t, "", longestCommonPrefix([]string{"dog", "racecar", "car"})) 11 | } 12 | -------------------------------------------------------------------------------- /14_最长公共前缀/request.txt: -------------------------------------------------------------------------------- 1 | 14. 最长公共前缀 2 | 3 | 编写一个函数来查找字符串数组中的最长公共前缀。 4 | 5 | 如果不存在公共前缀，返回空字符串 ""。 6 | 7 | 示例 1: 8 | 9 | 输入: ["flower","flow","flight"] 10 | 输出: "fl" 11 | 示例 2: 12 | 13 | 输入: ["dog","racecar","car"] 14 | 输出: "" 15 | 解释: 输入不存在公共前缀。 16 | 说明: 17 | 18 | 所有输入只包含小写字母 a-z 。 19 | 20 | 来源：力扣（LeetCode） 21 | 链接：https://leetcode-cn.com/problems/longest-common-prefix 22 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /15_threeSum/15_threeSum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | /* 9 | 数组排序 10 | 两层循环, 外层循环遍历整个数组, 内层循环通过两个游标获取首尾数据 11 | if sum < 0 , 递增左边的游标 12 | if sum > 0 , 递增右边的游标 13 | else append 三个数的数组 14 | 15 | 注意数据的去重处理 16 | */ 17 | 18 | func threeSum(nums []int) [][]int { 19 | resultList := make([][]int, 0) 20 | 21 | sort.Ints(nums) 22 | 23 | for k := 0; k < len(nums)-1; k++ { 24 | if nums[k] > 0 { 25 | break 26 | } 27 | 28 | if k > 0 && nums[k] == nums[k-1] { 29 | continue 30 | } 31 | i, j := k+1, len(nums)-1 32 | for i < j { 33 | s := nums[i] + nums[j] + nums[k] 34 | if s < 0 { 35 | i += 1 36 | for nums[i] == nums[i-1] && (i < j) { 37 | i += 1 38 | } 39 | } else if s > 0 { 40 | j -= 1 41 | for nums[j] == nums[j+1] && (i < j) { 42 | j -= 1 43 | } 44 | } else { 45 | 46 | resultList = append(resultList, []int{nums[k], nums[i], nums[j]}) 47 | i += 1 48 | j -= 1 49 | 50 | for nums[j] == nums[j+1] && (i < j) { 51 | j -= 1 52 | } 53 | for nums[i] == nums[i-1] && (i < j) { 54 | i += 1 55 | } 56 | } 57 | 58 | } 59 | 60 | } 61 | 62 | return resultList 63 | } 64 | 65 | func main() { 66 | nums := []int{-1, 0, 1, 2, -1, -4} 67 | fmt.Println(threeSum(nums)) 68 | } 69 | -------------------------------------------------------------------------------- /15_threeSum/request.txt: -------------------------------------------------------------------------------- 1 | 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 2 | 3 | 注意：答案中不可以包含重复的三元组。 4 | 5 | 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 6 | 7 | 满足要求的三元组集合为： 8 | [ 9 | [-1, 0, 1], 10 | [-1, -1, 2] 11 | ] 12 | 13 | 来源：力扣（LeetCode） 14 | 链接：https://leetcode-cn.com/problems/3sum 15 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /17_电话号码的字母组合/17_letterCombinations.go: -------------------------------------------------------------------------------- 1 | package letterCombinations 2 | 3 | var resultList = make([]string, 0) 4 | var flagMap = map[string]string{ 5 | "2": "abc", 6 | "3": "def", 7 | "4": "ghi", 8 | "5": "jkl", 9 | "6": "mno", 10 | "7": "pqrs", 11 | "8": "tuv", 12 | "9": "wxyz", 13 | } 14 | 15 | func letterCombinations(digits string) []string { 16 | 17 | if len(digits) != 0 { 18 | backtrack("", digits) 19 | } 20 | ret := resultList[:] 21 | resultList = make([]string, 0) 22 | return ret 23 | 24 | } 25 | 26 | func backtrack(re, nextString string) { 27 | if len(nextString) == 0 { 28 | resultList = append(resultList, re) 29 | return 30 | } 31 | 32 | currentNumber := string(nextString[0]) 33 | currentString := flagMap[currentNumber] 34 | for _, value := range currentString { 35 | backtrack(re+string(value), nextString[1:]) 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /17_电话号码的字母组合/17_letterCombinations_test.go: -------------------------------------------------------------------------------- 1 | package letterCombinations 2 | 3 | import ( 4 | "testing" 5 | "fmt" 6 | ) 7 | 8 | func TestLetterCombinations(t *testing.T) { 9 | //fmt.Println(letterCombinations("23")) 10 | fmt.Println(letterCombinations("")) 11 | } -------------------------------------------------------------------------------- /17_电话号码的字母组合/17_telephone_keypad.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huangxingx/leetcode/f33a4fff608f62fc75aed02b7d3b1cded158c1da/17_电话号码的字母组合/17_telephone_keypad.png -------------------------------------------------------------------------------- /17_电话号码的字母组合/request.txt: -------------------------------------------------------------------------------- 1 | 17. 电话号码的字母组合 2 | 3 | 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 4 | 5 | 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 6 | 7 | 8 | 9 | 示例: 10 | 11 | 输入："23" 12 | 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 13 | 说明: 14 | 尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。 15 | 16 | 来源：力扣（LeetCode） 17 | 链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number 18 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /17_电话号码的字母组合/result.txt: -------------------------------------------------------------------------------- 1 | 方法：回溯 2 | 回溯是一种通过穷举所有可能情况来找到所有解的算法。如果一个候选解最后被发现并不是可行解，回溯算法会舍弃它，并在前面的一些步骤做出一些修改，并重新尝试找到可行解。 3 | 4 | 给出如下回溯函数 backtrack(combination, next_digits) ，它将一个目前已经产生的组合 combination 和接下来准备要输入的数字 next_digits 作为参数。 5 | 6 | 如果没有更多的数字需要被输入，那意味着当前的组合已经产生好了。 7 | 如果还有数字需要被输入： 8 | 遍历下一个数字所对应的所有映射的字母。 9 | 将当前的字母添加到组合最后，也就是 combination = combination + letter 。 10 | 重复这个过程，输入剩下的数字： backtrack(combination + letter, next_digits[1:]) 。 11 | 12 | 13 | -------------------------------------------------------------------------------- /198_打家劫舍/198_rob.go: -------------------------------------------------------------------------------- 1 | package rob 2 | 3 | /* 4 | 动态规划 5 | 最大金额: n[i] = n[i-2] + n[i] 6 | */ 7 | 8 | func max(x, y int) int { 9 | if x > y { 10 | return x 11 | } 12 | return y 13 | } 14 | 15 | // 打家劫舍 16 | func rob(nums []int) int { 17 | if len(nums) == 0 { 18 | return 0 19 | } else if len(nums) == 1 { 20 | return nums[0] 21 | } else if len(nums) == 2 { 22 | return max(nums[0], nums[1]) 23 | } 24 | 25 | moneys := make([]int, len(nums)) 26 | moneys[0] = nums[0] 27 | moneys[1] = nums[1] 28 | maxMoney := max(moneys[0], moneys[1]) 29 | 30 | for i := 2; i < len(nums); i++ { 31 | 32 | temp := moneys[i-2] 33 | if i-3 >= 0 { 34 | temp = max(moneys[i-2], moneys[i-3]) 35 | } 36 | moneys[i] = temp + nums[i] 37 | 38 | maxMoney = max(maxMoney, moneys[i]) 39 | } 40 | 41 | return maxMoney 42 | } 43 | -------------------------------------------------------------------------------- /198_打家劫舍/198_rob_test.go: -------------------------------------------------------------------------------- 1 | package rob 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestRob(t *testing.T) { 9 | //assert.Equal(t, 4, rob([]int{1, 2, 3, 1})) 10 | assert.Equal(t, 4, rob([]int{2, 1, 1, 2})) 11 | } 12 | -------------------------------------------------------------------------------- /198_打家劫舍/request.txt: -------------------------------------------------------------------------------- 1 | 198. 打家劫舍 2 | 3 | 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 4 | 5 | 给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。 6 | 7 | 示例 1: 8 | 9 | 输入: [1,2,3,1] 10 | 输出: 4 11 | 解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 12 |   偷窃到的最高金额 = 1 + 3 = 4 。 13 | 示例 2: 14 | 15 | 输入: [2,7,9,3,1] 16 | 输出: 12 17 | 解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 18 |   偷窃到的最高金额 = 2 + 9 + 1 = 12 19 | 20 | 来源：力扣（LeetCode） 21 | 链接：https://leetcode-cn.com/problems/house-robber 22 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /1_twoSum/1_twoSum.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /* 6 | 利用Map减少数组的遍历 7 | */ 8 | 9 | func twoSum(nums []int, target int) []int { 10 | numMap := make(map[int]int) 11 | for i := 0; i < len(nums); i++ { 12 | numMap[nums[i]] = i 13 | } 14 | 15 | for j := 0; j < len(nums); j++ { 16 | num := nums[j] 17 | result := target - num 18 | _, ok := numMap[result] 19 | if ok && numMap[result] != j { 20 | return []int{j, numMap[result]} 21 | } 22 | } 23 | 24 | return []int{0, 0} 25 | 26 | } 27 | 28 | func main() { 29 | fmt.Println(twoSum([]int{3, 2, 4}, 6)) 30 | } 31 | -------------------------------------------------------------------------------- /1_twoSum/request.txt: -------------------------------------------------------------------------------- 1 | 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 2 | 3 | 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 4 | 5 | 示例: 6 | 7 | 给定 nums = [2, 7, 11, 15], target = 9 8 | 9 | 因为 nums[0] + nums[1] = 2 + 7 = 9 10 | 所以返回 [0, 1] 11 | 12 | 来源：力扣（LeetCode） 13 | 链接：https://leetcode-cn.com/problems/two-sum 14 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /202_快乐数/202_isHappy.go: -------------------------------------------------------------------------------- 1 | package isHappy 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | func isHappy(n int) bool { 8 | count := 0 9 | for { 10 | ret := 0.0 11 | for n > 0 { 12 | x := n % 10 13 | ret += math.Pow(float64(x), float64(2)) 14 | n /= 10 15 | } 16 | 17 | if ret == float64(1) { 18 | return true 19 | } 20 | n = int(ret) 21 | 22 | count++ 23 | if count > 1000 { 24 | return false 25 | } 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /202_快乐数/202_isHappy_test.go: -------------------------------------------------------------------------------- 1 | package isHappy 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestIsHappy(t *testing.T) { 9 | assert.Equal(t, true, isHappy(19)) 10 | 11 | } 12 | -------------------------------------------------------------------------------- /202_快乐数/request.txt: -------------------------------------------------------------------------------- 1 | 202. 快乐数 2 | 3 | 编写一个算法来判断一个数是不是“快乐数”。 4 | 5 | 一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。 6 | 7 | 示例:  8 | 9 | 输入: 19 10 | 输出: true 11 | 解释: 12 | 12 + 92 = 82 13 | 82 + 22 = 68 14 | 62 + 82 = 100 15 | 12 + 02 + 02 = 1 16 | 17 | 来源：力扣（LeetCode） 18 | 链接：https://leetcode-cn.com/problems/happy-number 19 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /20_有效的括号/20_isValid.go: -------------------------------------------------------------------------------- 1 | package isValid 2 | 3 | func isValid(s string) bool { 4 | flagMap := map[string]string{")": "(", "}": "{", "]": "[",} 5 | stactList := make([]string, 0) 6 | sLen := len(s) 7 | for i := 0; i < sLen; i++ { 8 | if si, ok := flagMap[string(s[i])]; len(stactList) > 0 && ok { 9 | if stactList[len(stactList)-1] != si { 10 | return false 11 | } else { 12 | // 如果匹配到一对的括号就出栈 13 | stactList = stactList[:len(stactList)-1] 14 | } 15 | } else { 16 | // 如果是正括号就入栈 17 | stactList = append(stactList, string(s[i])) 18 | } 19 | 20 | } 21 | 22 | return len(stactList) == 0 23 | 24 | } 25 | -------------------------------------------------------------------------------- /20_有效的括号/20_isValid_test.go: -------------------------------------------------------------------------------- 1 | package isValid 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestIsValid(t *testing.T) { 9 | assert.Equal(t, true, isValid("()")) 10 | assert.Equal(t, true, isValid("()[]{}")) 11 | assert.Equal(t, false, isValid("(]")) 12 | assert.Equal(t, false, isValid("([)]")) 13 | assert.Equal(t, true, isValid("{[]}")) 14 | assert.Equal(t, false, isValid("]")) 15 | assert.Equal(t, false, isValid("[])")) 16 | } 17 | -------------------------------------------------------------------------------- /20_有效的括号/request.txt: -------------------------------------------------------------------------------- 1 | 20. 有效的括号 2 | 3 | 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 4 | 5 | 有效字符串需满足： 6 | 7 | 左括号必须用相同类型的右括号闭合。 8 | 左括号必须以正确的顺序闭合。 9 | 注意空字符串可被认为是有效字符串。 10 | 11 | 示例 1: 12 | 13 | 输入: "()" 14 | 输出: true 15 | 示例 2: 16 | 17 | 输入: "()[]{}" 18 | 输出: true 19 | 示例 3: 20 | 21 | 输入: "(]" 22 | 输出: false 23 | 示例 4: 24 | 25 | 输入: "([)]" 26 | 输出: false 27 | 示例 5: 28 | 29 | 输入: "{[]}" 30 | 输出: true 31 | 32 | 来源：力扣（LeetCode） 33 | 链接：https://leetcode-cn.com/problems/valid-parentheses 34 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /226_翻转二叉树/226_invertTree.go: -------------------------------------------------------------------------------- 1 | package invertTree 2 | 3 | //Definition for a binary tree node. 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func invertTree(root *TreeNode) *TreeNode { 11 | if root != nil { 12 | tempNode := root.Left 13 | root.Left = root.Right 14 | root.Right = tempNode 15 | 16 | invertTree(root.Left) 17 | invertTree(root.Right) 18 | } else { 19 | return nil 20 | } 21 | 22 | return root 23 | } 24 | -------------------------------------------------------------------------------- /226_翻转二叉树/226_invertTree_test.go: -------------------------------------------------------------------------------- 1 | package invertTree 2 | -------------------------------------------------------------------------------- /226_翻转二叉树/request.txt: -------------------------------------------------------------------------------- 1 | 226. 翻转二叉树 2 | 3 | 翻转一棵二叉树。 4 | 5 | 示例： 6 | 7 | 输入： 8 | 9 | 4 10 | / \ 11 | 2 7 12 | / \ / \ 13 | 1 3 6 9 14 | 输出： 15 | 16 | 4 17 | / \ 18 | 7 2 19 | / \ / \ 20 | 9 6 3 1 21 | 22 | 来源：力扣（LeetCode） 23 | 链接：https://leetcode-cn.com/problems/invert-binary-tree 24 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /283_移动零/283_moveZeroes.go: -------------------------------------------------------------------------------- 1 | package moveZeroes 2 | 3 | // 移动零 4 | func moveZeroes(nums []int) { 5 | zeroeCount := 0 6 | for i, value := range nums { 7 | if value == 0 { 8 | zeroeCount ++ 9 | continue 10 | } 11 | if zeroeCount > 0 { 12 | nums[i], nums[i-zeroeCount] = nums[i-zeroeCount], nums[i] 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /283_移动零/283_moveZeroes_test.go: -------------------------------------------------------------------------------- 1 | package moveZeroes 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestMoveZeroes(t *testing.T) { 8 | moveZeroes([]int{0, 1, 0, 3, 12}) 9 | 10 | } 11 | -------------------------------------------------------------------------------- /283_移动零/request.txt: -------------------------------------------------------------------------------- 1 | 283. 移动零 2 | 3 | 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 4 | 5 | 示例: 6 | 7 | 输入: [0,1,0,3,12] 8 | 输出: [1,3,12,0,0] 9 | 说明: 10 | 11 | 必须在原数组上操作，不能拷贝额外的数组。 12 | 尽量减少操作次数。 13 | 14 | 15 | 来源：力扣（LeetCode） 16 | 链接：https://leetcode-cn.com/problems/move-zeroes 17 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /292_Nim游戏/292_canWinNim.go: -------------------------------------------------------------------------------- 1 | package canWinNim 2 | 3 | func canWinNim(n int) bool { 4 | return n%4 != 0 5 | } 6 | -------------------------------------------------------------------------------- /292_Nim游戏/292_canWinNim_test.go: -------------------------------------------------------------------------------- 1 | package canWinNim 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestCanWinNim(t *testing.T) { 9 | assert.Equal(t, false, canWinNim(4)) 10 | } 11 | -------------------------------------------------------------------------------- /292_Nim游戏/request.txt: -------------------------------------------------------------------------------- 1 | 292. Nim 游戏 2 | 3 | 你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。 4 | 5 | 你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。 6 | 7 | 示例: 8 | 9 | 输入: 4 10 | 输出: false 11 | 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛； 12 |   因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。 13 | 14 | 来源：力扣（LeetCode） 15 | 链接：https://leetcode-cn.com/problems/nim-game 16 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /2_addTwoNumbers/2_addTwoNumbers.go: -------------------------------------------------------------------------------- 1 | package add_two_numbers 2 | -------------------------------------------------------------------------------- /2_addTwoNumbers/2_addTwoNumbers_test.go: -------------------------------------------------------------------------------- 1 | package add_two_numbers 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestAddTwoNumbers(t *testing.T) { 8 | } 9 | -------------------------------------------------------------------------------- /2_addTwoNumbers/request.txt: -------------------------------------------------------------------------------- 1 | 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 2 | 3 | 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 4 | 5 | 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 6 | 7 | 示例： 8 | 9 | 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 10 | 输出：7 -> 0 -> 8 11 | 原因：342 + 465 = 807 12 | 13 | 来源：力扣（LeetCode） 14 | 链接：https://leetcode-cn.com/problems/add-two-numbers 15 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 16 | -------------------------------------------------------------------------------- /3_lengthOfLongestSubstring/3_lengthOfLongestSubstring.go: -------------------------------------------------------------------------------- 1 | package lengthOfLongestSubstring 2 | 3 | /* 4 | 遍历字符串通过map[字符串的byte]索引值 5 | 如果遍历的byte在map中存在,则通过获取到的重复byte的index+1 获取新数组,循环直到数组遍历完 6 | */ 7 | 8 | // 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 9 | func lengthOfLongestSubstring(s string) int { 10 | 11 | var tempMap map[byte]int 12 | var maxLength int 13 | var tempLength int 14 | sArray := []byte(s) 15 | var index int 16 | for { 17 | if index+1 > len(sArray) { 18 | break 19 | } 20 | 21 | tempMap = map[byte]int{} 22 | tempLength = 0 23 | 24 | for _, value := range sArray { 25 | index, ok := tempMap[value] 26 | if ok { 27 | break 28 | } 29 | tempMap[value] = index 30 | tempLength += 1 31 | if tempLength > maxLength { 32 | maxLength = tempLength 33 | } 34 | } 35 | sArray = sArray[index+1:] 36 | 37 | } 38 | 39 | return maxLength 40 | } 41 | -------------------------------------------------------------------------------- /3_lengthOfLongestSubstring/3_lengthOfLongestSubstring_test.go: -------------------------------------------------------------------------------- 1 | package lengthOfLongestSubstring 2 | 3 | import "testing" 4 | 5 | func TestLengthOfLongestSubstring(t *testing.T) { 6 | if lengthOfLongestSubstring("abcabcbb") != 3 { 7 | t.Error("abcabcbb err") 8 | } 9 | if lengthOfLongestSubstring("bbbbb") != 1 { 10 | t.Error("bbbbb err", lengthOfLongestSubstring("bbbbb")) 11 | } 12 | if lengthOfLongestSubstring("pwwkew") != 3 { 13 | t.Error("pwwkew err", lengthOfLongestSubstring("pwwkew")) 14 | } 15 | 16 | if lengthOfLongestSubstring("aab") != 2 { 17 | t.Error("aab err") 18 | } 19 | if lengthOfLongestSubstring("dvdf") != 3 { 20 | t.Error("dvdf err") 21 | } 22 | if lengthOfLongestSubstring(" ") != 1 { 23 | t.Error(" err", lengthOfLongestSubstring(" ")) 24 | } 25 | 26 | if lengthOfLongestSubstring("au") != 2 { 27 | t.Error("au err", lengthOfLongestSubstring("au")) 28 | } 29 | if lengthOfLongestSubstring("asjrgapa") != 6 { 30 | t.Error("asjrgapa err", lengthOfLongestSubstring("asjrgapa")) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /3_lengthOfLongestSubstring/request.txt: -------------------------------------------------------------------------------- 1 | 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 2 | 3 | 示例 1: 4 | 5 | 输入: "abcabcbb" 6 | 输出: 3 7 | 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。 8 | 示例 2: 9 | 10 | 输入: "bbbbb" 11 | 输出: 1 12 | 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。 13 | 示例 3: 14 | 15 | 输入: "pwwkew" 16 | 输出: 3 17 | 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 18 |   请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。 19 | 20 | 来源：力扣（LeetCode） 21 | 链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters 22 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /461_汉明距离/461_hammingDistance.go: -------------------------------------------------------------------------------- 1 | package hammingDistance 2 | 3 | import ( 4 | "strconv" 5 | ) 6 | 7 | // 汉明距离 8 | func hammingDistance(x int, y int) int { 9 | z := x ^ y 10 | 11 | zbin := strconv.FormatInt(int64(z), 2) 12 | sum := 0 13 | for _, value := range zbin { 14 | if "1" == string(value) { 15 | sum ++ 16 | } 17 | } 18 | 19 | return sum 20 | 21 | } 22 | -------------------------------------------------------------------------------- /461_汉明距离/461_hammingDistance_test.go: -------------------------------------------------------------------------------- 1 | package hammingDistance 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestReverse(t *testing.T) { 9 | assert.Equal(t, 2, hammingDistance(1, 4)) 10 | assert.Equal(t, 2, hammingDistance(2, 4)) 11 | } 12 | -------------------------------------------------------------------------------- /461_汉明距离/request.txt: -------------------------------------------------------------------------------- 1 | 461. 汉明距离 2 | 3 | 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。 4 | 5 | 给出两个整数 x 和 y，计算它们之间的汉明距离。 6 | 7 | 注意： 8 | 0 ≤ x, y < 231. 9 | 10 | 示例: 11 | 12 | 输入: x = 1, y = 4 13 | 14 | 输出: 2 15 | 16 | 解释: 17 | 1 (0 0 0 1) 18 | 4 (0 1 0 0) 19 | ↑ ↑ 20 | 21 | 上面的箭头指出了对应二进制位不同的位置。 22 | 23 | 来源：力扣（LeetCode） 24 | 链接：https://leetcode-cn.com/problems/hamming-distance 25 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /509_斐波那契数/509_fib.go: -------------------------------------------------------------------------------- 1 | package fib 2 | 3 | // 引入缓存 4 | var sMap = make(map[int]int) 5 | 6 | func fib(N int) int { 7 | 8 | if N <= 1 { 9 | return N 10 | } 11 | 12 | if r, ok := sMap[N]; ok { 13 | return r 14 | } 15 | ret := fib(N-1) + fib(N-2) 16 | sMap[N] = ret 17 | 18 | return ret 19 | } 20 | -------------------------------------------------------------------------------- /509_斐波那契数/509_fib_test.go: -------------------------------------------------------------------------------- 1 | package fib 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestFib(t *testing.T) { 9 | assert.Equal(t, 1, fib(1)) 10 | assert.Equal(t, 1, fib(2)) 11 | assert.Equal(t, 2, fib(3)) 12 | } 13 | -------------------------------------------------------------------------------- /509_斐波那契数/request.txt: -------------------------------------------------------------------------------- 1 | 509. 斐波那契数 2 | 3 | 斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： 4 | 5 | F(0) = 0,   F(1) = 1 6 | F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 7 | 给定 N，计算 F(N)。 8 | 9 |   10 | 11 | 示例 1： 12 | 13 | 输入：2 14 | 输出：1 15 | 解释：F(2) = F(1) + F(0) = 1 + 0 = 1. 16 | 示例 2： 17 | 18 | 输入：3 19 | 输出：2 20 | 解释：F(3) = F(2) + F(1) = 1 + 1 = 2. 21 | 示例 3： 22 | 23 | 输入：4 24 | 输出：3 25 | 解释：F(4) = F(3) + F(2) = 2 + 1 = 3. 26 |   27 | 28 | 提示： 29 | 30 | 0 ≤ N ≤ 30 31 | 32 | 来源：力扣（LeetCode） 33 | 链接：https://leetcode-cn.com/problems/fibonacci-number 34 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /53_最大子序和/53_maxSubArray.go: -------------------------------------------------------------------------------- 1 | package maxSubArray 2 | 3 | func max(x, y int) int { 4 | if x > y { 5 | return x 6 | } 7 | return y 8 | } 9 | 10 | func maxSubArray(nums []int) int { 11 | ret := nums[0] 12 | 13 | maxNode := nums[0] 14 | 15 | for i := 1; i < len(nums); i++ { 16 | maxNode = max(nums[i]+maxNode, nums[i]) 17 | ret = max(maxNode, ret) 18 | } 19 | 20 | return ret 21 | } 22 | -------------------------------------------------------------------------------- /53_最大子序和/53_maxSubArray_test.go: -------------------------------------------------------------------------------- 1 | package maxSubArray 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMaxSubArray(t *testing.T) { 9 | assert.Equal(t, 6, maxSubArray([]int{-2, 1, -3, 4, -1, 2, 1, -5, 4})) 10 | } 11 | -------------------------------------------------------------------------------- /53_最大子序和/request.txt: -------------------------------------------------------------------------------- 1 | 53. 最大子序和 2 | 3 | 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 4 | 5 | 示例: 6 | 7 | 输入: [-2,1,-3,4,-1,2,1,-5,4], 8 | 输出: 6 9 | 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 10 | 进阶: 11 | 12 | 如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。 13 | 14 | 来源：力扣（LeetCode） 15 | 链接：https://leetcode-cn.com/problems/maximum-subarray 16 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /5_longestPalindrome/5_longestPalindrome.go: -------------------------------------------------------------------------------- 1 | package longestPalindrome 2 | 3 | /* 4 | 中心扩展 5 | 考虑最长回文串为奇数和偶数两种情况 6 | */ 7 | func longestPalindrome(s string) string { 8 | 9 | //runtime.GOMAXPROCS(2) 10 | var start = 0 11 | var maxLen = 0 12 | sLen := len([]byte(s)) 13 | if sLen < 2 { 14 | return s 15 | } 16 | result := make(chan [2]int, 2*sLen) 17 | 18 | for k := 0; k < sLen; k++ { 19 | go findMaxLength(k, k, []byte(s), result) //假设最长为奇数，尝试尽可能向两边扩展 20 | go findMaxLength(k, k+1, []byte(s), result) //假设最长为偶数，尝试尽可能向两边扩展 21 | } 22 | 23 | for i := 0; i < 2*sLen; i++ { 24 | r := <-result 25 | //fmt.Println("result: ", strconv.Itoa(r[0]), "index: ", strconv.Itoa(r[1])) 26 | if maxLen < r[0] { 27 | maxLen = r[0] 28 | start = r[1] 29 | //fmt.Println("maxLen: ", maxLen) 30 | } 31 | } 32 | close(result) 33 | 34 | return string([]byte(s)[start : start+maxLen]) 35 | } 36 | 37 | func findMaxLength(i, j int, bList []byte, retChan chan [2]int) { 38 | for i >= 0 && j < len(bList) && bList[i] == bList[j] { 39 | i -= 1 40 | j += 1 41 | } 42 | maxLength := j - i - 1 43 | startIndex := i + 1 44 | retList := [2]int{maxLength, startIndex} 45 | retChan <- retList 46 | 47 | return 48 | } 49 | -------------------------------------------------------------------------------- /5_longestPalindrome/5_longestPalindrome_test.go: -------------------------------------------------------------------------------- 1 | package longestPalindrome 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestLongestPalindrome(t *testing.T) { 9 | testStringMap := map[string]string{ 10 | "abcdeedcba": "abcdeedcba", 11 | 12 | "abcba": "abcba", 13 | 14 | "cbbd": "bb", 15 | "babad": "bab", 16 | "cbbb": "bbb", 17 | "babcdea": "bab", 18 | "aa": "aa", 19 | 20 | " ": " ", 21 | "": "", 22 | "a": "a", 23 | "ac": "a", 24 | } 25 | 26 | for key, value := range testStringMap { 27 | assert.Equal(t, value, longestPalindrome(key)) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /5_longestPalindrome/request.txt: -------------------------------------------------------------------------------- 1 | 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。 2 | 3 | 示例 1： 4 | 5 | 输入: "babad" 6 | 输出: "bab" 7 | 注意: "aba" 也是一个有效答案。 8 | 示例 2： 9 | 10 | 输入: "cbbd" 11 | 输出: "bb" 12 | 13 | 来源：力扣（LeetCode） 14 | 链接：https://leetcode-cn.com/problems/longest-palindromic-substring 15 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /64_最小路径和/64_minPathSum.go: -------------------------------------------------------------------------------- 1 | package minPathSum 2 | 3 | func minPathSum(grid [][]int) int { 4 | 5 | for i := len(grid) - 1; i >= 0; i -- { 6 | for j := len(grid[0]) - 1; j >= 0; j -- { 7 | if i == len(grid)-1 && j != len(grid[0])-1 { 8 | grid[i][j] = grid[i][j] + grid[i][j+1] 9 | 10 | } else if i != len(grid)-1 && j == len(grid[0])-1 { 11 | grid[i][j] = grid[i][j] + grid[i+1][j] 12 | 13 | } else if i != len(grid)-1 && j != len(grid[0])-1 { 14 | grid[i][j] = grid[i][j] + min(grid[i+1][j], grid[i][j+1]) 15 | } 16 | 17 | } 18 | } 19 | return grid[0][0] 20 | } 21 | 22 | func min(x, y int) int { 23 | if x > y { 24 | return y 25 | } 26 | return x 27 | } 28 | -------------------------------------------------------------------------------- /64_最小路径和/64_minPathSum_test.go: -------------------------------------------------------------------------------- 1 | package minPathSum 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMinPathSum(t *testing.T) { 9 | assert.Equal(t, 7, minPathSum([][]int{{1, 3, 1}, {1, 5, 1}, {4, 2, 1}})) 10 | 11 | } 12 | -------------------------------------------------------------------------------- /64_最小路径和/request.txt: -------------------------------------------------------------------------------- 1 | 64. 最小路径和 2 | 3 | 给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 4 | 5 | 说明：每次只能向下或者向右移动一步。 6 | 7 | 示例: 8 | 9 | 输入: 10 | [ 11 |   [1,3,1], 12 | [1,5,1], 13 | [4,2,1] 14 | ] 15 | 输出: 7 16 | 解释: 因为路径 1→3→1→1→1 的总和最小。 17 | 18 | 来源：力扣（LeetCode） 19 | 链接：https://leetcode-cn.com/problems/minimum-path-sum 20 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /64_最小路径和/result.txt: -------------------------------------------------------------------------------- 1 | 方法 2：二维动态规划 2 | 算法 3 | 4 | 我们新建一个额外的 dpdp 数组，与原矩阵大小相同。在这个矩阵中，dp(i, j)dp(i,j) 表示从坐标 (i, j)(i,j) 到右下角的最小路径权值。我们初始化右下角的 dpdp 值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑移动到右边或者下面，因此获得最小路径和我们有如下递推公式： 5 | 6 | dp(i,j)=grid(i,j)+min(dp(i+1,j),dp(i,j+1)) 7 | 8 | -------------------------------------------------------------------------------- /66_加一/66_plusOne.go: -------------------------------------------------------------------------------- 1 | package plusOne 2 | 3 | func plusOne(digits []int) []int { 4 | var isAddOne = true 5 | for i := len(digits) - 1; i >= 0; i-- { 6 | if isAddOne { 7 | digits[i] += 1 8 | } else { 9 | continue 10 | } 11 | if digits[i] >= 10 { 12 | isAddOne = true 13 | } else { 14 | isAddOne = false 15 | } 16 | 17 | digits[i] = digits[i] % 10 18 | 19 | } 20 | if isAddOne { 21 | return append([]int{1}, digits...) 22 | } 23 | 24 | return digits 25 | } 26 | -------------------------------------------------------------------------------- /66_加一/66_plusOne_test.go: -------------------------------------------------------------------------------- 1 | package plusOne 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | ) 7 | 8 | func TestReverse(t *testing.T) { 9 | assert.Equal(t, []int{1, 2, 4}, plusOne([]int{1, 2, 3})) 10 | assert.Equal(t, []int{1, 3, 0}, plusOne([]int{1, 2, 9})) 11 | assert.Equal(t, []int{2, 0, 0}, plusOne([]int{1, 9, 9})) 12 | assert.Equal(t, []int{1, 0, 0, 0}, plusOne([]int{9, 9, 9})) 13 | } 14 | -------------------------------------------------------------------------------- /66_加一/request.txt: -------------------------------------------------------------------------------- 1 | 66. 加一 2 | 3 | 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。 4 | 5 | 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。 6 | 7 | 你可以假设除了整数 0 之外，这个整数不会以零开头。 8 | 9 | 示例 1: 10 | 11 | 输入: [1,2,3] 12 | 输出: [1,2,4] 13 | 解释: 输入数组表示数字 123。 14 | 示例 2: 15 | 16 | 输入: [4,3,2,1] 17 | 输出: [4,3,2,2] 18 | 解释: 输入数组表示数字 4321。 19 | 20 | 来源：力扣（LeetCode） 21 | 链接：https://leetcode-cn.com/problems/plus-one 22 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /6_Z字形变换/6_convert.go: -------------------------------------------------------------------------------- 1 | package convert 2 | 3 | func Min(x, y int) int { 4 | if x < y { 5 | return x 6 | } 7 | return y 8 | } 9 | 10 | func convert(s string, numRows int) string { 11 | 12 | if len(s) < 2 || numRows < 2 { 13 | return s 14 | } 15 | 16 | step := 2*numRows - 2 17 | 18 | sList := make([]string, 0) 19 | 20 | for i := 0; i < len(s); i += step { 21 | sList = append(sList, s[i:Min(i+step, len(s))]) 22 | } 23 | 24 | res := "" 25 | for _, value := range sList { 26 | res += string(value[0]) 27 | } 28 | 29 | for i, j := 1, step-1; i <= j; i, j = i+1, j-1 { 30 | for _, value := range sList { 31 | if i < len(value) { 32 | res += string(value[i]) 33 | } 34 | if j < len(value) && i != j { 35 | res += string(value[j]) 36 | } 37 | } 38 | } 39 | 40 | return res 41 | } 42 | -------------------------------------------------------------------------------- /6_Z字形变换/6_convert_test.go: -------------------------------------------------------------------------------- 1 | package convert 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestReverse(t *testing.T) { 9 | assert.Equal(t, "LCIRETOESIIGEDHN", convert("LEETCODEISHIRING", 3)) 10 | assert.Equal(t, "LDREOEIIECIHNTSG", convert("LEETCODEISHIRING", 4)) 11 | 12 | } 13 | -------------------------------------------------------------------------------- /6_Z字形变换/request.txt: -------------------------------------------------------------------------------- 1 | 6. Z 字形变换 2 | 3 | 将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。 4 | 5 | 比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下： 6 | 7 | L C I R 8 | E T O E S I I G 9 | E D H N 10 | 之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。 11 | 12 | 请你实现这个将字符串进行指定行数变换的函数： 13 | 14 | string convert(string s, int numRows); 15 | 示例 1: 16 | 17 | 输入: s = "LEETCODEISHIRING", numRows = 3 18 | 输出: "LCIRETOESIIGEDHN" 19 | 示例 2: 20 | 21 | 输入: s = "LEETCODEISHIRING", numRows = 4 22 | 输出: "LDREOEIIECIHNTSG" 23 | 解释: 24 | 25 | L D R 26 | E O E I I 27 | E C I H N 28 | T S G 29 | 30 | 来源：力扣（LeetCode） 31 | 链接：https://leetcode-cn.com/problems/zigzag-conversion 32 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /70_爬楼梯/70_climbStairs.go: -------------------------------------------------------------------------------- 1 | package climbStairs 2 | 3 | func climbStairs(n int) int { 4 | if n == 1 || n == 2 { 5 | return n 6 | } 7 | 8 | dp := make([]int, n+1) 9 | dp[1] = 1 10 | dp[2] = 2 11 | for i := 3; i <= n; i++ { 12 | dp[i] = dp[i-1] + dp[i-2] 13 | } 14 | 15 | return dp[n] 16 | } 17 | -------------------------------------------------------------------------------- /70_爬楼梯/70_climbStairs_test.go: -------------------------------------------------------------------------------- 1 | package climbStairs 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestClimbStairs(t *testing.T) { 9 | assert.Equal(t, 2, climbStairs(2)) 10 | assert.Equal(t, 1, climbStairs(1)) 11 | assert.Equal(t, 3, climbStairs(3)) 12 | } 13 | -------------------------------------------------------------------------------- /70_爬楼梯/request.txt: -------------------------------------------------------------------------------- 1 | 70. 爬楼梯 2 | 3 | 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 4 | 5 | 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 6 | 7 | 注意：给定 n 是一个正整数。 8 | 9 | 示例 1： 10 | 11 | 输入： 2 12 | 输出： 2 13 | 解释： 有两种方法可以爬到楼顶。 14 | 1. 1 阶 + 1 阶 15 | 2. 2 阶 16 | 示例 2： 17 | 18 | 输入： 3 19 | 输出： 3 20 | 解释： 有三种方法可以爬到楼顶。 21 | 1. 1 阶 + 1 阶 + 1 阶 22 | 2. 1 阶 + 2 阶 23 | 3. 2 阶 + 1 阶 24 | 25 | 来源：力扣（LeetCode） 26 | 链接：https://leetcode-cn.com/problems/climbing-stairs 27 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /728_自除数/728_selfDividingNumbers.go: -------------------------------------------------------------------------------- 1 | package selfDividingNumbers 2 | 3 | func selfDividingNumbers(left int, right int) []int { 4 | ret := make([]int, 0) 5 | for i := left; i < right+1; i++ { 6 | k := i 7 | flag := true 8 | for k > 0 { 9 | n := k % 10 10 | 11 | if n==0 || n != 0 && i%n != 0 { 12 | flag = false 13 | break 14 | } 15 | k /= 10 16 | } 17 | if flag { 18 | ret = append(ret, i) 19 | } 20 | } 21 | return ret 22 | } 23 | -------------------------------------------------------------------------------- /728_自除数/728_selfDividingNumbers_test.go: -------------------------------------------------------------------------------- 1 | package selfDividingNumbers 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestSelfDividingNumbers(t *testing.T) { 9 | assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22}, selfDividingNumbers(1, 22)) 10 | 11 | } 12 | -------------------------------------------------------------------------------- /728_自除数/request.txt: -------------------------------------------------------------------------------- 1 | 728. 自除数 2 | 3 | 自除数 是指可以被它包含的每一位数除尽的数。 4 | 5 | 例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。 6 | 7 | 还有，自除数不允许包含 0 。 8 | 9 | 给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。 10 | 11 | 示例 1： 12 | 13 | 输入： 14 | 上边界left = 1, 下边界right = 22 15 | 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22] 16 | 注意： 17 | 18 | 每个输入参数的边界满足 1 <= left <= right <= 10000。 19 | 20 | 21 | 来源：力扣（LeetCode） 22 | 链接：https://leetcode-cn.com/problems/self-dividing-numbers 23 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /771_宝石与石头/771_numJewelsInStones.go: -------------------------------------------------------------------------------- 1 | package numJewelsInStones 2 | 3 | import "strings" 4 | 5 | func numJewelsInStones(J string, S string) int { 6 | ret := 0 7 | for _, j := range J { 8 | ret += strings.Count(S, string(j)) 9 | } 10 | 11 | return ret 12 | } 13 | -------------------------------------------------------------------------------- /771_宝石与石头/771_numJewelsInStones_test.go: -------------------------------------------------------------------------------- 1 | package numJewelsInStones 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestNumJewelsInStones(t *testing.T) { 9 | assert.Equal(t, 3, numJewelsInStones("aA", "aAAbbbb")) 10 | assert.Equal(t, 0, numJewelsInStones("z", "ZZ")) 11 | 12 | } -------------------------------------------------------------------------------- /771_宝石与石头/request.txt: -------------------------------------------------------------------------------- 1 | 771. 宝石与石头 2 | 3 |  给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。 4 | 5 | J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。 6 | 7 | 示例 1: 8 | 9 | 输入: J = "aA", S = "aAAbbbb" 10 | 输出: 3 11 | 示例 2: 12 | 13 | 输入: J = "z", S = "ZZ" 14 | 输出: 0 15 | 注意: 16 | 17 | S 和 J 最多含有50个字母。 18 |  J 中的字符不重复。 19 | 20 | 21 | 来源：力扣（LeetCode） 22 | 链接：https://leetcode-cn.com/problems/jewels-and-stones 23 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /7_reverse/7_reverse.go: -------------------------------------------------------------------------------- 1 | package reverse 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | func reverse(x int) int { 8 | var result int 9 | for x != 0 { 10 | result = result*10 + x%10 11 | x /= 10 12 | if result > math.MaxInt32 || result < math.MinInt32 { 13 | return 0 14 | } 15 | } 16 | return result 17 | } 18 | -------------------------------------------------------------------------------- /7_reverse/7_reverse_test.go: -------------------------------------------------------------------------------- 1 | package reverse 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestReverse(t *testing.T) { 9 | testStringMap := map[int]int{ 10 | 12: 21, 11 | 123: 321, 12 | 100: 1, 13 | 120: 21, 14 | -120: -21, 15 | 1534236469: 0, 16 | } 17 | 18 | for key, value := range testStringMap { 19 | assert.Equal(t, value, reverse(key)) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /7_reverse/request.txt: -------------------------------------------------------------------------------- 1 | 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 2 | 3 | 示例 1: 4 | 5 | 输入: 123 6 | 输出: 321 7 |  示例 2: 8 | 9 | 输入: -123 10 | 输出: -321 11 | 示例 3: 12 | 13 | 输入: 120 14 | 输出: 21 15 | 注意: 16 | 17 | 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。 18 | 19 | 来源：力扣（LeetCode） 20 | 链接：https://leetcode-cn.com/problems/reverse-integer 21 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /832_翻转图像/832_flipAndInvertImage.go: -------------------------------------------------------------------------------- 1 | package flipAndInvertImage 2 | 3 | func reverse(x int) int { 4 | if x == 0 { 5 | return 1 6 | } 7 | return 0 8 | } 9 | 10 | func flipAndInvertImage(A [][]int) [][]int { 11 | for i := 0; i < len(A); i++ { 12 | for j := 0; j < len(A[i]); j++ { 13 | if j < len(A[i])-j { 14 | A[i][j], A[i][len(A[i])-1-j] = reverse(A[i][len(A[i])-1-j]), reverse(A[i][j]) 15 | //temp := A[i][len(A[i])-1-j] 16 | //A[i][len(A[i])-1-j] = reverse(A[i][j]) 17 | //A[i][j] = reverse(temp) 18 | 19 | } 20 | } 21 | } 22 | return A 23 | } 24 | -------------------------------------------------------------------------------- /832_翻转图像/832_flipAndInvertImage_test.go: -------------------------------------------------------------------------------- 1 | package flipAndInvertImage 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestFlipAndInvertImage(t *testing.T) { 9 | assert.Equal(t, [][]int{{1, 0, 0}, {0, 1, 0}, {1, 1, 1}}, flipAndInvertImage([][]int{{1, 1, 0}, {1, 0, 1}, {0, 0, 0}})) 10 | assert.Equal(t, [][]int{{1, 1, 0, 0}, {0, 1, 1, 0}, {0,0,0,1},{1, 0, 1, 0}}, flipAndInvertImage([][]int{{1, 1, 0, 0}, {1, 0, 0, 1}, {0, 1, 1, 1}, {1, 0, 1, 0}})) 11 | 12 | } 13 | -------------------------------------------------------------------------------- /832_翻转图像/request.txt: -------------------------------------------------------------------------------- 1 | 832. 翻转图像 2 | 3 | 4 | 给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。 5 | 6 | 水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。 7 | 8 | 反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。 9 | 10 | 示例 1: 11 | 12 | 输入: [[1,1,0],[1,0,1],[0,0,0]] 13 | 输出: [[1,0,0],[0,1,0],[1,1,1]] 14 | 解释: 首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]； 15 | 然后反转图片: [[1,0,0],[0,1,0],[1,1,1]] 16 | 示例 2: 17 | 18 | 输入: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]] 19 | 输出: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] 20 | 解释: 首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]； 21 | 然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] 22 | 说明: 23 | 24 | 1 <= A.length = A[0].length <= 20 25 | 0 <= A[i][j] <= 1 26 | 27 | 来源：力扣（LeetCode） 28 | 链接：https://leetcode-cn.com/problems/flipping-an-image 29 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /842_将数组拆分成斐波那契序列<未完成>/842_splitIntoFibonacci.go: -------------------------------------------------------------------------------- 1 | package splitIntoFibonacci 2 | 3 | func splitIntoFibonacci(S string) []int { 4 | ret := make([]int, 0) 5 | 6 | return ret 7 | } 8 | -------------------------------------------------------------------------------- /842_将数组拆分成斐波那契序列<未完成>/842_splitIntoFibonacci_test.go: -------------------------------------------------------------------------------- 1 | package splitIntoFibonacci 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestSplitIntoFibonacci(t *testing.T) { 9 | assert.Equal(t, []int{123, 456, 579}, splitIntoFibonacci("123456579")) 10 | assert.Equal(t, []int{1, 1, 2, 3, 5, 8, 13}, splitIntoFibonacci("11235813")) 11 | assert.Equal(t, []int{}, splitIntoFibonacci("112358130")) 12 | assert.Equal(t, []int{}, splitIntoFibonacci("0123")) 13 | assert.Equal(t, []int{11, 0, 11, 11}, splitIntoFibonacci("1101111")) 14 | 15 | } 16 | -------------------------------------------------------------------------------- /842_将数组拆分成斐波那契序列<未完成>/request.txt: -------------------------------------------------------------------------------- 1 | 842. 将数组拆分成斐波那契序列 2 | 3 | 给定一个数字字符串 S，比如 S = "123456579"，我们可以将它分成斐波那契式的序列 [123, 456, 579]。 4 | 5 | 形式上，斐波那契式序列是一个非负整数列表 F，且满足： 6 | 7 | 0 <= F[i] <= 2^31 - 1，（也就是说，每个整数都符合 32 位有符号整数类型）； 8 | F.length >= 3； 9 | 对于所有的0 <= i < F.length - 2，都有 F[i] + F[i+1] = F[i+2] 成立。 10 | 另外，请注意，将字符串拆分成小块时，每个块的数字一定不要以零开头，除非这个块是数字 0 本身。 11 | 12 | 返回从 S 拆分出来的所有斐波那契式的序列块，如果不能拆分则返回 []。 13 | 14 | 示例 1： 15 | 16 | 输入："123456579" 17 | 输出：[123,456,579] 18 | 示例 2： 19 | 20 | 输入: "11235813" 21 | 输出: [1,1,2,3,5,8,13] 22 | 示例 3： 23 | 24 | 输入: "112358130" 25 | 输出: [] 26 | 解释: 这项任务无法完成。 27 | 示例 4： 28 | 29 | 输入："0123" 30 | 输出：[] 31 | 解释：每个块的数字不能以零开头，因此 "01"，"2"，"3" 不是有效答案。 32 | 示例 5： 33 | 34 | 输入: "1101111" 35 | 输出: [110, 1, 111] 36 | 解释: 输出 [11,0,11,11] 也同样被接受。 37 | 提示： 38 | 39 | 1 <= S.length <= 200 40 | 字符串 S 中只含有数字。 41 | 42 | 来源：力扣（LeetCode） 43 | 链接：https://leetcode-cn.com/problems/split-array-into-fibonacci-sequence 44 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /8_字符串转换整数/8_myAtoi.go: -------------------------------------------------------------------------------- 1 | package myAtoi 2 | 3 | import ( 4 | "regexp" 5 | "strconv" 6 | "math" 7 | "strings" 8 | ) 9 | 10 | func myAtoi(str string) int { 11 | str = strings.Trim(str, " ") 12 | b := []byte(str) 13 | pat := `^[+|-]?\d+` 14 | reg := regexp.MustCompile(pat) 15 | newStr := reg.Find(b) 16 | number, _ := strconv.Atoi(string(newStr)) 17 | 18 | if number > math.MaxInt32 { 19 | return math.MaxInt32 20 | } else if number < math.MinInt32 { 21 | return math.MinInt32 22 | } 23 | 24 | return number 25 | } 26 | -------------------------------------------------------------------------------- /8_字符串转换整数/8_myAtoi_test.go: -------------------------------------------------------------------------------- 1 | package myAtoi 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestMyAtoi(t *testing.T) { 9 | testStringMap := map[string]int{ 10 | " qw-123": 0, 11 | " -123wd": -123, 12 | " -123wd ": -123, 13 | " w+123wd ": 0, 14 | 15 | "123": 123, 16 | " 123": 123, 17 | " -123": -123, 18 | 19 | " -qw-123": 0, 20 | "-qw-123": 0, 21 | "qw-123": 0, 22 | 23 | "-91283472332": -2147483648, 24 | } 25 | 26 | for key, value := range testStringMap { 27 | assert.Equal(t, value, myAtoi(key)) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /8_字符串转换整数/request.txt: -------------------------------------------------------------------------------- 1 | 8. 字符串转换整数 (atoi) 2 | 3 | 请你来实现一个 atoi 函数，使其能将字符串转换成整数。 4 | 5 | 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。 6 | 7 | 当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。 8 | 9 | 该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。 10 | 11 | 注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。 12 | 13 | 在任何情况下，若函数不能进行有效的转换时，请返回 0。 14 | 15 | 说明： 16 | 17 | 假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。如果数值超过这个范围，请返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。 18 | 19 | 示例 1: 20 | 21 | 输入: "42" 22 | 输出: 42 23 | 示例 2: 24 | 25 | 输入: " -42" 26 | 输出: -42 27 | 解释: 第一个非空白字符为 '-', 它是一个负号。 28 |   我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。 29 | 示例 3: 30 | 31 | 输入: "4193 with words" 32 | 输出: 4193 33 | 解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。 34 | 示例 4: 35 | 36 | 输入: "words and 987" 37 | 输出: 0 38 | 解释: 第一个非空字符是 'w', 但它不是数字或正、负号。 39 | 因此无法执行有效的转换。 40 | 示例 5: 41 | 42 | 输入: "-91283472332" 43 | 输出: -2147483648 44 | 解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 45 |   因此返回 INT_MIN (−231) 。 46 | 47 | 来源：力扣（LeetCode） 48 | 链接：https://leetcode-cn.com/problems/string-to-integer-atoi 49 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /9_回文数/9_isPalindrome.go: -------------------------------------------------------------------------------- 1 | package isPalindrome 2 | 3 | // 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 4 | func isPalindrome(x int) bool { 5 | // 负数肯定不是回文数 6 | if x < 0 { 7 | return false 8 | } 9 | var result int 10 | newX := x 11 | for x != 0 { 12 | result = result*10 + x%10 13 | x /= 10 14 | } 15 | 16 | if result != newX { 17 | return false 18 | } 19 | 20 | return true 21 | } 22 | 23 | func isPalindrome2(x int) bool { 24 | // 负数肯定不是回文数 25 | if x < 0 { 26 | return false 27 | } 28 | resultList := make([]int, 0) 29 | for x != 0 { 30 | resultList = append(resultList, x%10) 31 | x /= 10 32 | } 33 | rLen := len(resultList) 34 | for i := 0; i < rLen/2; i++ { 35 | if resultList[i] != resultList[rLen-1-i] { 36 | return false 37 | } 38 | } 39 | 40 | return true 41 | 42 | } 43 | -------------------------------------------------------------------------------- /9_回文数/9_isPalindrome_test.go: -------------------------------------------------------------------------------- 1 | package isPalindrome 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | "fmt" 7 | ) 8 | 9 | func TestMyAtoi(t *testing.T) { 10 | testStringMap := map[int]bool{ 11 | 121: true, 12 | 13 | 123: false, 14 | 15 | -123: false, 16 | 17 | } 18 | 19 | for key, value := range testStringMap { 20 | assert.Equal(t, value, isPalindrome2(key), fmt.Sprintf("key is %d", key)) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /9_回文数/request.txt: -------------------------------------------------------------------------------- 1 | 9. 回文数 2 | 3 | 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 4 | 5 | 示例 1: 6 | 7 | 输入: 121 8 | 输出: true 9 | 示例 2: 10 | 11 | 输入: -121 12 | 输出: false 13 | 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 14 | 示例 3: 15 | 16 | 输入: 10 17 | 输出: false 18 | 解释: 从右向左读, 为 01 。因此它不是一个回文数。 19 | 进阶: 20 | 21 | 你能不将整数转为字符串来解决这个问题吗？ 22 | 23 | 24 | 25 | 来源：力扣（LeetCode） 26 | 链接：https://leetcode-cn.com/problems/palindrome-number 27 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /LCP1_猜数字/1_game.go: -------------------------------------------------------------------------------- 1 | package game 2 | 3 | func game(guess []int, answer []int) int { 4 | ret := 0 5 | for i := 0; i < len(answer); i++ { 6 | if guess[i] == answer[i] { 7 | ret++ 8 | } 9 | 10 | } 11 | return ret 12 | } 13 | -------------------------------------------------------------------------------- /LCP1_猜数字/1_game_test.go: -------------------------------------------------------------------------------- 1 | package game 2 | 3 | import ( 4 | "testing" 5 | "github.com/stretchr/testify/assert" 6 | ) 7 | 8 | func TestGame(t *testing.T) { 9 | assert.Equal(t, 3, game([]int{1, 2, 3}, []int{1, 2, 3})) 10 | assert.Equal(t, 2, game([]int{2, 2, 3}, []int{1, 2, 3})) 11 | } 12 | -------------------------------------------------------------------------------- /LCP1_猜数字/request.txt: -------------------------------------------------------------------------------- 1 | LCP 1. 猜数字 2 | 3 | 4 | 小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？ 5 | 6 |   7 | 8 | 输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。 9 | 10 |   11 | 12 | 示例 1： 13 | 14 | 输入：guess = [1,2,3], answer = [1,2,3] 15 | 输出：3 16 | 解释：小A 每次都猜对了。 17 |   18 | 19 | 示例 2： 20 | 21 | 输入：guess = [2,2,3], answer = [3,2,1] 22 | 输出：1 23 | 解释：小A 只猜对了第二次。 24 |   25 | 26 | 限制： 27 | 28 | guess的长度 = 3 29 | answer的长度 = 3 30 | guess的元素取值为 {1, 2, 3} 之一。 31 | answer的元素取值为 {1, 2, 3} 之一。 32 | 33 | 来源：力扣（LeetCode） 34 | 链接：https://leetcode-cn.com/problems/guess-numbers 35 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Huang.X 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetcode 2 | leetcode for golang 3 | 4 | ## plan 5 | 每日一题 6 | 7 | ## 文件说明 8 | * *test.go 测试用例 (有的问题没有测试用例) 9 | * request.txt 问题描述 10 | * result.txt 解题思路 11 | * vscode/* vscode 通过安装 leetcode 插件文件 12 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module leetcode 2 | 3 | go 1.14 4 | -------------------------------------------------------------------------------- /vscode/1.两数之和.go: -------------------------------------------------------------------------------- 1 | /* 2 | * @lc app=leetcode.cn id=1 lang=golang 3 | * 4 | * [1] 两数之和 5 | */ 6 | package vscode 7 | 8 | // @lc code=start 9 | func twoSum(nums []int, target int) []int { 10 | numMap := make(map[int]int, len(nums)) 11 | for k, v := range nums { 12 | numMap[v] = k 13 | } 14 | value := int(0) 15 | for k, v := range nums { 16 | value = target - v 17 | if k2, ok := numMap[value]; ok && k2 != k { 18 | return []int{k, k2} 19 | } 20 | } 21 | return []int{} 22 | } 23 | 24 | // @lc code=end 25 | -------------------------------------------------------------------------------- /vscode/18.四数之和.go: -------------------------------------------------------------------------------- 1 | package vscode 2 | 3 | /* 4 | * @lc app=leetcode.cn id=18 lang=golang 5 | * 6 | * [18] 四数之和 7 | */ 8 | 9 | // @lc code=start 10 | func fourSum(nums []int, target int) [][]int { 11 | return nil 12 | } 13 | 14 | // @lc code=end 15 | -------------------------------------------------------------------------------- /vscode/2.两数相加.go: -------------------------------------------------------------------------------- 1 | package vscode 2 | 3 | /* 4 | * @lc app=leetcode.cn id=2 lang=golang 5 | * 6 | * [2] 两数相加 7 | */ 8 | 9 | // @lc code=start 10 | 11 | func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode { 12 | root := new(ListNode) 13 | tmp := root 14 | carry := 0 15 | 16 | for l1 != nil || l2 != nil || carry != 0 { 17 | if l1 == nil { 18 | l1 = new(ListNode) 19 | } 20 | if l2 == nil { 21 | l2 = new(ListNode) 22 | } 23 | sum := l1.Val + l2.Val + carry 24 | carry = sum / 10 25 | sumNode := &ListNode{ 26 | Val: sum % 10, 27 | } 28 | tmp.Next = sumNode 29 | tmp = sumNode 30 | 31 | if l1 != nil { 32 | l1 = l1.Next 33 | } 34 | if l2 != nil { 35 | l2 = l2.Next 36 | } 37 | } 38 | 39 | return root.Next 40 | } 41 | 42 | // @lc code=end 43 | -------------------------------------------------------------------------------- /vscode/2.两数相加_test.go: -------------------------------------------------------------------------------- 1 | package vscode 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | func TestAddTwoNumbers(t *testing.T) { 10 | t1 := []int{2, 4, 3} 11 | t2 := []int{5, 6, 4} 12 | except := []int{7, 0, 8} 13 | retListNode := addTwoNumbers(makeListNode(t1), makeListNode(t2)) 14 | retList := changeListNode2List(retListNode) 15 | if !reflect.DeepEqual(retList, except) { 16 | t.Error("错误") 17 | } 18 | fmt.Println(retList) 19 | } 20 | -------------------------------------------------------------------------------- /vscode/27.移除元素.go: -------------------------------------------------------------------------------- 1 | /* 2 | * @lc app=leetcode.cn id=27 lang=golang 3 | * 4 | * [27] 移除元素 5 | */ 6 | 7 | package vscode 8 | 9 | // @lc code=start 10 | func removeElement(nums []int, val int) int { 11 | j := len(nums) - 1 12 | i := int(0) 13 | for i = 0; i <= j; i++ { 14 | if nums[i] == val { 15 | nums[i], nums[j] = nums[j], nums[i] 16 | i-- 17 | j-- 18 | } 19 | } 20 | return j + 1 21 | } 22 | 23 | // @lc code=end 24 | -------------------------------------------------------------------------------- /vscode/common.go: -------------------------------------------------------------------------------- 1 | package vscode 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // 数组转链表 9 | func makeListNode(elements []int) *ListNode { 10 | if len(elements) == 0 { 11 | return nil 12 | } 13 | res := &ListNode{ 14 | Val: elements[0], 15 | } 16 | // temp对res复制，二者没有关系了 17 | temp := res 18 | for i := 1; i < len(elements); i++ { 19 | // 对temp的子属性赋值 20 | temp.Next = &ListNode{Val: elements[i]} 21 | // 再将temp指向当前子属性 作为下一轮循环的当前值 22 | temp = temp.Next 23 | } 24 | 25 | return res 26 | } 27 | 28 | func changeListNode2List(listNode *ListNode) []int { 29 | ret := make([]int, 0) 30 | ret = append(ret, listNode.Val) 31 | for listNode.Next != nil { 32 | listNode = listNode.Next 33 | ret = append(ret, listNode.Val) 34 | } 35 | return ret 36 | } 37 | --------------------------------------------------------------------------------