diff --git "a/11.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.go" "b/11.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.go"
new file mode 100644
index 0000000..260c4f2
--- /dev/null
+++ "b/11.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.go"
@@ -0,0 +1,92 @@
+/*
+ * @lc app=leetcode.cn id=11 lang=golang
+ *
+ * [11] 盛最多水的容器
+ *
+ * https://leetcode-cn.com/problems/container-with-most-water/description/
+ *
+ * algorithms
+ * Medium (61.73%)
+ * Likes:    3413
+ * Dislikes: 0
+ * Total Accepted:    701.5K
+ * Total Submissions: 1.1M
+ * Testcase Example:  '[1,8,6,2,5,4,8,3,7]'
+ *
+ * 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
+ *
+ * 找出其中的两条线，使得它们与 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
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * n == height.length
+ * 2 <= n <= 10^5
+ * 0 <= height[i] <= 10^4
+ *
+ *
+ */
+
+// @lc code=start
+func maxArea(height []int) int {
+	last := len(height) - 1
+	first := 0
+	cap := 0
+	if last <= 0 {
+		return 0
+	}
+	for first < last {
+		width := last - first
+		height := min(height[first], height[last])
+
+		cap = max(cap, width*height)
+
+		if height[first] < height[last] {
+			first++
+		} else {
+			last--
+		}
+	}
+	return cap
+
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.go" "b/116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.go"
index 34d2ed3..7b293c4 100644
--- "a/116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.go"
+++ "b/116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.go"
@@ -1,92 +1,92 @@
-/*
- * @lc app=leetcode.cn id=116 lang=golang
- *
- * [116] 填充每个节点的下一个右侧节点指针
- *
- * https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/description/
- *
- * algorithms
- * Medium (71.21%)
- * Likes:    741
- * Dislikes: 0
- * Total Accepted:    235.9K
- * Total Submissions: 330.4K
- * Testcase Example:  '[1,2,3,4,5,6,7]'
- *
- * 给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
- *
- *
- * struct Node {
- * ⁠ int val;
- * ⁠ Node *left;
- * ⁠ Node *right;
- * ⁠ Node *next;
- * }
- *
- * 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
- *
- * 初始状态下，所有 next 指针都被设置为 NULL。
- *
- *
- *
- * 示例 1：
- *
- *
- *
- *
- * 输入：root = [1,2,3,4,5,6,7]
- * 输出：[1,#,2,3,#,4,5,6,7,#]
- * 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B
- * 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
- *
- *
- *
- *
- * 示例 2:
- *
- *
- * 输入：root = []
- * 输出：[]
- *
- *
- *
- *
- * 提示：
- *
- *
- * 树中节点的数量在 [0, 2^12 - 1] 范围内
- * -1000 <= node.val <= 1000
- *
- *
- *
- *
- * 进阶：
- *
- *
- * 你只能使用常量级额外空间。
- * 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for a Node.
- * type Node struct {
- *     Val int
- *     Left *Node
- *     Right *Node
- *     Next *Node
- * }
- */
-
-func connect(root *Node) *Node {
-
-	if root.Left == nil {
-		return root
-	}
-	
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=116 lang=golang
+ *
+ * [116] 填充每个节点的下一个右侧节点指针
+ *
+ * https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/description/
+ *
+ * algorithms
+ * Medium (71.21%)
+ * Likes:    741
+ * Dislikes: 0
+ * Total Accepted:    235.9K
+ * Total Submissions: 330.4K
+ * Testcase Example:  '[1,2,3,4,5,6,7]'
+ *
+ * 给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
+ *
+ *
+ * struct Node {
+ * ⁠ int val;
+ * ⁠ Node *left;
+ * ⁠ Node *right;
+ * ⁠ Node *next;
+ * }
+ *
+ * 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
+ *
+ * 初始状态下，所有 next 指针都被设置为 NULL。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ *
+ * 输入：root = [1,2,3,4,5,6,7]
+ * 输出：[1,#,2,3,#,4,5,6,7,#]
+ * 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B
+ * 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
+ *
+ *
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入：root = []
+ * 输出：[]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点的数量在 [0, 2^12 - 1] 范围内
+ * -1000 <= node.val <= 1000
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 你只能使用常量级额外空间。
+ * 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ *     Next *Node
+ * }
+ */
+
+func connect(root *Node) *Node {
+
+	if root.Left == nil {
+		return root
+	}
+	
+}
+
+// @lc code=end
+
diff --git "a/120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go" "b/120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
index a93f887..a28181c 100644
--- "a/120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
+++ "b/120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
@@ -1,109 +1,109 @@
-/*
- * @lc app=leetcode.cn id=120 lang=golang
- *
- * [120] 三角形最小路径和
- *
- * https://leetcode-cn.com/problems/triangle/description/
- *
- * algorithms
- * Medium (68.47%)
- * Likes:    1012
- * Dislikes: 0
- * Total Accepted:    225.7K
- * Total Submissions: 329.3K
- * Testcase Example:  '[[2],[3,4],[6,5,7],[4,1,8,3]]'
- *
- * 给定一个三角形 triangle ，找出自顶向下的最小路径和。
- *
- * 每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1
- * 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
- * 输出：11
- * 解释：如下面简图所示：
- * ⁠  2
- * ⁠ 3 4
- * ⁠6 5 7
- * 4 1 8 3
- * 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
- *
- *
- * 示例 2：
- *
- *
- * 输入：triangle = [[-10]]
- * 输出：-10
- *
- *
- *
- *
- * 提示：
- *
- *
- * 1
- * triangle[0].length == 1
- * triangle[i].length == triangle[i - 1].length + 1
- * -10^4
- *
- *
- *
- *
- * 进阶：
- *
- *
- * 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？
- *
- *
- */
-
-// @lc code=start
-func minimumTotal(triangle [][]int) int {
-
-	row := len(triangle)
-
-	dp := make([][]int, row)
-	for i := 0; i < row; i++ {
-		dp[i] = make([]int, len(triangle[i]))
-	}
-
-	dp[0][0] = triangle[0][0]
-	for i := 1; i < row; i++ {
-		for j := 0; j < len(triangle[i]); j++ {
-			if j == 0 {
-				dp[i][0] = dp[i-1][0] + triangle[i][0]
-			} else if j == len(triangle[i])-1 {
-				dp[i][j] = dp[i-1][j-1] + triangle[i][j]
-			} else {
-				dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + triangle[i][j]
-			}
-		}
-	}
-
-	return minNum(dp[row-1])
-}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func minNum(arr []int) int {
-	ans := arr[0]
-
-	for i := 1; i < len(arr); i++ {
-		if arr[i] < ans {
-			ans = arr[i]
-		}
-	}
-	return ans
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=120 lang=golang
+ *
+ * [120] 三角形最小路径和
+ *
+ * https://leetcode-cn.com/problems/triangle/description/
+ *
+ * algorithms
+ * Medium (68.47%)
+ * Likes:    1012
+ * Dislikes: 0
+ * Total Accepted:    225.7K
+ * Total Submissions: 329.3K
+ * Testcase Example:  '[[2],[3,4],[6,5,7],[4,1,8,3]]'
+ *
+ * 给定一个三角形 triangle ，找出自顶向下的最小路径和。
+ *
+ * 每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1
+ * 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+ * 输出：11
+ * 解释：如下面简图所示：
+ * ⁠  2
+ * ⁠ 3 4
+ * ⁠6 5 7
+ * 4 1 8 3
+ * 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：triangle = [[-10]]
+ * 输出：-10
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1
+ * triangle[0].length == 1
+ * triangle[i].length == triangle[i - 1].length + 1
+ * -10^4
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？
+ *
+ *
+ */
+
+// @lc code=start
+func minimumTotal(triangle [][]int) int {
+
+	row := len(triangle)
+
+	dp := make([][]int, row)
+	for i := 0; i < row; i++ {
+		dp[i] = make([]int, len(triangle[i]))
+	}
+
+	dp[0][0] = triangle[0][0]
+	for i := 1; i < row; i++ {
+		for j := 0; j < len(triangle[i]); j++ {
+			if j == 0 {
+				dp[i][0] = dp[i-1][0] + triangle[i][0]
+			} else if j == len(triangle[i])-1 {
+				dp[i][j] = dp[i-1][j-1] + triangle[i][j]
+			} else {
+				dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + triangle[i][j]
+			}
+		}
+	}
+
+	return minNum(dp[row-1])
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func minNum(arr []int) int {
+	ans := arr[0]
+
+	for i := 1; i < len(arr); i++ {
+		if arr[i] < ans {
+			ans = arr[i]
+		}
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/124.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.go" "b/124.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.go"
index 2f3ebf9..30ed713 100644
--- "a/124.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.go"
+++ "b/124.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.go"
@@ -1,90 +1,90 @@
-/*
- * @lc app=leetcode.cn id=124 lang=golang
- *
- * [124] 二叉树中的最大路径和
- *
- * https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/description/
- *
- * algorithms
- * Hard (44.83%)
- * Likes:    1532
- * Dislikes: 0
- * Total Accepted:    219.3K
- * Total Submissions: 488.2K
- * Testcase Example:  '[1,2,3]'
- *
- * 路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个
- * 节点，且不一定经过根节点。
- *
- * 路径和 是路径中各节点值的总和。
- *
- * 给你一个二叉树的根节点 root ，返回其 最大路径和 。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：root = [1,2,3]
- * 输出：6
- * 解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6
- *
- * 示例 2：
- *
- *
- * 输入：root = [-10,9,20,null,null,15,7]
- * 输出：42
- * 解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
- *
- *
- *
- *
- * 提示：
- *
- *
- * 树中节点数目范围是 [1, 3 * 10^4]
- * -1000
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func maxPathSum(root *TreeNode) int {
-
-	maxSum := -1000
-	var dfs func(*TreeNode) int
-
-	dfs = func(n *TreeNode) int {
-		if n == nil {
-			return 0
-		}
-		left := max(0, dfs(n.Left))
-		right := max(0, dfs(n.Right))
-
-		maxSum = max(maxSum, n.Val+left+right)
-
-		return n.Val + max(left, right)
-
-	}
-
-	dfs(root)
-	return maxSum
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=124 lang=golang
+ *
+ * [124] 二叉树中的最大路径和
+ *
+ * https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/description/
+ *
+ * algorithms
+ * Hard (44.83%)
+ * Likes:    1532
+ * Dislikes: 0
+ * Total Accepted:    219.3K
+ * Total Submissions: 488.2K
+ * Testcase Example:  '[1,2,3]'
+ *
+ * 路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个
+ * 节点，且不一定经过根节点。
+ *
+ * 路径和 是路径中各节点值的总和。
+ *
+ * 给你一个二叉树的根节点 root ，返回其 最大路径和 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：root = [1,2,3]
+ * 输出：6
+ * 解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：root = [-10,9,20,null,null,15,7]
+ * 输出：42
+ * 解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点数目范围是 [1, 3 * 10^4]
+ * -1000
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func maxPathSum(root *TreeNode) int {
+
+	maxSum := -1000
+	var dfs func(*TreeNode) int
+
+	dfs = func(n *TreeNode) int {
+		if n == nil {
+			return 0
+		}
+		left := max(0, dfs(n.Left))
+		right := max(0, dfs(n.Right))
+
+		maxSum = max(maxSum, n.Val+left+right)
+
+		return n.Val + max(left, right)
+
+	}
+
+	dfs(root)
+	return maxSum
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/129.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.go" "b/129.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.go"
index 73061b4..3cb17c2 100644
--- "a/129.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.go"
+++ "b/129.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.go"
@@ -1,113 +1,113 @@
-/*
- * @lc app=leetcode.cn id=129 lang=golang
- *
- * [129] 求根节点到叶节点数字之和
- *
- * https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/description/
- *
- * algorithms
- * Medium (69.05%)
- * Likes:    510
- * Dislikes: 0
- * Total Accepted:    154.5K
- * Total Submissions: 223.2K
- * Testcase Example:  '[1,2,3]'
- *
- * 给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
- *
- *
- * 每条从根节点到叶节点的路径都代表一个数字：
- *
- *
- * 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
- *
- *
- * 计算从根节点到叶节点生成的 所有数字之和 。
- *
- * 叶节点 是指没有子节点的节点。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：root = [1,2,3]
- * 输出：25
- * 解释：
- * 从根到叶子节点路径 1->2 代表数字 12
- * 从根到叶子节点路径 1->3 代表数字 13
- * 因此，数字总和 = 12 + 13 = 25
- *
- * 示例 2：
- *
- *
- * 输入：root = [4,9,0,5,1]
- * 输出：1026
- * 解释：
- * 从根到叶子节点路径 4->9->5 代表数字 495
- * 从根到叶子节点路径 4->9->1 代表数字 491
- * 从根到叶子节点路径 4->0 代表数字 40
- * 因此，数字总和 = 495 + 491 + 40 = 1026
- *
- *
- *
- *
- * 提示：
- *
- *
- * 树中节点的数目在范围 [1, 1000] 内
- * 0
- * 树的深度不超过 10
- *
- *
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func sumNumbers(root *TreeNode) int {
-
-	if root == nil {
-		return 0
-	}
-
-	result := make([]int, 0)
-	var dfs func(*TreeNode, int)
-
-	dfs = func(n *TreeNode, pre int) {
-		curSum := pre*10 + n.Val
-
-		if n.Left == nil && n.Right == nil {
-			result = append(result, curSum)
-		}
-
-		if n.Left != nil {
-			dfs(n.Left, curSum)
-		}
-		if n.Right != nil {
-			dfs(n.Right, curSum)
-		}
-	}
-
-	dfs(root, 0)
-	return arrSum(result)
-}
-
-func arrSum(arr []int) int {
-	sum := 0
-	for i := range arr {
-		sum += arr[i]
-	}
-	return sum
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=129 lang=golang
+ *
+ * [129] 求根节点到叶节点数字之和
+ *
+ * https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/description/
+ *
+ * algorithms
+ * Medium (69.05%)
+ * Likes:    510
+ * Dislikes: 0
+ * Total Accepted:    154.5K
+ * Total Submissions: 223.2K
+ * Testcase Example:  '[1,2,3]'
+ *
+ * 给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
+ *
+ *
+ * 每条从根节点到叶节点的路径都代表一个数字：
+ *
+ *
+ * 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
+ *
+ *
+ * 计算从根节点到叶节点生成的 所有数字之和 。
+ *
+ * 叶节点 是指没有子节点的节点。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：root = [1,2,3]
+ * 输出：25
+ * 解释：
+ * 从根到叶子节点路径 1->2 代表数字 12
+ * 从根到叶子节点路径 1->3 代表数字 13
+ * 因此，数字总和 = 12 + 13 = 25
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：root = [4,9,0,5,1]
+ * 输出：1026
+ * 解释：
+ * 从根到叶子节点路径 4->9->5 代表数字 495
+ * 从根到叶子节点路径 4->9->1 代表数字 491
+ * 从根到叶子节点路径 4->0 代表数字 40
+ * 因此，数字总和 = 495 + 491 + 40 = 1026
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点的数目在范围 [1, 1000] 内
+ * 0
+ * 树的深度不超过 10
+ *
+ *
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumNumbers(root *TreeNode) int {
+
+	if root == nil {
+		return 0
+	}
+
+	result := make([]int, 0)
+	var dfs func(*TreeNode, int)
+
+	dfs = func(n *TreeNode, pre int) {
+		curSum := pre*10 + n.Val
+
+		if n.Left == nil && n.Right == nil {
+			result = append(result, curSum)
+		}
+
+		if n.Left != nil {
+			dfs(n.Left, curSum)
+		}
+		if n.Right != nil {
+			dfs(n.Right, curSum)
+		}
+	}
+
+	dfs(root, 0)
+	return arrSum(result)
+}
+
+func arrSum(arr []int) int {
+	sum := 0
+	for i := range arr {
+		sum += arr[i]
+	}
+	return sum
+}
+
+// @lc code=end
+
diff --git "a/15.\344\270\211\346\225\260\344\271\213\345\222\214.go" "b/15.\344\270\211\346\225\260\344\271\213\345\222\214.go"
index 92a4085..8a7b2cd 100644
--- "a/15.\344\270\211\346\225\260\344\271\213\345\222\214.go"
+++ "b/15.\344\270\211\346\225\260\344\271\213\345\222\214.go"
@@ -1,100 +1,100 @@
-/*
- * @lc app=leetcode.cn id=15 lang=golang
- *
- * [15] 三数之和
- *
- * https://leetcode-cn.com/problems/3sum/description/
- *
- * algorithms
- * Medium (34.84%)
- * Likes:    4648
- * Dislikes: 0
- * Total Accepted:    917.7K
- * Total Submissions: 2.6M
- * Testcase Example:  '[-1,0,1,2,-1,-4]'
- *
- * 给你一个包含 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
- * -10^5
- *
- *
- */
-
-// @lc code=start
-/*
-	先将数组排序, 然后遍历
-	对于遍历的每一项, 用双指针找到满足num[i] + num[left] + num[right] = 0的3个index
-	数组有重复元素, 需要跳过重复的元素
-*/
-func threeSum(nums []int) [][]int {
-	n := len(nums)
-	sort.Ints(nums)
-	ans := make([][]int, 0)
-
-	// 枚举 a
-	for first := 0; first < n; first++ {
-		// 需要和上一次枚举的数不相同
-		if first > 0 && nums[first] == nums[first-1] {
-			continue
-		}
-		// c 对应的指针初始指向数组的最右端
-		sum := 0
-		third := n - 1
-		target := sum - nums[first]
-		// 枚举 b
-		for second := first + 1; second < n; second++ {
-			// 需要和上一次枚举的数不相同
-			if second > first+1 && nums[second] == nums[second-1] {
-				continue
-			}
-			// 需要保证 b 的指针在 c 的指针的左侧
-			for second < third && nums[second]+nums[third] > target {
-				third--
-			}
-			// 如果指针重合，随着 b 后续的增加
-			// 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
-			if second == third {
-				break
-			}
-			if nums[second]+nums[third] == target {
-				ans = append(ans, []int{nums[first], nums[second], nums[third]})
-			}
-		}
-	}
-	return ans
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=15 lang=golang
+ *
+ * [15] 三数之和
+ *
+ * https://leetcode-cn.com/problems/3sum/description/
+ *
+ * algorithms
+ * Medium (34.84%)
+ * Likes:    4648
+ * Dislikes: 0
+ * Total Accepted:    917.7K
+ * Total Submissions: 2.6M
+ * Testcase Example:  '[-1,0,1,2,-1,-4]'
+ *
+ * 给你一个包含 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
+ * -10^5
+ *
+ *
+ */
+
+// @lc code=start
+/*
+	先将数组排序, 然后遍历
+	对于遍历的每一项, 用双指针找到满足num[i] + num[left] + num[right] = 0的3个index
+	数组有重复元素, 需要跳过重复的元素
+*/
+func threeSum(nums []int) [][]int {
+	n := len(nums)
+	sort.Ints(nums)
+	ans := make([][]int, 0)
+
+	// 枚举 a
+	for first := 0; first < n; first++ {
+		// 需要和上一次枚举的数不相同
+		if first > 0 && nums[first] == nums[first-1] {
+			continue
+		}
+		// c 对应的指针初始指向数组的最右端
+		sum := 0
+		third := n - 1
+		target := sum - nums[first]
+		// 枚举 b
+		for second := first + 1; second < n; second++ {
+			// 需要和上一次枚举的数不相同
+			if second > first+1 && nums[second] == nums[second-1] {
+				continue
+			}
+			// 需要保证 b 的指针在 c 的指针的左侧
+			for second < third && nums[second]+nums[third] > target {
+				third--
+			}
+			// 如果指针重合，随着 b 后续的增加
+			// 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
+			if second == third {
+				break
+			}
+			if nums[second]+nums[third] == target {
+				ans = append(ans, []int{nums[first], nums[second], nums[third]})
+			}
+		}
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/168.excel\350\241\250\345\210\227\345\220\215\347\247\260.go" "b/168.excel\350\241\250\345\210\227\345\220\215\347\247\260.go"
index 20e906b..36e0504 100644
--- "a/168.excel\350\241\250\345\210\227\345\220\215\347\247\260.go"
+++ "b/168.excel\350\241\250\345\210\227\345\220\215\347\247\260.go"
@@ -1,87 +1,87 @@
-/*
- * @lc app=leetcode.cn id=168 lang=golang
- *
- * [168] Excel表列名称
- *
- * https://leetcode-cn.com/problems/excel-sheet-column-title/description/
- *
- * algorithms
- * Easy (43.46%)
- * Likes:    520
- * Dislikes: 0
- * Total Accepted:    103.5K
- * Total Submissions: 237.7K
- * Testcase Example:  '1'
- *
- * 给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。
- *
- * 例如：
- *
- *
- * A -> 1
- * B -> 2
- * C -> 3
- * ...
- * Z -> 26
- * AA -> 27
- * AB -> 28
- * ...
- *
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：columnNumber = 1
- * 输出："A"
- *
- *
- * 示例 2：
- *
- *
- * 输入：columnNumber = 28
- * 输出："AB"
- *
- *
- * 示例 3：
- *
- *
- * 输入：columnNumber = 701
- * 输出："ZY"
- *
- *
- * 示例 4：
- *
- *
- * 输入：columnNumber = 2147483647
- * 输出："FXSHRXW"
- *
- *
- *
- *
- * 提示：
- *
- *
- * 1
- *
- *
- */
-
-// @lc code=start
-func convertToTitle(columnNumber int) string {
-
-	ans := []byte{}
-	for columnNumber != 0 {
-		left := (columnNumber-1)%26 + 1
-		// 1 -- A(65)
-		ans = append([]byte{byte(left + 64)}, ans...)
-
-		columnNumber = (columnNumber - left) / 26
-	}
-	return string(ans)
-
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=168 lang=golang
+ *
+ * [168] Excel表列名称
+ *
+ * https://leetcode-cn.com/problems/excel-sheet-column-title/description/
+ *
+ * algorithms
+ * Easy (43.46%)
+ * Likes:    520
+ * Dislikes: 0
+ * Total Accepted:    103.5K
+ * Total Submissions: 237.7K
+ * Testcase Example:  '1'
+ *
+ * 给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。
+ *
+ * 例如：
+ *
+ *
+ * A -> 1
+ * B -> 2
+ * C -> 3
+ * ...
+ * Z -> 26
+ * AA -> 27
+ * AB -> 28
+ * ...
+ *
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：columnNumber = 1
+ * 输出："A"
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：columnNumber = 28
+ * 输出："AB"
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：columnNumber = 701
+ * 输出："ZY"
+ *
+ *
+ * 示例 4：
+ *
+ *
+ * 输入：columnNumber = 2147483647
+ * 输出："FXSHRXW"
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1
+ *
+ *
+ */
+
+// @lc code=start
+func convertToTitle(columnNumber int) string {
+
+	ans := []byte{}
+	for columnNumber != 0 {
+		left := (columnNumber-1)%26 + 1
+		// 1 -- A(65)
+		ans = append([]byte{byte(left + 64)}, ans...)
+
+		columnNumber = (columnNumber - left) / 26
+	}
+	return string(ans)
+
+}
+
+// @lc code=end
+
diff --git "a/169.\345\244\232\346\225\260\345\205\203\347\264\240.go" "b/169.\345\244\232\346\225\260\345\205\203\347\264\240.go"
index c6e0dfc..bd1ecb8 100644
--- "a/169.\345\244\232\346\225\260\345\205\203\347\264\240.go"
+++ "b/169.\345\244\232\346\225\260\345\205\203\347\264\240.go"
@@ -1,65 +1,65 @@
-/*
- * @lc app=leetcode.cn id=169 lang=golang
- *
- * [169] 多数元素
- *
- * https://leetcode-cn.com/problems/majority-element/description/
- *
- * algorithms
- * Easy (66.57%)
- * Likes:    1376
- * Dislikes: 0
- * Total Accepted:    487.6K
- * Total Submissions: 732.1K
- * Testcase Example:  '[3,2,3]'
- *
- * 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
- *
- * 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：[3,2,3]
- * 输出：3
- *
- * 示例 2：
- *
- *
- * 输入：[2,2,1,1,1,2,2]
- * 输出：2
- *
- *
- *
- *
- * 进阶：
- *
- *
- * 尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。
- *
- *
- */
-
-// @lc code=start
-// Boyer-Moore 投票算法
-func majorityElement(nums []int) int {
-	count, candidate := 0, -1
-	for i := 0; i < len(nums); i++ {
-		if count == 0 {
-			candidate = nums[i]
-		}
-
-		if nums[i] == candidate {
-			count++
-		} else {
-			count--
-		}
-	}
-
-	return candidate
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=169 lang=golang
+ *
+ * [169] 多数元素
+ *
+ * https://leetcode-cn.com/problems/majority-element/description/
+ *
+ * algorithms
+ * Easy (66.57%)
+ * Likes:    1376
+ * Dislikes: 0
+ * Total Accepted:    487.6K
+ * Total Submissions: 732.1K
+ * Testcase Example:  '[3,2,3]'
+ *
+ * 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
+ *
+ * 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：[3,2,3]
+ * 输出：3
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：[2,2,1,1,1,2,2]
+ * 输出：2
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。
+ *
+ *
+ */
+
+// @lc code=start
+// Boyer-Moore 投票算法
+func majorityElement(nums []int) int {
+	count, candidate := 0, -1
+	for i := 0; i < len(nums); i++ {
+		if count == 0 {
+			candidate = nums[i]
+		}
+
+		if nums[i] == candidate {
+			count++
+		} else {
+			count--
+		}
+	}
+
+	return candidate
+}
+
+// @lc code=end
+
diff --git "a/2.\344\270\244\346\225\260\347\233\270\345\212\240.go" "b/2.\344\270\244\346\225\260\347\233\270\345\212\240.go"
index badcfa7..21de959 100644
--- "a/2.\344\270\244\346\225\260\347\233\270\345\212\240.go"
+++ "b/2.\344\270\244\346\225\260\347\233\270\345\212\240.go"
@@ -1,66 +1,66 @@
-/*
- * @lc app=leetcode.cn id=2 lang=golang
- *
- * [2] 两数相加
- */
-
-// @lc code=start
-/**
- * Definition for singly-linked list.
- * type ListNode struct {
- *     Val int
- *     Next *ListNode
- * }
- */
-func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
-
-	var (
-		head, tail *ListNode
-		carry      = 0
-	)
-
-	for l1 != nil || l2 != nil {
-		n1, n2 := 0, 0
-		if l1 != nil {
-			n1 = l1.Val
-			// 移动l1
-			l1 = l1.Next
-		}
-		if l2 != nil {
-			n2 = l2.Val
-			// 移动l2
-			l2 = l2.Next
-		}
-		sum := n1 + n2 + carry
-		left := sum % 10
-		carry = sum / 10
-
-		if head == nil {
-			// 初始化tail, head
-			head = &ListNode{
-				Val: left,
-			}
-			tail = head
-		} else {
-			node := &ListNode{
-				Val: left,
-			}
-			// 移动tail
-			tail.Next = node
-			tail = tail.Next
-		}
-	}
-
-	if carry > 0 {
-		node := &ListNode{
-			Val: carry,
-		}
-		tail.Next = node
-
-	}
-	return head
-
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=2 lang=golang
+ *
+ * [2] 两数相加
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+
+	var (
+		head, tail *ListNode
+		carry      = 0
+	)
+
+	for l1 != nil || l2 != nil {
+		n1, n2 := 0, 0
+		if l1 != nil {
+			n1 = l1.Val
+			// 移动l1
+			l1 = l1.Next
+		}
+		if l2 != nil {
+			n2 = l2.Val
+			// 移动l2
+			l2 = l2.Next
+		}
+		sum := n1 + n2 + carry
+		left := sum % 10
+		carry = sum / 10
+
+		if head == nil {
+			// 初始化tail, head
+			head = &ListNode{
+				Val: left,
+			}
+			tail = head
+		} else {
+			node := &ListNode{
+				Val: left,
+			}
+			// 移动tail
+			tail.Next = node
+			tail = tail.Next
+		}
+	}
+
+	if carry > 0 {
+		node := &ListNode{
+			Val: carry,
+		}
+		tail.Next = node
+
+	}
+	return head
+
+}
+
+// @lc code=end
+
diff --git "a/202.\345\277\253\344\271\220\346\225\260.go" "b/202.\345\277\253\344\271\220\346\225\260.go"
index 7594e02..ee3fd24 100644
--- "a/202.\345\277\253\344\271\220\346\225\260.go"
+++ "b/202.\345\277\253\344\271\220\346\225\260.go"
@@ -1,86 +1,86 @@
-/*
- * @lc app=leetcode.cn id=202 lang=golang
- *
- * [202] 快乐数
- *
- * https://leetcode-cn.com/problems/happy-number/description/
- *
- * algorithms
- * Easy (62.50%)
- * Likes:    900
- * Dislikes: 0
- * Total Accepted:    234.8K
- * Total Submissions: 374.8K
- * Testcase Example:  '19'
- *
- * 编写一个算法来判断一个数 n 是不是快乐数。
- *
- * 「快乐数」 定义为：
- *
- *
- * 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
- * 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
- * 如果这个过程 结果为 1，那么这个数就是快乐数。
- *
- *
- * 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：n = 19
- * 输出：true
- * 解释：
- * 1^2 + 9^2 = 82
- * 8^2 + 2^2 = 68
- * 6^2 + 8^2 = 100
- * 1^2 + 0^2 + 0^2 = 1
- *
- *
- * 示例 2：
- *
- *
- * 输入：n = 2
- * 输出：false
- *
- *
- *
- *
- * 提示：
- *
- *
- * 1 <= n <= 2^31 - 1
- *
- *
- */
-
-// @lc code=start
-func isHappy(n int) bool {
-	// 为处理过的数字建立缓存, 防止发生死循环
-	cache := make(map[int]bool)
-
-	for n != 1 {
-		if cache[n] {
-			return false
-		} else {
-			cache[n] = true
-			n = getNew(n)
-		}
-	}
-	return true
-}
-
-func getNew(n int) int {
-	ret := 0
-	for n != 0 {
-		last := n % 10
-		ret += last * last
-		n /= 10
-	}
-	return ret
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=202 lang=golang
+ *
+ * [202] 快乐数
+ *
+ * https://leetcode-cn.com/problems/happy-number/description/
+ *
+ * algorithms
+ * Easy (62.50%)
+ * Likes:    900
+ * Dislikes: 0
+ * Total Accepted:    234.8K
+ * Total Submissions: 374.8K
+ * Testcase Example:  '19'
+ *
+ * 编写一个算法来判断一个数 n 是不是快乐数。
+ *
+ * 「快乐数」 定义为：
+ *
+ *
+ * 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
+ * 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
+ * 如果这个过程 结果为 1，那么这个数就是快乐数。
+ *
+ *
+ * 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：n = 19
+ * 输出：true
+ * 解释：
+ * 1^2 + 9^2 = 82
+ * 8^2 + 2^2 = 68
+ * 6^2 + 8^2 = 100
+ * 1^2 + 0^2 + 0^2 = 1
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：n = 2
+ * 输出：false
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= n <= 2^31 - 1
+ *
+ *
+ */
+
+// @lc code=start
+func isHappy(n int) bool {
+	// 为处理过的数字建立缓存, 防止发生死循环
+	cache := make(map[int]bool)
+
+	for n != 1 {
+		if cache[n] {
+			return false
+		} else {
+			cache[n] = true
+			n = getNew(n)
+		}
+	}
+	return true
+}
+
+func getNew(n int) int {
+	ret := 0
+	for n != 0 {
+		last := n % 10
+		ret += last * last
+		n /= 10
+	}
+	return ret
+}
+
+// @lc code=end
+
diff --git "a/233.\346\225\260\345\255\227-1-\347\232\204\344\270\252\346\225\260.go" "b/233.\346\225\260\345\255\227-1-\347\232\204\344\270\252\346\225\260.go"
index 642def8..06ff325 100644
--- "a/233.\346\225\260\345\255\227-1-\347\232\204\344\270\252\346\225\260.go"
+++ "b/233.\346\225\260\345\255\227-1-\347\232\204\344\270\252\346\225\260.go"
@@ -1,50 +1,50 @@
-/*
- * @lc app=leetcode.cn id=233 lang=golang
- *
- * [233] 数字 1 的个数
- *
- * https://leetcode-cn.com/problems/number-of-digit-one/description/
- *
- * algorithms
- * Hard (48.01%)
- * Likes:    412
- * Dislikes: 0
- * Total Accepted:    40.7K
- * Total Submissions: 84.6K
- * Testcase Example:  '13'
- *
- * 给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。
- * 
- * 
- * 
- * 示例 1：
- * 
- * 
- * 输入：n = 13
- * 输出：6
- * 
- * 
- * 示例 2：
- * 
- * 
- * 输入：n = 0
- * 输出：0
- * 
- * 
- * 
- * 
- * 提示：
- * 
- * 
- * 0 <= n <= 10^9
- * 
- * 
- */
-
-// @lc code=start
-func countDigitOne(n int) int {
-	// 13: 1101
-
-}
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=233 lang=golang
+ *
+ * [233] 数字 1 的个数
+ *
+ * https://leetcode-cn.com/problems/number-of-digit-one/description/
+ *
+ * algorithms
+ * Hard (48.01%)
+ * Likes:    412
+ * Dislikes: 0
+ * Total Accepted:    40.7K
+ * Total Submissions: 84.6K
+ * Testcase Example:  '13'
+ *
+ * 给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。
+ * 
+ * 
+ * 
+ * 示例 1：
+ * 
+ * 
+ * 输入：n = 13
+ * 输出：6
+ * 
+ * 
+ * 示例 2：
+ * 
+ * 
+ * 输入：n = 0
+ * 输出：0
+ * 
+ * 
+ * 
+ * 
+ * 提示：
+ * 
+ * 
+ * 0 <= n <= 10^9
+ * 
+ * 
+ */
+
+// @lc code=start
+func countDigitOne(n int) int {
+	// 13: 1101
+
+}
+// @lc code=end
+
diff --git "a/235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.go" "b/235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.go"
index da7fe9e..88791a0 100644
--- "a/235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.go"
+++ "b/235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.go"
@@ -1,105 +1,105 @@
-/*
- * @lc app=leetcode.cn id=235 lang=golang
- *
- * [235] 二叉搜索树的最近公共祖先
- *
- * https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/
- *
- * algorithms
- * Easy (67.04%)
- * Likes:    798
- * Dislikes: 0
- * Total Accepted:    217.7K
- * Total Submissions: 324.7K
- * Testcase Example:  '[6,2,8,0,4,7,9,null,null,3,5]\n2\n8'
- *
- * 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
- *
- * 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x
- * 的深度尽可能大（一个节点也可以是它自己的祖先）。”
- *
- * 例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]
- *
- *
- *
- *
- *
- * 示例 1:
- *
- * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
- * 输出: 6
- * 解释: 节点 2 和节点 8 的最近公共祖先是 6。
- *
- *
- * 示例 2:
- *
- * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
- * 输出: 2
- * 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
- *
- *
- *
- * 说明:
- *
- *
- * 所有节点的值都是唯一的。
- * p、q 为不同节点且均存在于给定的二叉搜索树中。
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val   int
- *     Left  *TreeNode
- *     Right *TreeNode
- * }
- */
-
-/*
-	因为是binary search tree, 生成到达p, q的path
-	最近公共祖先为两个path最后一个相等的node
-*/
-func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
-	if root == nil {
-		return nil
-	}
-
-	path1 := getPath(root, p)
-	path2 := getPath(root, q)
-
-	i := 0
-	ancestor := root
-	for i < len(path1) && i < len(path2) {
-		if path1[i].Val == path2[i].Val {
-			ancestor = path1[i]
-			i++
-		} else {
-			break
-		}
-	}
-	return ancestor
-}
-
-func getPath(root, n *TreeNode) []*TreeNode {
-	path := []*TreeNode{}
-	node := root
-	for node != nil {
-		if node.Val == n.Val {
-			path = append(path, node)
-			break
-		} else if node.Val < n.Val {
-			path = append(path, node)
-			node = node.Right
-		} else {
-			path = append(path, node)
-			node = node.Left
-		}
-	}
-	return path
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=235 lang=golang
+ *
+ * [235] 二叉搜索树的最近公共祖先
+ *
+ * https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/
+ *
+ * algorithms
+ * Easy (67.04%)
+ * Likes:    798
+ * Dislikes: 0
+ * Total Accepted:    217.7K
+ * Total Submissions: 324.7K
+ * Testcase Example:  '[6,2,8,0,4,7,9,null,null,3,5]\n2\n8'
+ *
+ * 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
+ *
+ * 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x
+ * 的深度尽可能大（一个节点也可以是它自己的祖先）。”
+ *
+ * 例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]
+ *
+ *
+ *
+ *
+ *
+ * 示例 1:
+ *
+ * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
+ * 输出: 6
+ * 解释: 节点 2 和节点 8 的最近公共祖先是 6。
+ *
+ *
+ * 示例 2:
+ *
+ * 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
+ * 输出: 2
+ * 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
+ *
+ *
+ *
+ * 说明:
+ *
+ *
+ * 所有节点的值都是唯一的。
+ * p、q 为不同节点且均存在于给定的二叉搜索树中。
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val   int
+ *     Left  *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+/*
+	因为是binary search tree, 生成到达p, q的path
+	最近公共祖先为两个path最后一个相等的node
+*/
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if root == nil {
+		return nil
+	}
+
+	path1 := getPath(root, p)
+	path2 := getPath(root, q)
+
+	i := 0
+	ancestor := root
+	for i < len(path1) && i < len(path2) {
+		if path1[i].Val == path2[i].Val {
+			ancestor = path1[i]
+			i++
+		} else {
+			break
+		}
+	}
+	return ancestor
+}
+
+func getPath(root, n *TreeNode) []*TreeNode {
+	path := []*TreeNode{}
+	node := root
+	for node != nil {
+		if node.Val == n.Val {
+			path = append(path, node)
+			break
+		} else if node.Val < n.Val {
+			path = append(path, node)
+			node = node.Right
+		} else {
+			path = append(path, node)
+			node = node.Left
+		}
+	}
+	return path
+}
+
+// @lc code=end
+
diff --git "a/239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.go" "b/239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.go"
index 26ea5cb..a7159ef 100644
--- "a/239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.go"
+++ "b/239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.go"
@@ -1,50 +1,50 @@
-/*
- * @lc app=leetcode.cn id=239 lang=golang
- *
- * [239] 滑动窗口最大值
- */
-// @lc code=start
-
-var a []int
-
-type hp struct{ sort.IntSlice }
-
-func (h hp) Less(i, j int) bool  { return a[h.IntSlice[i]] > a[h.IntSlice[j]] }
-func (h *hp) Push(v interface{}) { h.IntSlice = append(h.IntSlice, v.(int)) }
-func (h *hp) Pop() interface{} {
-	a := h.IntSlice
-	v := a[len(a)-1]
-	h.IntSlice = a[:len(a)-1]
-	return v
-}
-
-/*
-构造一个max heap, 队列元素存储原数组元素的index
-
-1. 每移动1位, push(j)进heap
-2. 检查heap[0]下标是否越界, 越界就执行pop()
-3. heap[0]即为当前位置最大值
-*/
-func maxSlidingWindow(nums []int, k int) []int {
-	a = nums
-	q := &hp{make([]int, k)}
-	for i := 0; i < k; i++ {
-		q.IntSlice[i] = i
-	}
-	heap.Init(q)
-
-	n := len(nums)
-	ans := make([]int, 1, n-k+1)
-	ans[0] = nums[q.IntSlice[0]]
-	for i := k; i < n; i++ {
-		heap.Push(q, i)
-		for q.IntSlice[0] <= i-k {
-			heap.Pop(q)
-		}
-		ans = append(ans, nums[q.IntSlice[0]])
-	}
-	return ans
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=239 lang=golang
+ *
+ * [239] 滑动窗口最大值
+ */
+// @lc code=start
+
+var a []int
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool  { return a[h.IntSlice[i]] > a[h.IntSlice[j]] }
+func (h *hp) Push(v interface{}) { h.IntSlice = append(h.IntSlice, v.(int)) }
+func (h *hp) Pop() interface{} {
+	a := h.IntSlice
+	v := a[len(a)-1]
+	h.IntSlice = a[:len(a)-1]
+	return v
+}
+
+/*
+构造一个max heap, 队列元素存储原数组元素的index
+
+1. 每移动1位, push(j)进heap
+2. 检查heap[0]下标是否越界, 越界就执行pop()
+3. heap[0]即为当前位置最大值
+*/
+func maxSlidingWindow(nums []int, k int) []int {
+	a = nums
+	q := &hp{make([]int, k)}
+	for i := 0; i < k; i++ {
+		q.IntSlice[i] = i
+	}
+	heap.Init(q)
+
+	n := len(nums)
+	ans := make([]int, 1, n-k+1)
+	ans[0] = nums[q.IntSlice[0]]
+	for i := k; i < n; i++ {
+		heap.Push(q, i)
+		for q.IntSlice[0] <= i-k {
+			heap.Pop(q)
+		}
+		ans = append(ans, nums[q.IntSlice[0]])
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/24.\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.go" "b/24.\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.go"
index 2b4275d..643b163 100644
--- "a/24.\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.go"
+++ "b/24.\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.go"
@@ -1,73 +1,73 @@
-/*
- * @lc app=leetcode.cn id=24 lang=golang
- *
- * [24] 两两交换链表中的节点
- *
- * https://leetcode-cn.com/problems/swap-nodes-in-pairs/description/
- *
- * algorithms
- * Medium (70.67%)
- * Likes:    1352
- * Dislikes: 0
- * Total Accepted:    422.7K
- * Total Submissions: 597.5K
- * Testcase Example:  '[1,2,3,4]'
- *
- * 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：head = [1,2,3,4]
- * 输出：[2,1,4,3]
- *
- *
- * 示例 2：
- *
- *
- * 输入：head = []
- * 输出：[]
- *
- *
- * 示例 3：
- *
- *
- * 输入：head = [1]
- * 输出：[1]
- *
- *
- *
- *
- * 提示：
- *
- *
- * 链表中节点的数目在范围 [0, 100] 内
- * 0 <= Node.val <= 100
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for singly-linked list.
- * type ListNode struct {
- *     Val int
- *     Next *ListNode
- * }
- */
-func swapPairs(head *ListNode) *ListNode {
-	if head == nil || head.Next == nil {
-		return head
-	}
-
-	newHead := head.Next
-	head.Next = swapPairs(newHead.Next)
-	newHead.Next = head
-	return newHead
-
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=24 lang=golang
+ *
+ * [24] 两两交换链表中的节点
+ *
+ * https://leetcode-cn.com/problems/swap-nodes-in-pairs/description/
+ *
+ * algorithms
+ * Medium (70.67%)
+ * Likes:    1352
+ * Dislikes: 0
+ * Total Accepted:    422.7K
+ * Total Submissions: 597.5K
+ * Testcase Example:  '[1,2,3,4]'
+ *
+ * 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：head = [1,2,3,4]
+ * 输出：[2,1,4,3]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：head = []
+ * 输出：[]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：head = [1]
+ * 输出：[1]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 链表中节点的数目在范围 [0, 100] 内
+ * 0 <= Node.val <= 100
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func swapPairs(head *ListNode) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+
+	newHead := head.Next
+	head.Next = swapPairs(newHead.Next)
+	newHead.Next = head
+	return newHead
+
+}
+
+// @lc code=end
+
diff --git "a/278.\347\254\254\344\270\200\344\270\252\351\224\231\350\257\257\347\232\204\347\211\210\346\234\254.go" "b/278.\347\254\254\344\270\200\344\270\252\351\224\231\350\257\257\347\232\204\347\211\210\346\234\254.go"
new file mode 100644
index 0000000..f072ad2
--- /dev/null
+++ "b/278.\347\254\254\344\270\200\344\270\252\351\224\231\350\257\257\347\232\204\347\211\210\346\234\254.go"
@@ -0,0 +1,79 @@
+/*
+ * @lc app=leetcode.cn id=278 lang=golang
+ *
+ * [278] 第一个错误的版本
+ *
+ * https://leetcode-cn.com/problems/first-bad-version/description/
+ *
+ * algorithms
+ * Easy (45.13%)
+ * Likes:    667
+ * Dislikes: 0
+ * Total Accepted:    313.5K
+ * Total Submissions: 694.6K
+ * Testcase Example:  '5\n4'
+ *
+ *
+ * 你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
+ *
+ * 假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
+ *
+ * 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version
+ * 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：n = 5, bad = 4
+ * 输出：4
+ * 解释：
+ * 调用 isBadVersion(3) -> false
+ * 调用 isBadVersion(5) -> true
+ * 调用 isBadVersion(4) -> true
+ * 所以，4 是第一个错误的版本。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：n = 1, bad = 1
+ * 输出：1
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Forward declaration of isBadVersion API.
+ * @param   version   your guess about first bad version
+ * @return 	 	      true if current version is bad
+ *			          false if current version is good
+ * func isBadVersion(version int) bool;
+ */
+
+func firstBadVersion(n int) int {
+	left, right := 1, n
+	for left < right {
+		mid := left + (right-left)/2
+
+		if isBadVersion(mid) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	return left
+
+}
+
+// @lc code=end
+
diff --git "a/3.\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.go" "b/3.\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.go"
index bb6dcf7..3cb211b 100644
--- "a/3.\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.go"
+++ "b/3.\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.go"
@@ -1,97 +1,97 @@
-/*
- * @lc app=leetcode.cn id=3 lang=golang
- *
- * [3] 无重复字符的最长子串
- *
- * https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/description/
- *
- * algorithms
- * Medium (38.57%)
- * Likes:    7338
- * Dislikes: 0
- * Total Accepted:    1.6M
- * Total Submissions: 4.3M
- * Testcase Example:  '"abcabcbb"'
- *
- * 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
- *
- *
- *
- * 示例 1:
- *
- *
- * 输入: s = "abcabcbb"
- * 输出: 3
- * 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
- *
- *
- * 示例 2:
- *
- *
- * 输入: s = "bbbbb"
- * 输出: 1
- * 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
- *
- *
- * 示例 3:
- *
- *
- * 输入: s = "pwwkew"
- * 输出: 3
- * 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
- * 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
- *
- *
- *
- *
- * 提示：
- *
- *
- * 0 <= s.length <= 5 * 10^4
- * s 由英文字母、数字、符号和空格组成
- *
- *
- */
-
-// @lc code=start
-func lengthOfLongestSubstring(s string) int {
-
-	m := make(map[byte]int, 0)
-
-	maxLen := 0
-	preLen := 0
-	for i := range s {
-		char := s[i] // byte
-		if v, ok := m[char]; ok {
-			m[char] = i
-			preLen = i - v
-			// 删除index小于v的所有key
-			cleanCache(m, v)
-		} else {
-			m[char] = i
-			currentLen := preLen + 1
-			maxLen = max(currentLen, maxLen)
-			preLen = currentLen
-		}
-
-	}
-	return maxLen
-}
-
-func cleanCache(m map[byte]int, i int) {
-	for k, v := range m {
-		if v <= i {
-			delete(m, k)
-		}
-	}
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=3 lang=golang
+ *
+ * [3] 无重复字符的最长子串
+ *
+ * https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/description/
+ *
+ * algorithms
+ * Medium (38.57%)
+ * Likes:    7338
+ * Dislikes: 0
+ * Total Accepted:    1.6M
+ * Total Submissions: 4.3M
+ * Testcase Example:  '"abcabcbb"'
+ *
+ * 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
+ *
+ *
+ *
+ * 示例 1:
+ *
+ *
+ * 输入: s = "abcabcbb"
+ * 输出: 3
+ * 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入: s = "bbbbb"
+ * 输出: 1
+ * 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+ *
+ *
+ * 示例 3:
+ *
+ *
+ * 输入: s = "pwwkew"
+ * 输出: 3
+ * 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+ * 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 0 <= s.length <= 5 * 10^4
+ * s 由英文字母、数字、符号和空格组成
+ *
+ *
+ */
+
+// @lc code=start
+func lengthOfLongestSubstring(s string) int {
+
+	m := make(map[byte]int, 0)
+
+	maxLen := 0
+	preLen := 0
+	for i := range s {
+		char := s[i] // byte
+		if v, ok := m[char]; ok {
+			m[char] = i
+			preLen = i - v
+			// 删除index小于v的所有key
+			cleanCache(m, v)
+		} else {
+			m[char] = i
+			currentLen := preLen + 1
+			maxLen = max(currentLen, maxLen)
+			preLen = currentLen
+		}
+
+	}
+	return maxLen
+}
+
+func cleanCache(m map[byte]int, i int) {
+	for k, v := range m {
+		if v <= i {
+			delete(m, k)
+		}
+	}
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/382.\351\223\276\350\241\250\351\232\217\346\234\272\350\212\202\347\202\271.go" "b/382.\351\223\276\350\241\250\351\232\217\346\234\272\350\212\202\347\202\271.go"
index 67e90cc..08592de 100644
--- "a/382.\351\223\276\350\241\250\351\232\217\346\234\272\350\212\202\347\202\271.go"
+++ "b/382.\351\223\276\350\241\250\351\232\217\346\234\272\350\212\202\347\202\271.go"
@@ -1,108 +1,108 @@
-/*
- * @lc app=leetcode.cn id=382 lang=golang
- *
- * [382] 链表随机节点
- *
- * https://leetcode-cn.com/problems/linked-list-random-node/description/
- *
- * algorithms
- * Medium (71.83%)
- * Likes:    269
- * Dislikes: 0
- * Total Accepted:    43.7K
- * Total Submissions: 60.7K
- * Testcase Example:  '["Solution","getRandom","getRandom","getRandom","getRandom","getRandom"]\n' +
-  '[[[1,2,3]],[],[],[],[],[]]'
- *
- * 给你一个单链表，随机选择链表的一个节点，并返回相应的节点值。每个节点 被选中的概率一样 。
- *
- * 实现 Solution 类：
- *
- *
- * Solution(ListNode head) 使用整数数组初始化对象。
- * int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。
- *
- *
- *
- *
- * 示例：
- *
- *
- * 输入
- * ["Solution", "getRandom", "getRandom", "getRandom", "getRandom",
- * "getRandom"]
- * [[[1, 2, 3]], [], [], [], [], []]
- * 输出
- * [null, 1, 3, 2, 2, 3]
- *
- * 解释
- * Solution solution = new Solution([1, 2, 3]);
- * solution.getRandom(); // 返回 1
- * solution.getRandom(); // 返回 3
- * solution.getRandom(); // 返回 2
- * solution.getRandom(); // 返回 2
- * solution.getRandom(); // 返回 3
- * // getRandom() 方法应随机返回 1、2、3中的一个，每个元素被返回的概率相等。
- *
- *
- *
- * 提示：
- *
- *
- * 链表中的节点数在范围 [1, 10^4] 内
- * -10^4 <= Node.val <= 10^4
- * 至多调用 getRandom 方法 10^4 次
- *
- *
- *
- *
- * 进阶：
- *
- *
- * 如果链表非常大且长度未知，该怎么处理？
- * 你能否在不使用额外空间的情况下解决此问题？
- *
- *
-*/
-
-// @lc code=start
-/**
- * Definition for singly-linked list.
- * type ListNode struct {
- *     Val int
- *     Next *ListNode
- * }
- */
-type Solution struct {
-	Head *ListNode
-}
-
-func Constructor(head *ListNode) Solution {
-	return Solution{
-		Head: head,
-	}
-
-}
-
-// 水塘抽样
-func (s *Solution) GetRandom() int {
-	i := 1
-	node := s.Head
-	var ans int
-	for node != nil {
-		if rand.Intn(i) == 0 {
-			ans = node.Val
-		}
-		node = node.Next
-		i++
-	}
-	return ans
-}
-
-/**
- * Your Solution object will be instantiated and called as such:
- * obj := Constructor(head);
- * param_1 := obj.GetRandom();
- */
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=382 lang=golang
+ *
+ * [382] 链表随机节点
+ *
+ * https://leetcode-cn.com/problems/linked-list-random-node/description/
+ *
+ * algorithms
+ * Medium (71.83%)
+ * Likes:    269
+ * Dislikes: 0
+ * Total Accepted:    43.7K
+ * Total Submissions: 60.7K
+ * Testcase Example:  '["Solution","getRandom","getRandom","getRandom","getRandom","getRandom"]\n' +
+  '[[[1,2,3]],[],[],[],[],[]]'
+ *
+ * 给你一个单链表，随机选择链表的一个节点，并返回相应的节点值。每个节点 被选中的概率一样 。
+ *
+ * 实现 Solution 类：
+ *
+ *
+ * Solution(ListNode head) 使用整数数组初始化对象。
+ * int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。
+ *
+ *
+ *
+ *
+ * 示例：
+ *
+ *
+ * 输入
+ * ["Solution", "getRandom", "getRandom", "getRandom", "getRandom",
+ * "getRandom"]
+ * [[[1, 2, 3]], [], [], [], [], []]
+ * 输出
+ * [null, 1, 3, 2, 2, 3]
+ *
+ * 解释
+ * Solution solution = new Solution([1, 2, 3]);
+ * solution.getRandom(); // 返回 1
+ * solution.getRandom(); // 返回 3
+ * solution.getRandom(); // 返回 2
+ * solution.getRandom(); // 返回 2
+ * solution.getRandom(); // 返回 3
+ * // getRandom() 方法应随机返回 1、2、3中的一个，每个元素被返回的概率相等。
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 链表中的节点数在范围 [1, 10^4] 内
+ * -10^4 <= Node.val <= 10^4
+ * 至多调用 getRandom 方法 10^4 次
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 如果链表非常大且长度未知，该怎么处理？
+ * 你能否在不使用额外空间的情况下解决此问题？
+ *
+ *
+*/
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+type Solution struct {
+	Head *ListNode
+}
+
+func Constructor(head *ListNode) Solution {
+	return Solution{
+		Head: head,
+	}
+
+}
+
+// 水塘抽样
+func (s *Solution) GetRandom() int {
+	i := 1
+	node := s.Head
+	var ans int
+	for node != nil {
+		if rand.Intn(i) == 0 {
+			ans = node.Val
+		}
+		node = node.Next
+		i++
+	}
+	return ans
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * obj := Constructor(head);
+ * param_1 := obj.GetRandom();
+ */
+// @lc code=end
+
diff --git "a/404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.go" "b/404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.go"
index eec4445..98532a6 100644
--- "a/404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.go"
+++ "b/404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.go"
@@ -1,95 +1,95 @@
-/*
- * @lc app=leetcode.cn id=404 lang=golang
- *
- * [404] 左叶子之和
- *
- * https://leetcode-cn.com/problems/sum-of-left-leaves/description/
- *
- * algorithms
- * Easy (59.83%)
- * Likes:    435
- * Dislikes: 0
- * Total Accepted:    142.9K
- * Total Submissions: 237.2K
- * Testcase Example:  '[3,9,20,null,null,15,7]'
- *
- * 给定二叉树的根节点 root ，返回所有左叶子之和。
- *
- *
- *
- * 示例 1：
- *
- *
- *
- *
- * 输入: root = [3,9,20,null,null,15,7]
- * 输出: 24
- * 解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
- *
- *
- * 示例 2:
- *
- *
- * 输入: root = [1]
- * 输出: 0
- *
- *
- *
- *
- * 提示:
- *
- *
- * 节点数在 [1, 1000] 范围内
- * -1000 <= Node.val <= 1000
- *
- *
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-
-func isLeaf(n *TreeNode) bool {
-	if n.Left == nil && n.Right == nil {
-		return true
-	}
-	return false
-}
-
-func sumOfLeftLeaves(root *TreeNode) int {
-
-	result := 0
-	var dfs func(*TreeNode)
-
-	dfs = func(n *TreeNode) {
-		if isLeaf(n) {
-			return
-		}
-		if n.Left != nil {
-			if isLeaf(n.Left) {
-				result += n.Left.Val
-			} else {
-				dfs(n.Left)
-			}
-		}
-		if n.Right != nil {
-			if !isLeaf(n.Right) {
-				dfs(n.Right)
-			}
-		}
-	}
-
-	dfs(root)
-	return result
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=404 lang=golang
+ *
+ * [404] 左叶子之和
+ *
+ * https://leetcode-cn.com/problems/sum-of-left-leaves/description/
+ *
+ * algorithms
+ * Easy (59.83%)
+ * Likes:    435
+ * Dislikes: 0
+ * Total Accepted:    142.9K
+ * Total Submissions: 237.2K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * 给定二叉树的根节点 root ，返回所有左叶子之和。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ *
+ * 输入: root = [3,9,20,null,null,15,7]
+ * 输出: 24
+ * 解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入: root = [1]
+ * 输出: 0
+ *
+ *
+ *
+ *
+ * 提示:
+ *
+ *
+ * 节点数在 [1, 1000] 范围内
+ * -1000 <= Node.val <= 1000
+ *
+ *
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func isLeaf(n *TreeNode) bool {
+	if n.Left == nil && n.Right == nil {
+		return true
+	}
+	return false
+}
+
+func sumOfLeftLeaves(root *TreeNode) int {
+
+	result := 0
+	var dfs func(*TreeNode)
+
+	dfs = func(n *TreeNode) {
+		if isLeaf(n) {
+			return
+		}
+		if n.Left != nil {
+			if isLeaf(n.Left) {
+				result += n.Left.Val
+			} else {
+				dfs(n.Left)
+			}
+		}
+		if n.Right != nil {
+			if !isLeaf(n.Right) {
+				dfs(n.Right)
+			}
+		}
+	}
+
+	dfs(root)
+	return result
+}
+
+// @lc code=end
+
diff --git a/412.fizz-buzz.go b/412.fizz-buzz.go
index ba3aee3..bbe8517 100644
--- a/412.fizz-buzz.go
+++ b/412.fizz-buzz.go
@@ -1,107 +1,107 @@
-/*
- * @lc app=leetcode.cn id=412 lang=golang
- *
- * [412] Fizz Buzz
- *
- * https://leetcode-cn.com/problems/fizz-buzz/description/
- *
- * algorithms
- * Easy (71.22%)
- * Likes:    175
- * Dislikes: 0
- * Total Accepted:    118.9K
- * Total Submissions: 166.7K
- * Testcase Example:  '3'
- *
- * 给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1
- * 开始）返回结果，其中：
- *
- *
- * answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
- * answer[i] == "Fizz" 如果 i 是 3 的倍数。
- * answer[i] == "Buzz" 如果 i 是 5 的倍数。
- * answer[i] == i （以字符串形式）如果上述条件全不满足。
- *
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：n = 3
- * 输出：["1","2","Fizz"]
- *
- *
- * 示例 2：
- *
- *
- * 输入：n = 5
- * 输出：["1","2","Fizz","4","Buzz"]
- *
- *
- * 示例 3：
- *
- *
- * 输入：n = 15
- *
- * 输出：["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
- *
- *
- *
- * 提示：
- *
- *
- * 1 <= n <= 10^4
- *
- *
- */
-
-// @lc code=start
-func fizzBuzz(n int) []string {
-
-	ans := make([]string, n)
-
-	// 标记3的倍数
-	i := 1
-	for i <= n {
-		multi := i * 3
-		if multi > n {
-			break
-		}
-		idx := multi - 1
-
-		if ans[idx] == "" {
-			ans[idx] = "Fizz"
-		}
-		i++
-	}
-
-	// 标记5的倍数
-	i = 1
-	for i <= n {
-		multi := i * 5
-		if multi > n {
-			break
-		}
-		idx := multi - 1
-
-		if ans[idx] == "" {
-			ans[idx] = "Buzz"
-		} else if ans[idx] == "Fizz" {
-			ans[idx] = "FizzBuzz"
-		}
-
-		i++
-	}
-
-	// 空字符串替换为idx+1
-	for j := range ans {
-		if ans[j] == "" {
-			ans[j] = strconv.Itoa(j + 1)
-		}
-	}
-	return ans
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=412 lang=golang
+ *
+ * [412] Fizz Buzz
+ *
+ * https://leetcode-cn.com/problems/fizz-buzz/description/
+ *
+ * algorithms
+ * Easy (71.22%)
+ * Likes:    175
+ * Dislikes: 0
+ * Total Accepted:    118.9K
+ * Total Submissions: 166.7K
+ * Testcase Example:  '3'
+ *
+ * 给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1
+ * 开始）返回结果，其中：
+ *
+ *
+ * answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
+ * answer[i] == "Fizz" 如果 i 是 3 的倍数。
+ * answer[i] == "Buzz" 如果 i 是 5 的倍数。
+ * answer[i] == i （以字符串形式）如果上述条件全不满足。
+ *
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：n = 3
+ * 输出：["1","2","Fizz"]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：n = 5
+ * 输出：["1","2","Fizz","4","Buzz"]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：n = 15
+ *
+ * 输出：["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= n <= 10^4
+ *
+ *
+ */
+
+// @lc code=start
+func fizzBuzz(n int) []string {
+
+	ans := make([]string, n)
+
+	// 标记3的倍数
+	i := 1
+	for i <= n {
+		multi := i * 3
+		if multi > n {
+			break
+		}
+		idx := multi - 1
+
+		if ans[idx] == "" {
+			ans[idx] = "Fizz"
+		}
+		i++
+	}
+
+	// 标记5的倍数
+	i = 1
+	for i <= n {
+		multi := i * 5
+		if multi > n {
+			break
+		}
+		idx := multi - 1
+
+		if ans[idx] == "" {
+			ans[idx] = "Buzz"
+		} else if ans[idx] == "Fizz" {
+			ans[idx] = "FizzBuzz"
+		}
+
+		i++
+	}
+
+	// 空字符串替换为idx+1
+	for j := range ans {
+		if ans[j] == "" {
+			ans[j] = strconv.Itoa(j + 1)
+		}
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/476.\346\225\260\345\255\227\347\232\204\350\241\245\346\225\260.go" "b/476.\346\225\260\345\255\227\347\232\204\350\241\245\346\225\260.go"
index 5f3af27..4e31b76 100644
--- "a/476.\346\225\260\345\255\227\347\232\204\350\241\245\346\225\260.go"
+++ "b/476.\346\225\260\345\255\227\347\232\204\350\241\245\346\225\260.go"
@@ -1,80 +1,80 @@
-/*
- * @lc app=leetcode.cn id=476 lang=golang
- *
- * [476] 数字的补数
- *
- * https://leetcode-cn.com/problems/number-complement/description/
- *
- * algorithms
- * Easy (71.14%)
- * Likes:    296
- * Dislikes: 0
- * Total Accepted:    69.4K
- * Total Submissions: 97.7K
- * Testcase Example:  '5'
- *
- * 对整数的二进制表示取反（0 变 1 ，1 变 0）后，再转换为十进制表示，可以得到这个整数的补数。
- *
- *
- * 例如，整数 5 的二进制表示是 "101" ，取反后得到 "010" ，再转回十进制表示得到补数 2 。
- *
- *
- * 给你一个整数 num ，输出它的补数。
- *
- *
- *
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：num = 5
- * 输出：2
- * 解释：5 的二进制表示为 101（没有前导零位），其补数为 010。所以你需要输出 2 。
- *
- *
- * 示例 2：
- *
- *
- * 输入：num = 1
- * 输出：0
- * 解释：1 的二进制表示为 1（没有前导零位），其补数为 0。所以你需要输出 0 。
- *
- *
- *
- *
- * 提示：
- *
- *
- * 1 <= num < 2^31
- *
- *
- *
- *
- * 注意：本题与 1009 https://leetcode-cn.com/problems/complement-of-base-10-integer/
- * 相同
- *
- */
-
-// @lc code=start
-func findComplement(num int) int {
-
-	comp := 0
-	i := 0
-	filter := 1 << i
-	for filter <= num {
-
-		// 此位为0
-		if filter&num == 0 {
-			comp += filter
-		}
-
-		i++
-		filter = 1 << i
-	}
-
-	return comp
-}
-
-// @lc code=end
+/*
+ * @lc app=leetcode.cn id=476 lang=golang
+ *
+ * [476] 数字的补数
+ *
+ * https://leetcode-cn.com/problems/number-complement/description/
+ *
+ * algorithms
+ * Easy (71.14%)
+ * Likes:    296
+ * Dislikes: 0
+ * Total Accepted:    69.4K
+ * Total Submissions: 97.7K
+ * Testcase Example:  '5'
+ *
+ * 对整数的二进制表示取反（0 变 1 ，1 变 0）后，再转换为十进制表示，可以得到这个整数的补数。
+ *
+ *
+ * 例如，整数 5 的二进制表示是 "101" ，取反后得到 "010" ，再转回十进制表示得到补数 2 。
+ *
+ *
+ * 给你一个整数 num ，输出它的补数。
+ *
+ *
+ *
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：num = 5
+ * 输出：2
+ * 解释：5 的二进制表示为 101（没有前导零位），其补数为 010。所以你需要输出 2 。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：num = 1
+ * 输出：0
+ * 解释：1 的二进制表示为 1（没有前导零位），其补数为 0。所以你需要输出 0 。
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= num < 2^31
+ *
+ *
+ *
+ *
+ * 注意：本题与 1009 https://leetcode-cn.com/problems/complement-of-base-10-integer/
+ * 相同
+ *
+ */
+
+// @lc code=start
+func findComplement(num int) int {
+
+	comp := 0
+	i := 0
+	filter := 1 << i
+	for filter <= num {
+
+		// 此位为0
+		if filter&num == 0 {
+			comp += filter
+		}
+
+		i++
+		filter = 1 << i
+	}
+
+	return comp
+}
+
+// @lc code=end
diff --git "a/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.go" "b/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.go"
index bd2c65d..dc420e5 100644
--- "a/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.go"
+++ "b/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.go"
@@ -1,73 +1,73 @@
-/*
- * @lc app=leetcode.cn id=485 lang=golang
- *
- * [485] 最大连续 1 的个数
- *
- * https://leetcode-cn.com/problems/max-consecutive-ones/description/
- *
- * algorithms
- * Easy (60.95%)
- * Likes:    313
- * Dislikes: 0
- * Total Accepted:    148.8K
- * Total Submissions: 244K
- * Testcase Example:  '[1,1,0,1,1,1]'
- *
- * 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：nums = [1,1,0,1,1,1]
- * 输出：3
- * 解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.
- *
- *
- * 示例 2:
- *
- *
- * 输入：nums = [1,0,1,1,0,1]
- * 输出：2
- *
- *
- *
- *
- * 提示：
- *
- *
- * 1 <= nums.length <= 10^5
- * nums[i] 不是 0 就是 1.
- *
- *
- */
-
-// @lc code=start
-func findMaxConsecutiveOnes(nums []int) int {
-
-	maxLen := 0
-	preLen := 0
-
-	for i := range nums {
-		num := nums[i]
-
-		if num == 1 {
-			curLen := preLen + 1
-			maxLen = max(maxLen, curLen)
-			preLen = curLen
-		} else {
-			preLen = 0
-		}
-	}
-	return maxLen
-}
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=485 lang=golang
+ *
+ * [485] 最大连续 1 的个数
+ *
+ * https://leetcode-cn.com/problems/max-consecutive-ones/description/
+ *
+ * algorithms
+ * Easy (60.95%)
+ * Likes:    313
+ * Dislikes: 0
+ * Total Accepted:    148.8K
+ * Total Submissions: 244K
+ * Testcase Example:  '[1,1,0,1,1,1]'
+ *
+ * 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [1,1,0,1,1,1]
+ * 输出：3
+ * 解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入：nums = [1,0,1,1,0,1]
+ * 输出：2
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 10^5
+ * nums[i] 不是 0 就是 1.
+ *
+ *
+ */
+
+// @lc code=start
+func findMaxConsecutiveOnes(nums []int) int {
+
+	maxLen := 0
+	preLen := 0
+
+	for i := range nums {
+		num := nums[i]
+
+		if num == 1 {
+			curLen := preLen + 1
+			maxLen = max(maxLen, curLen)
+			preLen = curLen
+		} else {
+			preLen = 0
+		}
+	}
+	return maxLen
+}
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/561.\346\225\260\347\273\204\346\213\206\345\210\206-i.go" "b/561.\346\225\260\347\273\204\346\213\206\345\210\206-i.go"
new file mode 100644
index 0000000..93e055f
--- /dev/null
+++ "b/561.\346\225\260\347\273\204\346\213\206\345\210\206-i.go"
@@ -0,0 +1,67 @@
+/*
+ * @lc app=leetcode.cn id=561 lang=golang
+ *
+ * [561] 数组拆分 I
+ *
+ * https://leetcode-cn.com/problems/array-partition-i/description/
+ *
+ * algorithms
+ * Easy (77.98%)
+ * Likes:    295
+ * Dislikes: 0
+ * Total Accepted:    105.7K
+ * Total Submissions: 135.6K
+ * Testcase Example:  '[1,4,3,2]'
+ *
+ * 给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn)
+ * ，使得从 1 到 n 的 min(ai, bi) 总和最大。
+ *
+ * 返回该 最大总和 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [1,4,3,2]
+ * 输出：4
+ * 解释：所有可能的分法（忽略元素顺序）为：
+ * 1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
+ * 2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
+ * 3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
+ * 所以最大总和为 4
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [6,2,6,5,1,2]
+ * 输出：9
+ * 解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2
+ * + 6 = 9
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1
+ * nums.length == 2 * n
+ * -10^4
+ *
+ *
+ */
+
+// @lc code=start
+func arrayPairSum(nums []int) int {
+	// 升序排列, 结果即为最大
+	sort.Ints(nums)
+	sum := 0
+	for i := 0; i < len(nums); i += 2 {
+		sum += nums[i]
+	}
+	return sum
+}
+
+// @lc code=end
+
diff --git "a/57.\346\217\222\345\205\245\345\214\272\351\227\264.go" "b/57.\346\217\222\345\205\245\345\214\272\351\227\264.go"
index e2fba7e..5369ba1 100644
--- "a/57.\346\217\222\345\205\245\345\214\272\351\227\264.go"
+++ "b/57.\346\217\222\345\205\245\345\214\272\351\227\264.go"
@@ -1,121 +1,121 @@
-/*
- * @lc app=leetcode.cn id=57 lang=golang
- *
- * [57] 插入区间
- *
- * https://leetcode-cn.com/problems/insert-interval/description/
- *
- * algorithms
- * Medium (41.41%)
- * Likes:    569
- * Dislikes: 0
- * Total Accepted:    105.3K
- * Total Submissions: 254.1K
- * Testcase Example:  '[[1,3],[6,9]]\n[2,5]'
- *
- * 给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
- *
- * 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
- * 输出：[[1,5],[6,9]]
- *
- *
- * 示例 2：
- *
- *
- * 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
- * 输出：[[1,2],[3,10],[12,16]]
- * 解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
- *
- * 示例 3：
- *
- *
- * 输入：intervals = [], newInterval = [5,7]
- * 输出：[[5,7]]
- *
- *
- * 示例 4：
- *
- *
- * 输入：intervals = [[1,5]], newInterval = [2,3]
- * 输出：[[1,5]]
- *
- *
- * 示例 5：
- *
- *
- * 输入：intervals = [[1,5]], newInterval = [2,7]
- * 输出：[[1,7]]
- *
- *
- *
- *
- * 提示：
- *
- *
- * 0
- * intervals[i].length == 2
- * 0
- * intervals 根据 intervals[i][0] 按 升序 排列
- * newInterval.length == 2
- * 0
- *
- *
- */
-
-// @lc code=start
-func insert(input [][]int, newInterval []int) (result [][]int) {
-	newStart := newInterval[0]
-	newEnd := newInterval[1]
-
-	merged := false
-	for _, v := range input {
-		start := v[0]
-		end := v[1]
-
-		if end < newStart {
-			// 此区间在新区间左侧
-			result = append(result, v)
-		} else if start > newEnd {
-			// 此区间在新区间右侧
-			if !merged {
-				// 检查新区间是否已经被插入过了
-				result = append(result, []int{newStart, newEnd})
-				merged = true
-			}
-			// 本区间一定需要插入
-			result = append(result, v)
-		} else {
-			// 肯定相交了, 与当前区间进行合并
-			newStart = min(start, newStart)
-			newEnd = max(end, newEnd)
-		}
-	}
-	if !merged {
-		result = append(result, []int{newStart, newEnd})
-	}
-	return result
-}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=57 lang=golang
+ *
+ * [57] 插入区间
+ *
+ * https://leetcode-cn.com/problems/insert-interval/description/
+ *
+ * algorithms
+ * Medium (41.41%)
+ * Likes:    569
+ * Dislikes: 0
+ * Total Accepted:    105.3K
+ * Total Submissions: 254.1K
+ * Testcase Example:  '[[1,3],[6,9]]\n[2,5]'
+ *
+ * 给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
+ *
+ * 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
+ * 输出：[[1,5],[6,9]]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+ * 输出：[[1,2],[3,10],[12,16]]
+ * 解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：intervals = [], newInterval = [5,7]
+ * 输出：[[5,7]]
+ *
+ *
+ * 示例 4：
+ *
+ *
+ * 输入：intervals = [[1,5]], newInterval = [2,3]
+ * 输出：[[1,5]]
+ *
+ *
+ * 示例 5：
+ *
+ *
+ * 输入：intervals = [[1,5]], newInterval = [2,7]
+ * 输出：[[1,7]]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 0
+ * intervals[i].length == 2
+ * 0
+ * intervals 根据 intervals[i][0] 按 升序 排列
+ * newInterval.length == 2
+ * 0
+ *
+ *
+ */
+
+// @lc code=start
+func insert(input [][]int, newInterval []int) (result [][]int) {
+	newStart := newInterval[0]
+	newEnd := newInterval[1]
+
+	merged := false
+	for _, v := range input {
+		start := v[0]
+		end := v[1]
+
+		if end < newStart {
+			// 此区间在新区间左侧
+			result = append(result, v)
+		} else if start > newEnd {
+			// 此区间在新区间右侧
+			if !merged {
+				// 检查新区间是否已经被插入过了
+				result = append(result, []int{newStart, newEnd})
+				merged = true
+			}
+			// 本区间一定需要插入
+			result = append(result, v)
+		} else {
+			// 肯定相交了, 与当前区间进行合并
+			newStart = min(start, newStart)
+			newEnd = max(end, newEnd)
+		}
+	}
+	if !merged {
+		result = append(result, []int{newStart, newEnd})
+	}
+	return result
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/62.\344\270\215\345\220\214\350\267\257\345\276\204.go" "b/62.\344\270\215\345\220\214\350\267\257\345\276\204.go"
index 4038dc6..91efcc0 100644
--- "a/62.\344\270\215\345\220\214\350\267\257\345\276\204.go"
+++ "b/62.\344\270\215\345\220\214\350\267\257\345\276\204.go"
@@ -1,94 +1,94 @@
-/*
- * @lc app=leetcode.cn id=62 lang=golang
- *
- * [62] 不同路径
- *
- * https://leetcode-cn.com/problems/unique-paths/description/
- *
- * algorithms
- * Medium (66.83%)
- * Likes:    1372
- * Dislikes: 0
- * Total Accepted:    418.2K
- * Total Submissions: 624.8K
- * Testcase Example:  '3\n7'
- *
- * 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
- *
- * 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
- *
- * 问总共有多少条不同的路径？
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：m = 3, n = 7
- * 输出：28
- *
- * 示例 2：
- *
- *
- * 输入：m = 3, n = 2
- * 输出：3
- * 解释：
- * 从左上角开始，总共有 3 条路径可以到达右下角。
- * 1. 向右 -> 向下 -> 向下
- * 2. 向下 -> 向下 -> 向右
- * 3. 向下 -> 向右 -> 向下
- *
- *
- * 示例 3：
- *
- *
- * 输入：m = 7, n = 3
- * 输出：28
- *
- *
- * 示例 4：
- *
- *
- * 输入：m = 3, n = 3
- * 输出：6
- *
- *
- *
- * 提示：
- *
- *
- * 1
- * 题目数据保证答案小于等于 2 * 10^9
- *
- *
- */
-
-// @lc code=start
-func uniquePaths(m int, n int) int {
-
-	dp := make([][]int, m)
-	for i := 0; i < m; i++ {
-		dp[i] = make([]int, n)
-	}
-
-	dp[0][0] = 1
-	// 初始化第一列
-	for i := 1; i < m; i++ {
-		dp[i][0] = 1
-	}
-	for i := 1; i < n; i++ {
-		dp[0][i] = 1
-	}
-
-	fmt.Println(dp)
-	for i := 1; i < m; i++ {
-		for j := 1; j < n; j++ {
-			dp[i][j] = dp[i-1][j] + dp[i][j-1]
-		}
-	}
-
-	return dp[m-1][n-1]
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=62 lang=golang
+ *
+ * [62] 不同路径
+ *
+ * https://leetcode-cn.com/problems/unique-paths/description/
+ *
+ * algorithms
+ * Medium (66.83%)
+ * Likes:    1372
+ * Dislikes: 0
+ * Total Accepted:    418.2K
+ * Total Submissions: 624.8K
+ * Testcase Example:  '3\n7'
+ *
+ * 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
+ *
+ * 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
+ *
+ * 问总共有多少条不同的路径？
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：m = 3, n = 7
+ * 输出：28
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：m = 3, n = 2
+ * 输出：3
+ * 解释：
+ * 从左上角开始，总共有 3 条路径可以到达右下角。
+ * 1. 向右 -> 向下 -> 向下
+ * 2. 向下 -> 向下 -> 向右
+ * 3. 向下 -> 向右 -> 向下
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：m = 7, n = 3
+ * 输出：28
+ *
+ *
+ * 示例 4：
+ *
+ *
+ * 输入：m = 3, n = 3
+ * 输出：6
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1
+ * 题目数据保证答案小于等于 2 * 10^9
+ *
+ *
+ */
+
+// @lc code=start
+func uniquePaths(m int, n int) int {
+
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
+	}
+
+	dp[0][0] = 1
+	// 初始化第一列
+	for i := 1; i < m; i++ {
+		dp[i][0] = 1
+	}
+	for i := 1; i < n; i++ {
+		dp[0][i] = 1
+	}
+
+	fmt.Println(dp)
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			dp[i][j] = dp[i-1][j] + dp[i][j-1]
+		}
+	}
+
+	return dp[m-1][n-1]
+}
+
+// @lc code=end
+
diff --git "a/637.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\271\263\345\235\207\345\200\274.go" "b/637.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\271\263\345\235\207\345\200\274.go"
new file mode 100644
index 0000000..aeb7169
--- /dev/null
+++ "b/637.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\271\263\345\235\207\345\200\274.go"
@@ -0,0 +1,91 @@
+/*
+ * @lc app=leetcode.cn id=637 lang=golang
+ *
+ * [637] 二叉树的层平均值
+ *
+ * https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/description/
+ *
+ * algorithms
+ * Easy (69.41%)
+ * Likes:    329
+ * Dislikes: 0
+ * Total Accepted:    97.6K
+ * Total Submissions: 140.6K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * 给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10^-5 以内的答案可以被接受。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ *
+ * 输入：root = [3,9,20,null,null,15,7]
+ * 输出：[3.00000,14.50000,11.00000]
+ * 解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
+ * 因此返回 [3, 14.5, 11] 。
+ *
+ *
+ * 示例 2:
+ *
+ *
+ *
+ *
+ * 输入：root = [3,9,20,15,7]
+ * 输出：[3.00000,14.50000,11.00000]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ *
+ *
+ * 树中节点数量在 [1, 10^4] 范围内
+ * -2^31 <= Node.val <= 2^31 - 1
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func averageOfLevels(root *TreeNode) []float64 {
+
+	queue := []*TreeNode{root}
+
+	ans := []float64{}
+	for len(queue) > 0 {
+		size := len(queue)
+		sum := 0
+		for i := 0; i < size; i++ {
+			node := queue[i]
+			sum += node.Val
+
+			if node.Left != nil {
+				queue = append(queue, node.Left)
+			}
+			if node.Right != nil {
+				queue = append(queue, node.Right)
+			}
+		}
+
+		average := float64(sum) / float64(size)
+		ans = append(ans, average)
+
+		queue = queue[size:]
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/64.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go" "b/64.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
index 5e33ce6..c066dd9 100644
--- "a/64.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
+++ "b/64.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.go"
@@ -1,88 +1,88 @@
-/*
- * @lc app=leetcode.cn id=64 lang=golang
- *
- * [64] 最小路径和
- *
- * https://leetcode-cn.com/problems/minimum-path-sum/description/
- *
- * algorithms
- * Medium (69.10%)
- * Likes:    1215
- * Dislikes: 0
- * Total Accepted:    349.2K
- * Total Submissions: 505.2K
- * Testcase Example:  '[[1,3,1],[1,5,1],[4,2,1]]'
- *
- * 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
- *
- * 说明：每次只能向下或者向右移动一步。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
- * 输出：7
- * 解释：因为路径 1→3→1→1→1 的总和最小。
- *
- *
- * 示例 2：
- *
- *
- * 输入：grid = [[1,2,3],[4,5,6]]
- * 输出：12
- *
- *
- *
- *
- * 提示：
- *
- *
- * m == grid.length
- * n == grid[i].length
- * 1
- * 0
- *
- *
- */
-
-// @lc code=start
-func minPathSum(grid [][]int) int {
-	rows := len(grid)
-	columns := len(grid[0])
-
-	dp := make([][]int, rows)
-	for i := 0; i < rows; i++ {
-		dp[i] = make([]int, columns)
-	}
-
-	dp[0][0] = grid[0][0]
-
-	// 初始化第一行
-	for i := 1; i < columns; i++ {
-		dp[0][i] = dp[0][i-1] + grid[0][i]
-	}
-
-	// 初始化第一列
-	for j := 1; j < rows; j++ {
-		dp[j][0] = dp[j-1][0] + grid[j][0]
-	}
-
-	for i := 1; i < rows; i++ {
-		for j := 1; j < columns; j++ {
-			dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + grid[i][j]
-		}
-	}
-	return dp[rows-1][columns-1]
-}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=64 lang=golang
+ *
+ * [64] 最小路径和
+ *
+ * https://leetcode-cn.com/problems/minimum-path-sum/description/
+ *
+ * algorithms
+ * Medium (69.10%)
+ * Likes:    1215
+ * Dislikes: 0
+ * Total Accepted:    349.2K
+ * Total Submissions: 505.2K
+ * Testcase Example:  '[[1,3,1],[1,5,1],[4,2,1]]'
+ *
+ * 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
+ *
+ * 说明：每次只能向下或者向右移动一步。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
+ * 输出：7
+ * 解释：因为路径 1→3→1→1→1 的总和最小。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：grid = [[1,2,3],[4,5,6]]
+ * 输出：12
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * m == grid.length
+ * n == grid[i].length
+ * 1
+ * 0
+ *
+ *
+ */
+
+// @lc code=start
+func minPathSum(grid [][]int) int {
+	rows := len(grid)
+	columns := len(grid[0])
+
+	dp := make([][]int, rows)
+	for i := 0; i < rows; i++ {
+		dp[i] = make([]int, columns)
+	}
+
+	dp[0][0] = grid[0][0]
+
+	// 初始化第一行
+	for i := 1; i < columns; i++ {
+		dp[0][i] = dp[0][i-1] + grid[0][i]
+	}
+
+	// 初始化第一列
+	for j := 1; j < rows; j++ {
+		dp[j][0] = dp[j-1][0] + grid[j][0]
+	}
+
+	for i := 1; i < rows; i++ {
+		for j := 1; j < columns; j++ {
+			dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + grid[i][j]
+		}
+	}
+	return dp[rows-1][columns-1]
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/693.\344\272\244\346\233\277\344\275\215\344\272\214\350\277\233\345\210\266\346\225\260.go" "b/693.\344\272\244\346\233\277\344\275\215\344\272\214\350\277\233\345\210\266\346\225\260.go"
new file mode 100644
index 0000000..648a34d
--- /dev/null
+++ "b/693.\344\272\244\346\233\277\344\275\215\344\272\214\350\277\233\345\210\266\346\225\260.go"
@@ -0,0 +1,62 @@
+/*
+ * @lc app=leetcode.cn id=693 lang=golang
+ *
+ * [693] 交替位二进制数
+ *
+ * https://leetcode-cn.com/problems/binary-number-with-alternating-bits/description/
+ *
+ * algorithms
+ * Easy (65.40%)
+ * Likes:    205
+ * Dislikes: 0
+ * Total Accepted:    68K
+ * Total Submissions: 103.9K
+ * Testcase Example:  '5'
+ *
+ * 给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：n = 5
+ * 输出：true
+ * 解释：5 的二进制表示是：101
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：n = 7
+ * 输出：false
+ * 解释：7 的二进制表示是：111.
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：n = 11
+ * 输出：false
+ * 解释：11 的二进制表示是：1011.
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= n <= 2^31 - 1
+ *
+ *
+ */
+
+// n右移一位与n异或, 结果全是1
+
+// @lc code=start
+func hasAlternatingBits(n int) bool {
+	x := n ^ (n >> 1)
+	return x&(x+1) == 0
+
+}
+
+// @lc code=end
+
diff --git "a/7.\346\225\264\346\225\260\345\217\215\350\275\254.go" "b/7.\346\225\264\346\225\260\345\217\215\350\275\254.go"
index 547e273..aced13a 100644
--- "a/7.\346\225\264\346\225\260\345\217\215\350\275\254.go"
+++ "b/7.\346\225\264\346\225\260\345\217\215\350\275\254.go"
@@ -1,83 +1,83 @@
-/*
- * @lc app=leetcode.cn id=7 lang=golang
- *
- * [7] 整数反转
- *
- * https://leetcode-cn.com/problems/reverse-integer/description/
- *
- * algorithms
- * Medium (35.19%)
- * Likes:    3436
- * Dislikes: 0
- * Total Accepted:    971.8K
- * Total Submissions: 2.8M
- * Testcase Example:  '123'
- *
- * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
- *
- * 如果反转后整数超过 32 位的有符号整数的范围 [−2^31,  2^31 − 1] ，就返回 0。
- * 假设环境不允许存储 64 位整数（有符号或无符号）。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：x = 123
- * 输出：321
- *
- *
- * 示例 2：
- *
- *
- * 输入：x = -123
- * 输出：-321
- *
- *
- * 示例 3：
- *
- *
- * 输入：x = 120
- * 输出：21
- *
- *
- * 示例 4：
- *
- *
- * 输入：x = 0
- * 输出：0
- *
- *
- *
- *
- * 提示：
- *
- *
- * -2^31
- *
- *
- */
-
-// @lc code=start
-func reverse(x int) int {
-
-	if x == 0 {
-		return 0
-	}
-
-	ans := 0
-
-	for x != 0 {
-		left := x % 10
-		ans = ans*10 + left
-
-		if ans > math.MaxInt32 || ans < math.MinInt32 {
-			return 0
-		}
-		x /= 10
-	}
-	return ans
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=7 lang=golang
+ *
+ * [7] 整数反转
+ *
+ * https://leetcode-cn.com/problems/reverse-integer/description/
+ *
+ * algorithms
+ * Medium (35.19%)
+ * Likes:    3436
+ * Dislikes: 0
+ * Total Accepted:    971.8K
+ * Total Submissions: 2.8M
+ * Testcase Example:  '123'
+ *
+ * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
+ *
+ * 如果反转后整数超过 32 位的有符号整数的范围 [−2^31,  2^31 − 1] ，就返回 0。
+ * 假设环境不允许存储 64 位整数（有符号或无符号）。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：x = 123
+ * 输出：321
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：x = -123
+ * 输出：-321
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：x = 120
+ * 输出：21
+ *
+ *
+ * 示例 4：
+ *
+ *
+ * 输入：x = 0
+ * 输出：0
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * -2^31
+ *
+ *
+ */
+
+// @lc code=start
+func reverse(x int) int {
+
+	if x == 0 {
+		return 0
+	}
+
+	ans := 0
+
+	for x != 0 {
+		left := x % 10
+		ans = ans*10 + left
+
+		if ans > math.MaxInt32 || ans < math.MinInt32 {
+			return 0
+		}
+		x /= 10
+	}
+	return ans
+}
+
+// @lc code=end
+
diff --git "a/724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.go" "b/724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.go"
new file mode 100644
index 0000000..9ced867
--- /dev/null
+++ "b/724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.go"
@@ -0,0 +1,111 @@
+/*
+ * @lc app=leetcode.cn id=724 lang=golang
+ *
+ * [724] 寻找数组的中心下标
+ *
+ * https://leetcode-cn.com/problems/find-pivot-index/description/
+ *
+ * algorithms
+ * Easy (48.37%)
+ * Likes:    390
+ * Dislikes: 0
+ * Total Accepted:    175.5K
+ * Total Submissions: 362.6K
+ * Testcase Example:  '[1,7,3,6,5,6]'
+ *
+ * 给你一个整数数组 nums ，请计算数组的 中心下标 。
+ *
+ * 数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
+ *
+ * 如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
+ *
+ * 如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [1, 7, 3, 6, 5, 6]
+ * 输出：3
+ * 解释：
+ * 中心下标是 3 。
+ * 左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
+ * 右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [1, 2, 3]
+ * 输出：-1
+ * 解释：
+ * 数组中不存在满足此条件的中心下标。
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：nums = [2, 1, -1]
+ * 输出：0
+ * 解释：
+ * 中心下标是 0 。
+ * 左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
+ * 右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 10^4
+ * -1000 <= nums[i] <= 1000
+ *
+ *
+ *
+ *
+ * 注意：本题与主站 1991
+ * 题相同：https://leetcode-cn.com/problems/find-the-middle-index-in-array/
+ *
+ */
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	arr := []int{-1, -1, 0, 1, 1, 0}
+	x := pivotIndex(arr)
+	fmt.Println(x)
+}
+
+// @lc code=start
+func pivotIndex(nums []int) int {
+	leftSum := 0
+	rightSum := sum(nums[1:])
+	if rightSum == leftSum {
+		return 0
+	}
+	idx := 1
+	for idx < len(nums) {
+		leftSum += nums[idx-1]
+		rightSum -= nums[idx]
+		if leftSum == rightSum {
+			return idx
+		} else {
+			idx++
+		}
+	}
+	return -1
+}
+
+func sum(arr []int) int {
+	s := 0
+	for i := range arr {
+		s += arr[i]
+	}
+	return s
+}
+
+// @lc code=end
diff --git "a/728.\350\207\252\351\231\244\346\225\260.go" "b/728.\350\207\252\351\231\244\346\225\260.go"
new file mode 100644
index 0000000..4ddad78
--- /dev/null
+++ "b/728.\350\207\252\351\231\244\346\225\260.go"
@@ -0,0 +1,80 @@
+/*
+ * @lc app=leetcode.cn id=728 lang=golang
+ *
+ * [728] 自除数
+ *
+ * https://leetcode-cn.com/problems/self-dividing-numbers/description/
+ *
+ * algorithms
+ * Easy (78.92%)
+ * Likes:    232
+ * Dislikes: 0
+ * Total Accepted:    70.2K
+ * Total Submissions: 89K
+ * Testcase Example:  '1\n22'
+ *
+ * 自除数 是指可以被它包含的每一位数整除的数。
+ *
+ *
+ * 例如，128 是一个 自除数 ，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
+ *
+ *
+ * 自除数 不允许包含 0 。
+ *
+ * 给定两个整数 left 和 right ，返回一个列表，列表的元素是范围 [left, right] 内所有的 自除数 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：left = 1, right = 22
+ * 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入：left = 47, right = 85
+ * 输出：[48,55,66,77]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= left <= right <= 10^4
+ *
+ *
+ */
+
+// @lc code=start
+func selfDividingNumbers(left int, right int) []int {
+	ans := make([]int, 0)
+	for i := left; i <= right; i++ {
+		if matched(i) {
+			ans = append(ans, i)
+		}
+	}
+	return ans
+
+}
+
+func matched(i int) bool {
+
+	origin := i
+	for i != 0 {
+
+		last := i % 10
+		if last == 0 || origin%last != 0 {
+			return false
+		} else {
+			i /= 10
+		}
+	}
+	return true
+}
+
+// @lc code=end
+
diff --git "a/747.\350\207\263\345\260\221\346\230\257\345\205\266\344\273\226\346\225\260\345\255\227\344\270\244\345\200\215\347\232\204\346\234\200\345\244\247\346\225\260.go" "b/747.\350\207\263\345\260\221\346\230\257\345\205\266\344\273\226\346\225\260\345\255\227\344\270\244\345\200\215\347\232\204\346\234\200\345\244\247\346\225\260.go"
new file mode 100644
index 0000000..cedaa13
--- /dev/null
+++ "b/747.\350\207\263\345\260\221\346\230\257\345\205\266\344\273\226\346\225\260\345\255\227\344\270\244\345\200\215\347\232\204\346\234\200\345\244\247\346\225\260.go"
@@ -0,0 +1,74 @@
+/*
+ * @lc app=leetcode.cn id=747 lang=golang
+ *
+ * [747] 至少是其他数字两倍的最大数
+ *
+ * https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/description/
+ *
+ * algorithms
+ * Easy (45.79%)
+ * Likes:    170
+ * Dislikes: 0
+ * Total Accepted:    82.1K
+ * Total Submissions: 179.2K
+ * Testcase Example:  '[3,6,1,0]'
+ *
+ * 给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。
+ *
+ * 请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 -1 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [3,6,1,0]
+ * 输出：1
+ * 解释：6 是最大的整数，对于数组中的其他整数，6 至少是数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [1,2,3,4]
+ * 输出：-1
+ * 解释：4 没有超过 3 的两倍大，所以返回 -1 。
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：nums = [1]
+ * 输出：0
+ * 解释：因为不存在其他数字，所以认为现有数字 1 至少是其他数字的两倍。
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 50
+ * 0 <= nums[i] <= 100
+ * nums 中的最大元素是唯一的
+ *
+ *
+ */
+
+// @lc code=start
+func dominantIndex(nums []int) int {
+	m1, m2, idx := -1, -1, 0
+	for i, num := range nums {
+		if num > m1 {
+			m1, m2, idx = num, m1, i
+		} else if num > m2 {
+			m2 = num
+		}
+	}
+	if m1 >= m2*2 {
+		return idx
+	}
+	return -1
+}
+
+// @lc code=end
+
diff --git "a/82.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240-ii.go" "b/82.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240-ii.go"
index 2a20e8b..f445b41 100644
--- "a/82.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240-ii.go"
+++ "b/82.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240-ii.go"
@@ -1,82 +1,82 @@
-/*
- * @lc app=leetcode.cn id=82 lang=golang
- *
- * [82] 删除排序链表中的重复元素 II
- *
- * https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/description/
- *
- * algorithms
- * Medium (53.29%)
- * Likes:    860
- * Dislikes: 0
- * Total Accepted:    241.7K
- * Total Submissions: 453.6K
- * Testcase Example:  '[1,2,3,3,4,4,5]'
- *
- * 给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。
- *
- *
- *
- * 示例 1：
- *
- *
- * 输入：head = [1,2,3,3,4,4,5]
- * 输出：[1,2,5]
- *
- *
- * 示例 2：
- *
- *
- * 输入：head = [1,1,1,2,3]
- * 输出：[2,3]
- *
- *
- *
- *
- * 提示：
- *
- *
- * 链表中节点数目在范围 [0, 300] 内
- * -100 <= Node.val <= 100
- * 题目数据保证链表已经按升序 排列
- *
- *
- */
-
-// @lc code=start
-/**
- * Definition for singly-linked list.
- * type ListNode struct {
- *     Val int
- *     Next *ListNode
- * }
- */
-func deleteDuplicates(head *ListNode) *ListNode {
-	if head == nil {
-		return nil
-	}
-
-	dummy := new(ListNode)
-	dummy.Next = head
-
-	current := dummy
-
-	for current.Next != nil && current.Next.Next != nil {
-		if current.Next.Next.Val == current.Next.Val {
-			// 找到重复的值
-			v := current.Next.Val
-			// 从current开始遍历
-			for current.Next != nil && current.Next.Val == v {
-				current.Next = current.Next.Next
-			}
-
-		} else {
-			// 必须不存在重复值, 才能向下迭代
-			current = current.Next
-		}
-	}
-	return dummy.Next
-}
-
-// @lc code=end
-
+/*
+ * @lc app=leetcode.cn id=82 lang=golang
+ *
+ * [82] 删除排序链表中的重复元素 II
+ *
+ * https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/description/
+ *
+ * algorithms
+ * Medium (53.29%)
+ * Likes:    860
+ * Dislikes: 0
+ * Total Accepted:    241.7K
+ * Total Submissions: 453.6K
+ * Testcase Example:  '[1,2,3,3,4,4,5]'
+ *
+ * 给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：head = [1,2,3,3,4,4,5]
+ * 输出：[1,2,5]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：head = [1,1,1,2,3]
+ * 输出：[2,3]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 链表中节点数目在范围 [0, 300] 内
+ * -100 <= Node.val <= 100
+ * 题目数据保证链表已经按升序 排列
+ *
+ *
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func deleteDuplicates(head *ListNode) *ListNode {
+	if head == nil {
+		return nil
+	}
+
+	dummy := new(ListNode)
+	dummy.Next = head
+
+	current := dummy
+
+	for current.Next != nil && current.Next.Next != nil {
+		if current.Next.Next.Val == current.Next.Val {
+			// 找到重复的值
+			v := current.Next.Val
+			// 从current开始遍历
+			for current.Next != nil && current.Next.Val == v {
+				current.Next = current.Next.Next
+			}
+
+		} else {
+			// 必须不存在重复值, 才能向下迭代
+			current = current.Next
+		}
+	}
+	return dummy.Next
+}
+
+// @lc code=end
+
diff --git "a/896.\345\215\225\350\260\203\346\225\260\345\210\227.go" "b/896.\345\215\225\350\260\203\346\225\260\345\210\227.go"
new file mode 100644
index 0000000..70a44e9
--- /dev/null
+++ "b/896.\345\215\225\350\260\203\346\225\260\345\210\227.go"
@@ -0,0 +1,76 @@
+/*
+ * @lc app=leetcode.cn id=896 lang=golang
+ *
+ * [896] 单调数列
+ *
+ * https://leetcode-cn.com/problems/monotonic-array/description/
+ *
+ * algorithms
+ * Easy (57.99%)
+ * Likes:    160
+ * Dislikes: 0
+ * Total Accepted:    67.4K
+ * Total Submissions: 116.2K
+ * Testcase Example:  '[1,2,2,3]'
+ *
+ * 如果数组是单调递增或单调递减的，那么它是 单调 的。
+ *
+ * 如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 如果对于所有 i <= j，nums[i]> =
+ * nums[j]，那么数组 nums 是单调递减的。
+ *
+ * 当给定的数组 nums 是单调数组时返回 true，否则返回 false。
+ *
+ *
+ *
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [1,2,2,3]
+ * 输出：true
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [6,5,4,4]
+ * 输出：true
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：nums = [1,3,2]
+ * 输出：false
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 10^5
+ * -10^5 <= nums[i] <= 10^5
+ *
+ *
+ */
+
+// @lc code=start
+func isMonotonic(nums []int) bool {
+
+	inc, dec := true, true
+	for i := 0; i < len(nums)-1; i++ {
+		if nums[i] > nums[i+1] {
+			inc = false
+		}
+		if nums[i] < nums[i+1] {
+			dec = false
+		}
+	}
+	return inc || dec
+}
+
+// @lc code=end
+
diff --git "a/905.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.go" "b/905.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.go"
new file mode 100644
index 0000000..4bb7ae8
--- /dev/null
+++ "b/905.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.go"
@@ -0,0 +1,79 @@
+/*
+ * @lc app=leetcode.cn id=905 lang=golang
+ *
+ * [905] 按奇偶排序数组
+ *
+ * https://leetcode-cn.com/problems/sort-array-by-parity/description/
+ *
+ * algorithms
+ * Easy (69.99%)
+ * Likes:    241
+ * Dislikes: 0
+ * Total Accepted:    66.2K
+ * Total Submissions: 94.5K
+ * Testcase Example:  '[3,1,2,4]'
+ *
+ * 给你一个整数数组 nums，将 nums 中的的所有偶数元素移动到数组的前面，后跟所有奇数元素。
+ *
+ * 返回满足此条件的 任一数组 作为答案。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [3,1,2,4]
+ * 输出：[2,4,3,1]
+ * 解释：[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [0]
+ * 输出：[0]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 5000
+ * 0 <= nums[i] <= 5000
+ *
+ *
+ */
+// @lc code=start
+func sortArrayByParity(nums []int) []int {
+	size := len(nums)
+	if size == 1 {
+		return nums
+	}
+	left := 0
+	right := size - 1
+
+	for left < right {
+
+		for left < size && nums[left]%2 == 0 {
+			left++
+		}
+		for right >= 0 && nums[right]%2 == 1 {
+			right--
+		}
+		if left < right {
+			swap(nums, left, right)
+
+			left++
+			right--
+		}
+	}
+	return nums
+
+}
+func swap(arr []int, x, y int) {
+	arr[x], arr[y] = arr[y], arr[x]
+
+}
+
+// @lc code=end
diff --git "a/908.\346\234\200\345\260\217\345\267\256\345\200\274-i.go" "b/908.\346\234\200\345\260\217\345\267\256\345\200\274-i.go"
new file mode 100644
index 0000000..d08332d
--- /dev/null
+++ "b/908.\346\234\200\345\260\217\345\267\256\345\200\274-i.go"
@@ -0,0 +1,96 @@
+/*
+ * @lc app=leetcode.cn id=908 lang=golang
+ *
+ * [908] 最小差值 I
+ *
+ * https://leetcode-cn.com/problems/smallest-range-i/description/
+ *
+ * algorithms
+ * Easy (70.02%)
+ * Likes:    79
+ * Dislikes: 0
+ * Total Accepted:    24.2K
+ * Total Submissions: 34.6K
+ * Testcase Example:  '[1]\n0'
+ *
+ * 给你一个整数数组 nums，和一个整数 k 。
+ *
+ * 在一个操作中，您可以选择 0 <= i < nums.length 的任何索引 i 。将 nums[i] 改为 nums[i] + x ，其中 x
+ * 是一个范围为 [-k, k] 的整数。对于每个索引 i ，最多 只能 应用 一次 此操作。
+ *
+ * nums 的 分数 是 nums 中最大和最小元素的差值。
+ *
+ * 在对  nums 中的每个索引最多应用一次上述操作后，返回 nums 的最低 分数 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [1], k = 0
+ * 输出：0
+ * 解释：分数是 max(nums) - min(nums) = 1 - 1 = 0。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [0,10], k = 2
+ * 输出：6
+ * 解释：将 nums 改为 [2,8]。分数是 max(nums) - min(nums) = 8 - 2 = 6。
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：nums = [1,3,6], k = 3
+ * 输出：0
+ * 解释：将 nums 改为 [4,4,4]。分数是 max(nums) - min(nums) = 4 - 4 = 0。
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= nums.length <= 10^4
+ * 0 <= nums[i] <= 10^4
+ * 0 <= k <= 10^4
+ *
+ *
+ */
+
+// @lc code=start
+func smallestRangeI(nums []int, k int) int {
+
+	mx := math.MinInt64
+	mn := math.MaxInt64
+
+	for i := 0; i < len(nums); i++ {
+		mx = max(mx, nums[i])
+		mn = min(mn, nums[i])
+	}
+
+	rt := mx-mn-2*k
+	if rt < 0 {
+		return 0
+	}
+	return rt
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// @lc code=end
+
diff --git "a/917.\344\273\205\344\273\205\345\217\215\350\275\254\345\255\227\346\257\215.go" "b/917.\344\273\205\344\273\205\345\217\215\350\275\254\345\255\227\346\257\215.go"
new file mode 100644
index 0000000..ca70cbd
--- /dev/null
+++ "b/917.\344\273\205\344\273\205\345\217\215\350\275\254\345\255\227\346\257\215.go"
@@ -0,0 +1,107 @@
+/*
+ * @lc app=leetcode.cn id=917 lang=golang
+ *
+ * [917] 仅仅反转字母
+ *
+ * https://leetcode-cn.com/problems/reverse-only-letters/description/
+ *
+ * algorithms
+ * Easy (60.23%)
+ * Likes:    167
+ * Dislikes: 0
+ * Total Accepted:    66.9K
+ * Total Submissions: 111.1K
+ * Testcase Example:  '"ab-cd"'
+ *
+ * 给你一个字符串 s ，根据下述规则反转字符串：
+ *
+ *
+ * 所有非英文字母保留在原有位置。
+ * 所有英文字母（小写或大写）位置反转。
+ *
+ *
+ * 返回反转后的 s 。
+ *
+ *
+ *
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：s = "ab-cd"
+ * 输出："dc-ba"
+ *
+ *
+ *
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：s = "a-bC-dEf-ghIj"
+ * 输出："j-Ih-gfE-dCba"
+ *
+ *
+ *
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：s = "Test1ng-Leet=code-Q!"
+ * 输出："Qedo1ct-eeLg=ntse-T!"
+ *
+ *
+ *
+ *
+ * 提示
+ *
+ *
+ * 1 <= s.length <= 100
+ * s 仅由 ASCII 值在范围 [33, 122] 的字符组成
+ * s 不含 '\"' 或 '\\'
+ *
+ *
+ */
+
+// @lc code=start
+func reverseOnlyLetters(s string) string {
+	ans := []byte(s)
+	size := len(ans)
+
+	left := 0
+	right := size - 1
+
+	for left < right {
+		for left < size && !isLetter(ans[left]) {
+			left++
+		}
+		for right >=0 && !isLetter(ans[right]){
+			right--
+		}
+		if left < right {
+			swap(ans, left, right)
+			left++
+			right--
+		}
+	}
+
+	return string(ans)
+}
+func swap(arr []byte, x, y int) {
+	arr[x], arr[y] = arr[y], arr[x]
+}
+
+func isLetter(c byte) bool {
+	if c >= byte('a') && c <= byte('z') {
+		return true
+	} else if c >= byte('A') && c <= byte('Z') {
+		return true
+	}
+	return false
+}
+
+// @lc code=end
+
diff --git "a/922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204-ii.go" "b/922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204-ii.go"
new file mode 100644
index 0000000..eb468a5
--- /dev/null
+++ "b/922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204-ii.go"
@@ -0,0 +1,90 @@
+/*
+ * @lc app=leetcode.cn id=922 lang=golang
+ *
+ * [922] 按奇偶排序数组 II
+ *
+ * https://leetcode-cn.com/problems/sort-array-by-parity-ii/description/
+ *
+ * algorithms
+ * Easy (71.32%)
+ * Likes:    235
+ * Dislikes: 0
+ * Total Accepted:    96.2K
+ * Total Submissions: 134.9K
+ * Testcase Example:  '[4,2,5,7]'
+ *
+ * 给定一个非负整数数组 nums，  nums 中一半整数是 奇数 ，一半整数是 偶数 。
+ *
+ * 对数组进行排序，以便当 nums[i] 为奇数时，i 也是 奇数 ；当 nums[i] 为偶数时， i 也是 偶数 。
+ *
+ * 你可以返回 任何满足上述条件的数组作为答案 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [4,2,5,7]
+ * 输出：[4,5,2,7]
+ * 解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [2,3]
+ * 输出：[2,3]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 2 <= nums.length <= 2 * 10^4
+ * nums.length 是偶数
+ * nums 中一半是偶数
+ * 0 <= nums[i] <= 1000
+ *
+ *
+ *
+ *
+ * 进阶：可以不使用额外空间解决问题吗？
+ *
+ */
+package main
+
+func main() {
+	a := []int{2, 3}
+	sortArrayByParityII(a)
+}
+
+// @lc code=start
+func sortArrayByParityII(nums []int) []int {
+
+	size := len(nums)
+	left := 0
+	right := size - 1
+
+	for left <= size-2 && right >= 1 {
+		for left <= size-2 && nums[left]%2 == 0 {
+			left += 2
+		}
+		for right >= 1 && nums[right]%2 == 1 {
+			right -= 2
+		}
+		if left < size && right >= 0{
+			swap(nums, left, right)
+			left += 2
+			right -= 2
+
+		}
+	}
+	return nums
+}
+
+func swap(arr []int, x, y int) {
+	arr[x], arr[y] = arr[y], arr[x]
+}
+
+// @lc code=end
diff --git "a/925.\351\225\277\346\214\211\351\224\256\345\205\245.go" "b/925.\351\225\277\346\214\211\351\224\256\345\205\245.go"
new file mode 100644
index 0000000..ce26d26
--- /dev/null
+++ "b/925.\351\225\277\346\214\211\351\224\256\345\205\245.go"
@@ -0,0 +1,84 @@
+/*
+ * @lc app=leetcode.cn id=925 lang=golang
+ *
+ * [925] 长按键入
+ *
+ * https://leetcode-cn.com/problems/long-pressed-name/description/
+ *
+ * algorithms
+ * Easy (38.38%)
+ * Likes:    228
+ * Dislikes: 0
+ * Total Accepted:    54K
+ * Total Submissions: 140.6K
+ * Testcase Example:  '"alex"\n"aaleex"'
+ *
+ * 你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
+ *
+ * 你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：name = "alex", typed = "aaleex"
+ * 输出：true
+ * 解释：'alex' 中的 'a' 和 'e' 被长按。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：name = "saeed", typed = "ssaaedd"
+ * 输出：false
+ * 解释：'e' 一定需要被键入两次，但在 typed 的输出中不是这样。
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 1 <= name.length, typed.length <= 1000
+ * name 和 typed 的字符都是小写字母
+ *
+ *
+ */
+ package main
+ func main(){
+	 n := "vex"
+	 r := "vext"
+ }
+
+// @lc code=start
+func isLongPressedName(name string, typed string) bool {
+
+	p1 := 0
+	p2 := 0
+
+	s1 := len(name)
+	s2 := len(typed)
+
+	// 遍历typed, 而不是name
+	for p2 < s2 {
+		if p1 < s1 && name[p1] == typed[p2] {
+			p1++
+			p2++
+		} else {
+			if p2 == 0 {
+				return false
+			} else {
+				if typed[p2] == typed[p2-1] {
+					p2++
+				} else {
+					return false
+				}
+			}
+		}
+	}
+	return p1 == s1
+}
+
+// @lc code=end
+