add some solution

Author: 6boris

lcof/of042/Solution_test.go

@@ -16,7 +16,7 @@ type SolutionFuncType func([]int) int
 var SolutionFuncList = []SolutionFuncType{
 	maxSubArray_1,
 	maxSubArray_2,
-	maxSubArray_3,
+	//maxSubArray_3,
 }
 
 //	Test info struct

lcof/of045/Solution.go

@@ -0,0 +1,22 @@
+package Solution
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+)
+
+func minNumber(nums []int) string {
+	ans := ""
+	sort.Slice(nums, func(i, j int) bool {
+		s1, s2 := fmt.Sprintf("%d%d", nums[i], nums[j]), fmt.Sprintf("%d%d", nums[j], nums[i])
+		if s1 > s2 {
+			return false
+		}
+		return true
+	})
+	for _, v := range nums {
+		ans += strconv.Itoa(v)
+	}
+	return ans
+}

lcof/of045/Solution_test.go

@@ -0,0 +1,47 @@
+package Solution
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+//	solution func Info
+type SolutionFuncType func([]int) string
+
+var SolutionFuncList = []SolutionFuncType{
+	minNumber,
+}
+
+//	test info struct
+type Case struct {
+	name   string
+	inputs []int
+	expect string
+}
+
+// 	Test case
+var cases = []Case{
+	{name: "TestCase 1", inputs: []int{10, 2}, expect: "102"},
+	{name: "TestCase 2", inputs: []int{3, 30, 34, 5, 9}, expect: "3033459"},
+}
+
+// TestSolution Example for solution test cases
+func TestSolution(t *testing.T) {
+	ast := assert.New(t)
+
+	for _, f := range SolutionFuncList {
+		funcName := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".")[1]
+		for _, c := range cases {
+			t.Run(fmt.Sprintf("%s %s", funcName, c.name), func(t *testing.T) {
+				got := f(c.inputs)
+				ast.Equal(c.expect, got,
+					"func: %v case: %v ", funcName, c.name)
+			})
+		}
+	}
+}

leetcode/1-100/0003.Longest-Substring-Without-Repeating-Characters/Solution.go

@@ -1,5 +1,44 @@
 package Solution
 
+func lengthOfLongestSubstring_1(s string) int {
+	// 哈希集合，记录每个字符是否出现过
+	m := map[byte]int{}
+	n := len(s)
+	// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
+	rk, ans := -1, 0
+	for i := 0; i < n; i++ {
+		if i != 0 {
+			// 左指针向右移动一格，移除一个字符
+			delete(m, s[i-1])
+		}
+		for rk+1 < n && m[s[rk+1]] == 0 {
+			// 不断地移动右指针
+			m[s[rk+1]]++
+			rk++
+		}
+		// 第 i 到 rk 个字符是一个极长的无重复字符子串
+		ans = max(ans, rk-i+1)
+	}
+	return ans
+}
+
+func max(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+func lengthOfLongestSubstring_2(s string) int {
+	ans, left, m := 0, 0, map[rune]int{}
+	for right, v := range s {
+		left = max(left, m[v])
+		m[v] = right + 1
+		ans = max(ans, right-left+1)
+	}
+	return ans
+}
+
 // O(n) time O(1) space Solution
 func lengthOfLongestSubstring(s string) int {
 	var chPosition [256]int // [0, 0, 0, ...]

leetcode/1-100/0003.Longest-Substring-Without-Repeating-Characters/Solution_test.go

@@ -1,96 +1,49 @@
 package Solution
 
 import (
+	"fmt"
 	"reflect"
+	"runtime"
+	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestSolution(t *testing.T) {
-	//	测试用例
-	cases := []struct {
-		name   string
-		inputs string
-		expect int
-	}{
-		{"1 test 1", "abcabcbb!", 3},
-		{"2 test 2", "bbbbb", 1},
-		{"3 test 3", "pwwkew", 3},
-	}
+// Solution func Info
+type SolutionFuncType func(string) int
 
-	//	开始测试
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			ret := lengthOfLongestSubstring(c.inputs)
-			if !reflect.DeepEqual(ret, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, ret, c.inputs)
-			}
-		})
-	}
+var SolutionFuncList = []SolutionFuncType{
+	lengthOfLongestSubstring_1,
+	lengthOfLongestSubstring_2,
 }
 
-func TestSolution2(t *testing.T) {
-	//	测试用例
-	cases := []struct {
-		name   string
-		inputs string
-		expect int
-	}{
-		{"1 test 1", "abcabcbb!", 3},
-		{"2 test 2", "bbbbb", 1},
-		{"3 test 3", "pwwkew", 3},
-	}
-
-	//	开始测试
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			ret := lengthOfLongestSubstring2(c.inputs)
-			if !reflect.DeepEqual(ret, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, ret, c.inputs)
-			}
-		})
-	}
+// Test case info struct
+type Case struct {
+	name   string
+	input  string
+	expect int
 }
 
-const N = 1000
-
-func BenchmarkMax1(b *testing.B) {
-	// b.N = 10000
-	//	测试用例
-	cases := []struct {
-		name   string
-		inputs string
-		expect int
-	}{
-		{"1 test 1", "abcabcbb!", 3},
-		{"2 test 2", "bbbbb", 1},
-		{"3 test 3", "pwwkew", 3},
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		lengthOfLongestSubstring(cases[0].inputs)
-		lengthOfLongestSubstring(cases[1].inputs)
-		lengthOfLongestSubstring(cases[2].inputs)
-	}
+// Test case
+var cases = []Case{
+	{name: "TestCase 1", input: "abcabcbb", expect: 3},
+	{name: "TestCase 2", input: "bbbbb", expect: 1},
+	{name: "TestCase 3", input: "pwwkew", expect: 3},
 }
 
-func BenchmarkMax2(b *testing.B) {
-	// b.N = 10000
-	//	测试用例
-	cases := []struct {
-		name   string
-		inputs string
-		expect int
-	}{
-		{"1 test 1", "abcabcbb!", 3},
-		{"2 test 2", "bbbbb", 1},
-		{"3 test 3", "pwwkew", 3},
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		lengthOfLongestSubstring2(cases[0].inputs)
-		lengthOfLongestSubstring2(cases[1].inputs)
-		lengthOfLongestSubstring2(cases[2].inputs)
+// TestSolution Run test case for all solutions
+func TestSolution(t *testing.T) {
+	ast := assert.New(t)
+
+	for _, f := range SolutionFuncList {
+		funcName := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".")[1]
+		for _, c := range cases {
+			t.Run(fmt.Sprintf("%s %s", funcName, c.name), func(t *testing.T) {
+				got := f(c.input)
+				ast.Equal(c.expect, got,
+					"func: %v case: %v ", funcName, c.name)
+			})
+		}
 	}
 }

leetcode/1-100/0015.3Sum/Solution.go

@@ -4,7 +4,7 @@ import (
 	"sort"
 )
 
-func threeSum(nums []int) [][]int {
+func threeSum_1(nums []int) [][]int {
 	ans := [][]int{}
 	if len(nums) <= 2 {
 		return ans

leetcode/1-100/0015.3Sum/Solution_test.go

@@ -1,38 +1,49 @@
 package Solution
 
 import (
+	"fmt"
 	"reflect"
-	"strconv"
+	"runtime"
+	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestSolution(t *testing.T) {
-	//	测试用例
-	cases := []struct {
-		name   string
-		inputs []int
-		expect [][]int
-	}{
-		{"TestCase", []int{-1, 0, 1, 2, -1, -4}, [][]int{{-1, -1, 2}, {-1, 0, 1}}},
-		{"TestCase", []int{-2, 0, 0, 2, 2}, [][]int{{-2, 0, 2}}},
-	}
+// Solution func Info
+type SolutionFuncType func([]int) [][]int
 
-	//	开始测试
-	for i, c := range cases {
-		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := threeSum(c.inputs)
-			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
-			}
-		})
-	}
+var SolutionFuncList = []SolutionFuncType{
+	threeSum_1,
 }
 
-//	压力测试
-func BenchmarkSolution(b *testing.B) {
+// Test case info struct
+type Case struct {
+	name   string
+	input  []int
+	expect [][]int
 }
 
-//	使用案列
-func ExampleSolution() {
+// Test case
+var cases = []Case{
+	{name: "TestCase 1", input: []int{}, expect: [][]int{}},
+	{name: "TestCase 2", input: []int{0}, expect: [][]int{}},
+	{name: "TestCase 3", input: []int{-1, 0, 1, 2, -1, -4}, expect: [][]int{{-1, -1, 2}, {-1, 0, 1}}},
+	{name: "TestCase 4", input: []int{-2, 0, 0, 2, 2}, expect: [][]int{{-2, 0, 2}}},
+}
+
+// TestSolution Run test case for all solutions
+func TestSolution(t *testing.T) {
+	ast := assert.New(t)
+
+	for _, f := range SolutionFuncList {
+		funcName := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".")[1]
+		for _, c := range cases {
+			t.Run(fmt.Sprintf("%s %s", funcName, c.name), func(t *testing.T) {
+				got := f(c.input)
+				ast.Equal(c.expect, got,
+					"func: %v case: %v ", funcName, c.name)
+			})
+		}
+	}
 }

leetcode/101-200/0101.Symmetric-Tree/Solution.go

@@ -6,28 +6,6 @@ type TreeNode struct {
 	Right *TreeNode
 }
 
-func isSymmetric_DFS(root *TreeNode) bool {
-	stack, left, right := []*TreeNode{root.Left, root.Right}, &TreeNode{}, &TreeNode{}
-	for len(stack) > 0 {
-		left, right = stack[len(stack)-1], stack[len(stack)-2]
-		stack = stack[:len(stack)-2]
-		if left == nil && right == nil {
-			continue
-		}
-
-		if left == nil || right == nil {
-			return false
-		}
-
-		if left.Val != right.Val {
-			return false
-		}
-
-		stack = append(stack, left.Left, right.Right, left.Right, right.Left)
-	}
-	return true
-}
-
 func isSymmetric_1(root *TreeNode) bool {
 	var dfs func(*TreeNode, *TreeNode) bool
 	dfs = func(p *TreeNode, q *TreeNode) bool {
@@ -37,7 +15,9 @@ func isSymmetric_1(root *TreeNode) bool {
 		if p == nil || q == nil {
 			return false
 		}
-		return p.Val == q.Val && dfs(p.Left, q.Right) && dfs(p.Right, q.Left)
+		return p.Val == q.Val &&
+			dfs(p.Left, q.Right) &&
+			dfs(p.Right, q.Left)
 	}
 	return dfs(root, root)
 }