Daily Update

Author: 6boris

README.md

@@ -94,8 +94,8 @@ LeetCode of algorithms with golang solution(updating).
 [companies]: https://github.com/Blankj/awesome-java-leetcode/blob/master/Companies.md
 
 [001]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/001/README.md
-[0007]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/007/README.md
-[0009]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/009/README.md
+[0007]: https://github.com/kylesliu/awesome-golang-leetcode/tree/master/src/0007.Reverse-Integer
+[0009]: https://github.com/kylesliu/awesome-golang-leetcode/tree/master/src/0009.Palindrome-Number
 [013]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/013/README.md
 [014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/014/README.md
 [020]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/020/README.md

src/0000.Demo/README.md

@@ -0,0 +1,38 @@
+# [1. Add Sum][title]
+
+## Problem
+
+### Description
+
+Given an array with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.
+
+We define an array is non-decreasing if array[i] <= array[i + 1] holds for every i (1 <= i < n).
+### Example
+```cpp
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+
+Input: [4,2,1]
+Output: False
+Explanation: You can't get a non-decreasing array by modify at most one element.
+```
+> Note: 如果array [i] <= array [i + 1]对于每个i（1 <= i <n）成立，我们定义一个数组是非递减的。
+
+>优先把 nums[i]降为nums[i+1]，这样可以减少 nums[i+1] > nums[i+2] 的风险。
+**Tags:**
+
+
+## 题解
+### 思路1
+在遍历数组时用 Stack 把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
+
+### 思路2
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome golang leetcode][me]
+
+[title]: https://leetcode.com/problems/two-sum/description/
+[me]: https://github.com/kylesliu/awesome-golang-leetcode

src/0000.Demo/Solution.go

@@ -0,0 +1,5 @@
+package Solution
+
+func Solution() bool {
+	return true
+}

src/0000.Demo/Solution_test.go

@@ -0,0 +1,23 @@
+package Solution
+
+import "testing"
+
+func TestSolution(t *testing.T) {
+	t.Run("Test-1", func(t *testing.T) {
+		got := Solution()
+		want := false
+		if got != want {
+			t.Error("GOT:", got, "WANT:", want)
+		}
+	})
+	t.Run("asd", func(t *testing.T) {
+
+	})
+	t.Run("Test-2", func(t *testing.T) {
+		got := Solution()
+		want := true
+		if got != want {
+			t.Error("GOT:", got, "WANT:", want)
+		}
+	})
+}

src/0001.Two-Sum/README.md

@@ -0,0 +1,75 @@
+# [1. Add Sum][title]
+
+## Problem
+
+### Description
+
+Given an array with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.
+
+We define an array is non-decreasing if array[i] <= array[i + 1] holds for every i (1 <= i < n).
+### Example
+```cpp
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+
+Input: [4,2,1]
+Output: False
+Explanation: You can't get a non-decreasing array by modify at most one element.
+```
+> Note: 如果array [i] <= array [i + 1]对于每个i（1 <= i <n）成立，我们定义一个数组是非递减的。
+
+>优先把 nums[i]降为nums[i+1]，这样可以减少 nums[i+1] > nums[i+2] 的风险。
+
+## 题解
+### 思路1
+>题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为 O(n^2)，首次提交居然是 2ms，打败了 100% 的提交，谜一样的结果，之后再次提交就再也没跑到过 2ms 了。
+```go
+func twoSum(nums []int, target int) []int {
+	if nums == nil || len(nums) < 2 {
+		return []int{-1, -1}
+	}
+
+	for k, v := range nums {
+		for i := k + 1; i < len(nums); i++ {
+			if v+nums[i] == target {
+				return []int{k, i}
+			}
+		}
+	}
+	return nil
+}
+```
+
+### 思路2
+>利用 HashMap 作为存储，键为目标值减去当前元素值，索引为值，比如 i = 0 时，此时首先要判断 nums[0] = 2 是否在 map 中，如果不存在，那么插入键值对 key = 9 - 2 = 7, value = 0，之后当 i = 1 时，此时判断 nums[1] = 7 已存在于 map 中，那么取出该 value = 0 作为第一个返回值，当前 i 作为第二个返回值，具体代码如下所示。
+```go
+func twoSum(nums []int, target int) []int {
+	if nums == nil || len(nums) < 2 {
+		return []int{-1, -1}
+	}
+	res := []int{-1, -1}
+
+	//	MAP的KEY表示值，MAP的VAL表示nums的下标
+	intMap := map[int]int{}
+	for i := 0; i < len(nums); i++ {
+		//	判断MAP中是否纯在一个Key满足 KEY + nums[i] = target
+		//	如果满足则返回相关地址,不满足则将数组中的值PUSH到MAP
+		if _, ok := intMap[target-nums[i]]; ok {
+			res[0] = intMap[target-nums[i]]
+			res[1] = i
+			break
+		}
+		intMap[nums[i]] = i
+	}
+	return res
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome golang leetcode][me]
+
+[title]: https://leetcode.com/problems/two-sum/description/
+[me]: https://github.com/kylesliu/awesome-golang-leetcode

src/0001.Two-Sum/Solution.go

@@ -0,0 +1,38 @@
+package Solution
+
+//	HasMap解法
+func twoSum(nums []int, target int) []int {
+	if nums == nil || len(nums) < 2 {
+		return []int{-1, -1}
+	}
+	res := []int{-1, -1}
+
+	//	MAP的KEY表示值，MAP的VAL表示nums的下标
+	intMap := map[int]int{}
+	for i := 0; i < len(nums); i++ {
+		//	判断MAP中是否纯在一个Key满足 KEY + nums[i] = target
+		//	如果满足则返回相关地址,不满足则将数组中的值PUSH到MAP
+		if _, ok := intMap[target-nums[i]]; ok {
+			res[0] = intMap[target-nums[i]]
+			res[1] = i
+			break
+		}
+		intMap[nums[i]] = i
+	}
+	return res
+}
+
+func twoSum1(nums []int, target int) []int {
+	if nums == nil || len(nums) < 2 {
+		return []int{-1, -1}
+	}
+
+	for k, v := range nums {
+		for i := k + 1; i < len(nums); i++ {
+			if v+nums[i] == target {
+				return []int{k, i}
+			}
+		}
+	}
+	return nil
+}

src/0001.Two-Sum/Solution_test.go

@@ -0,0 +1,76 @@
+package Solution
+
+import (
+	"fmt"
+	"testing"
+)
+
+func IsEqualForSlice(a, b []int) bool {
+	if len(a) != len(b) {
+		fmt.Println("a")
+		return false
+	}
+	//	为了和reflect.DeepEqual的结果保持一致：
+	// 	[]int{} != []int(nil)
+	if (a == nil) != (b == nil) {
+		fmt.Println("a")
+
+		return false
+	}
+
+	// 	此处的处的bounds check能够明确保证v != b[i]中的b[i]
+	//	会出现越界错误，从而避免了b[i]中的越界检查从而提高效率
+	//	https://go101.org/article/bounds-check-elimination.html
+	b = b[:len(a)]
+
+	//	循环检测每个元素是否相等
+	for i, v := range a {
+		if v != a[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestTwoSum(t *testing.T) {
+
+	t.Run("Test-1", func(t *testing.T) {
+		data := []int{3, 2, 4}
+		target := 6
+		want := []int{1, 2}
+
+		got := twoSum(data, target)
+		if !IsEqualForSlice(got, want) {
+			t.Error("GOT:", got, " WANT:", want)
+		}
+	})
+
+	t.Run("Test-2", func(t *testing.T) {
+		data := []int{2, 7, 11, 15}
+		target := 9
+		want := []int{0, 1}
+
+		got := twoSum(data, target)
+		if !IsEqualForSlice(got, want) {
+			t.Error("GOT:", got, " WANT:", want)
+		}
+	})
+
+	t.Run("Test-3", func(t *testing.T) {
+		data := []int{7, 6, 5, 3, 2, 1, 4, 9, 10}
+		target := 17
+		want := []int{0, 8}
+
+		got := twoSum(data, target)
+		if !IsEqualForSlice(got, want) {
+			t.Error("GOT:", got, " WANT:", want)
+		}
+	})
+
+}
+
+func TestTwoSum1(t *testing.T) {
+	data := []int{7, 6, 5, 3, 2, 1, 4, 9, 10}
+	target := 17
+	fmt.Println(twoSum1(data, target))
+}

src/00013.-Roman-to-Integer/README.md

@@ -0,0 +1,79 @@
+# [13. Roman to Integer][title]
+
+## Description
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+```
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+```
+
+For example, two is written as `II` in Roman numeral, just two one's added together. Twelve is written as, `XII`, which is simply `X` + `II`. The number twenty seven is written as `XXVII`, which is `XX` + `V` + `II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+- `I` can be placed before `V` (5) and `X` (10) to make 4 and 9. 
+- `X` can be placed before `L` (50) and `C` (100) to make 40 and 90. 
+- `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.
+
+**Example 1:**
+
+```
+Input: "III"
+Output: 3
+```
+
+**Example 2:**
+
+```
+Input: "IV"
+Output: 4
+```
+
+**Example 3:**
+
+```
+Input: "IX"
+Output: 9
+```
+
+**Example 4:**
+
+```
+Input: "LVIII"
+Output: 58
+Explanation: C = 100, L = 50, XXX = 30 and III = 3.
+```
+
+**Example 5:**
+
+```
+Input: "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+```
+
+**Tags:** Math, String
+
+## 题解
+### 思路1
+在遍历数组时用 Stack 把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
+
+### 思路2
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome golang leetcode][me]
+
+[title]: https://leetcode.com/problems/roman-to-integer/description/
+[me]: https://github.com/kylesliu/awesome-golang-leetcode

src/00013.-Roman-to-Integer/Solution.go

@@ -0,0 +1,5 @@
+package Solution
+
+func romanToInt(s string) int {
+	return 0
+}

src/00013.-Roman-to-Integer/Solution_test.go

@@ -0,0 +1,14 @@
+package Solution
+
+import "testing"
+
+func TestSolution(t *testing.T) {
+	t.Run("Test-1", func(t *testing.T) {
+		got := romanToInt("III")
+		want := 3
+		if got != want {
+			t.Error("GOT:", got, "WANT:", want)
+		}
+	})
+
+}