add 37.38.39.40. golang

Author: zj972

README.md

@@ -40,7 +40,10 @@
 |034|Find First and Last Position of Element in Sorted Array|[Golang](https://github.com/zj972/leetcode/tree/master/code/034.%20Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array)|Medium|
 |035|Search Insert Position|[Golang](https://github.com/zj972/leetcode/tree/master/code/035.%20Search%20Insert%20Position)|Easy|
 |036|Valid Sudoku|[JavaScript & Golang](https://github.com/zj972/leetcode/tree/master/code/036.%20Valid%20Sudoku)|Easy|
-|038|Count and Say|[JavaScript](https://github.com/zj972/leetcode/tree/master/code/038.%20Count%20and%20Say)|Easy|
+|037|Sudoku Solver|[Golang](https://github.com/zj972/leetcode/tree/master/code/037.%20Sudoku%20Solver)|Hard|
+|038|Count and Say|[JavaScript & Golang](https://github.com/zj972/leetcode/tree/master/code/038.%20Count%20and%20Say)|Easy|
+|039|Combination Sum|[Golang](https://github.com/zj972/leetcode/tree/master/code/039.%20Combination%20Sum)|Medium|
+|040|Combination Sum II|[Golang](https://github.com/zj972/leetcode/tree/master/code/040.%20Combination%20Sum%20II)|Medium|
 |058|Length of Last Word|[JavaScript](https://github.com/zj972/leetcode/tree/master/code/058.%20Length%20of%20Last%20Word)|Easy|
 |062|Unique Paths|[JavaScript](https://github.com/zj972/leetcode/tree/master/code/062.%20Unique%20Paths)|Medium|
 |066|Plus One|[JavaScript](https://github.com/zj972/leetcode/tree/master/code/066.%20Plus%20One)|Easy|

code/037. Sudoku Solver/README.md

@@ -0,0 +1,29 @@
+# 37. Sudoku Solver
+
+Write a program to solve a Sudoku puzzle by filling the empty cells.
+
+A sudoku solution must satisfy all of the following rules:
+
+1.Each of the digits 1-9 must occur exactly once in each row.
+
+2.Each of the digits 1-9 must occur exactly once in each column.
+
+3.Each of the the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.
+
+Empty cells are indicated by the character '.'.
+
+![img](https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png)
+
+A sudoku puzzle...
+
+![img](https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Sudoku-by-L2G-20050714_solution.svg/250px-Sudoku-by-L2G-20050714_solution.svg.png)
+
+...and its solution numbers marked in red.
+
+##### Note:
+
+* The given board contain only digits 1-9 and the character '.'.
+
+* You may assume that the given Sudoku puzzle will have a single unique solution.
+
+* The given board size is always 9x9.

code/037. Sudoku Solver/main.go

@@ -0,0 +1,185 @@
+package main
+
+import "fmt"
+
+//Runtime: 172 ms, faster than 10.34% of Go online submissions for Sudoku Solver.
+//func solveSudoku(board [][]byte) {
+//	var next func(board [][]byte, x int, y int) bool
+//	next = func(board [][]byte, x int, y int) bool {
+//		if board[x][y] != byte(46) {
+//			if x == 8 && y == 8 {
+//				return true
+//			}
+//			if x == 8 {
+//				return next(board, 0, y+1)
+//			} else {
+//				return next(board, x+1, y)
+//			}
+//		}
+//		list := verify(board, x, y)
+//		if len(list) == 0 {
+//			return false
+//		}
+//		if x == 8 && y == 8 {
+//			if len(list) != 1 {
+//				return false
+//			}
+//			board[x][y] = list[0]
+//			return true
+//		}
+//		var v bool
+//		for i := 0; i < len(list); i++ {
+//			board[x][y] = list[i]
+//			if x == 8 {
+//				v = next(board, 0, y+1)
+//			} else {
+//				v = next(board, x+1, y)
+//			}
+//			if v {
+//				return true
+//			}
+//		}
+//		if v == false {
+//			board[x][y] = byte(46)
+//		}
+//		return v
+//	}
+//	next(board, 0, 0)
+//}
+//
+//func verify(board [][]byte, x int, y int) []byte {
+//	all := map[byte]bool{
+//		46: false,
+//		49: true,
+//		50: true,
+//		51: true,
+//		52: true,
+//		53: true,
+//		54: true,
+//		55: true,
+//		56: true,
+//		57: true,
+//	}
+//	for i := 0; i < len(board); i++ {
+//		for j := 0; j < len(board[0]); j++ {
+//			if i == x || j == y {
+//				all[board[i][j]] = false
+//				continue
+//			}
+//			xs := (x / 3) * 3
+//			ys := (y / 3) * 3
+//			if i >= xs && i <= xs+2 && j >= ys && j <= ys+2 {
+//				all[board[i][j]] = false
+//				continue
+//			}
+//		}
+//	}
+//	outPut := []byte{}
+//	for k, v := range all {
+//		if v {
+//			outPut = append(outPut, k)
+//		}
+//	}
+//	return outPut
+//}
+
+//Runtime: 0 ms, faster than 100.00% of Go online submissions for Sudoku Solver.
+func solveSudoku(board [][]byte) {
+	var colMark [9][9]bool
+	var rowMark [9][9]bool
+	var areaMark [9][9]bool
+
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			colMark[i][j] = true
+			rowMark[i][j] = true
+			areaMark[i][j] = true
+		}
+	}
+
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			if board[i][j] != '.' {
+				num := int(board[i][j]-'0') - 1
+				rowMark[i][num] = false
+				colMark[j][num] = false
+				index := (i/3)*3 + j/3
+				areaMark[index][num] = false
+			}
+		}
+	}
+
+	findSolved(board, 0, colMark, rowMark, areaMark)
+}
+
+func findSolved(board [][]byte, count int, colMark, rowMark, areaMark [9][9]bool) bool {
+	if count >= 81 {
+		return true
+	}
+	row := count / 9
+	col := count % 9
+	area := (row/3)*3 + col/3
+	if board[row][col] == '.' {
+		for v := 0; v < 9; v++ {
+			if colMark[col][v] && rowMark[row][v] && areaMark[area][v] {
+				board[row][col] = byte('1' + v)
+				colMark[col][v] = false
+				rowMark[row][v] = false
+				areaMark[area][v] = false
+				if findSolved(board, count+1, colMark, rowMark, areaMark) {
+					return true
+				}
+				board[row][col] = '.'
+				colMark[col][v] = true
+				rowMark[row][v] = true
+				areaMark[area][v] = true
+			}
+		}
+	} else {
+		return findSolved(board, count+1, colMark, rowMark, areaMark)
+	}
+
+	return false
+}
+
+func main() {
+	var data = [][]byte{
+		[]byte("53..7...."),
+		[]byte("6..195..."),
+		[]byte(".98....6."),
+		[]byte("8...6...3"),
+		[]byte("4..8.3..1"),
+		[]byte("7...2...6"),
+		[]byte(".6....28."),
+		[]byte("...419..5"),
+		[]byte("....8..79"),
+	}
+	for i := 0; i < len(data); i++ {
+		fmt.Printf("%v:", i)
+		for j := 0; j < len(data[i]); j++ {
+			fmt.Printf("  %v", string(data[i][j]))
+			if j == 2 || j == 5 {
+				fmt.Printf("  |")
+			}
+		}
+		fmt.Printf("\n")
+		if i == 2 || i == 5 {
+			fmt.Printf("—  —  —  —  —  —  —  —  —  —  —  ———\n")
+		}
+	}
+	fmt.Printf("--------------------------------------\n")
+	solveSudoku(data)
+	for i := 0; i < len(data); i++ {
+		fmt.Printf("%v:", i)
+		for j := 0; j < len(data[i]); j++ {
+			fmt.Printf("  %v", string(data[i][j]))
+			if j == 2 || j == 5 {
+				fmt.Printf("  |")
+			}
+		}
+		fmt.Printf("\n")
+		if i == 2 || i == 5 {
+			fmt.Printf("—  —  —  —  —  —  —  —  —  —  —  ———\n")
+		}
+	}
+}

code/038. Count and Say/README.md

@@ -1,14 +1,31 @@
 # 38. Count and Say
-The count-and-say sequence is the sequence of integers beginning as follows:
 
-`1, 11, 21, 1211, 111221, ...`
+The count-and-say sequence is the sequence of integers with the first five terms as following:
 
-`1` is read off as `"one 1"` or `11`.
+1. 1
+2. 11
+3. 21
+4. 1211
+5. 111221
 
-`11` is read off as `"two 1s"` or `21`.
+1 is read off as "one 1" or 11.
 
-`21` is read off as `"one 2`, then `one 1"` or `1211`.
+11 is read off as "two 1s" or 21.
 
-Given an integer n, generate the `n<sup>th</sup>` sequence.
+21 is read off as "one 2, then one 1" or 1211.
 
-Note: The sequence of integers will be represented as a string.
+Given an integer n where 1 ≤ n ≤ 30, generate the nth term of the count-and-say sequence.
+
+Note: Each term of the sequence of integers will be represented as a string.
+
+##### Example 1:
+
+Input: 1
+
+Output: "1"
+
+##### Example 2:
+
+Input: 4
+
+Output: "1211"

code/038. Count and Say/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+//Runtime: 4 ms, faster than 58.25% of Go online submissions for Count and Say.
+//func countAndSay(n int) string {
+//	var str = "1"
+//	var getStr = func(str string) (next string) {
+//		for i := 0; i < len(str); i++ {
+//			if i == len(str)-1 {
+//				next += "1" + string(str[i])
+//			} else {
+//				var n int = 0
+//				var v = str[i]
+//				for i < len(str) {
+//					if str[i] == v {
+//						n++
+//						i++
+//					} else {
+//						next += strconv.Itoa(n) + string(v)
+//						n = 0
+//						i--
+//						break
+//					}
+//				}
+//				if n != 0 {
+//					next += strconv.Itoa(n) + string(v)
+//				}
+//			}
+//		}
+//		return next
+//	}
+//	for i := 1; i < n; i++ {
+//		str = getStr(str)
+//	}
+//	return str
+//}
+
+//Runtime: 0 ms, faster than 100.00% of Go online submissions for Count and Say.
+func countAndSay(n int) string {
+	if n == 1 {
+		return "1"
+	}
+	lastString := "1"
+	for i := 2; i <= n; i++ {
+		var results []byte
+		lastByte := lastString[0]
+		num := 1
+		for j := range lastString {
+			if j == 0 {
+				continue
+			}
+			if lastString[j] == lastByte {
+				num++
+			} else {
+				results = append(results, byte(num+48))
+				results = append(results, lastByte)
+				lastByte = lastString[j]
+				num = 1
+			}
+		}
+		results = append(results, byte(num+48))
+		results = append(results, lastByte)
+		lastString = string(results)
+	}
+	return lastString
+}
+
+func main() {
+	fmt.Println(countAndSay(6))
+}