feat: finish 34 36

Author: plh97

algorithm/34.FindFirstandLastPositionofElementinSortedArray/README.md

@@ -0,0 +1,25 @@
+# [34. Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
+
+## 2019/09/14
+
+### 题目 💗[medium]
+
+Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.
+
+Your algorithm's runtime complexity must be in the order of O(log n).
+
+If the target is not found in the array, return [-1, -1].
+
+Example 1:
+
+```bash
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+```
+
+Example 2:
+
+```bash
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+```

algorithm/34.FindFirstandLastPositionofElementinSortedArray/main.go

@@ -0,0 +1,25 @@
+package searchRange
+
+func searchRange(nums []int, target int) []int {
+	firstIndex := indexOf(nums, target)
+	lastIndex := lastIndexOf(nums, target)
+	return []int{firstIndex, lastIndex}
+}
+
+func indexOf(nums []int, val int) int {
+	for i := range nums {
+		if nums[i] == val {
+			return i
+		}
+	}
+	return -1
+}
+
+func lastIndexOf(nums []int, val int) int {
+	for i := len(nums) - 1; i >= 0; i-- {
+		if nums[i] == val {
+			return i
+		}
+	}
+	return -1
+}

algorithm/34.FindFirstandLastPositionofElementinSortedArray/main_test.go

@@ -0,0 +1,26 @@
+package searchRange
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  []int
+	N2  int
+	ans []int
+}{
+	{
+		[]int{5, 7, 7, 8, 8, 10},
+		8,
+		[]int{3, 4},
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, searchRange(tc.N1, tc.N2), "输入:%v", tc)
+	}
+}

algorithm/36.ValidSudoku/README.md

@@ -0,0 +1,60 @@
+# [36. Valid Sudoku](https://leetcode.com/problems/valid-sudoku/)
+
+## 2019/09/14
+
+### 题目 💗[medium]
+
+Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
+
+1. Each row must contain the digits 1-9 without repetition.
+2. Each column must contain the digits 1-9 without repetition.
+3. Each of the 9 3x3 sub-boxes of the grid must contain the digits 1-9 without repetition.
+
+A partially filled sudoku which is valid.
+
+The Sudoku board could be partially filled, where empty cells are filled with the character '.'.
+
+Example 1:
+
+```bash
+Input:
+[
+  ["5","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]
+Output: true
+```
+
+Example 2:
+
+```bash
+Input:
+[
+  ["8","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]
+Output: false
+Explanation: Same as Example 1, except with the 5 in the top left corner being
+    modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.
+```
+
+Note:
+
+- A Sudoku board (partially filled) could be valid but is not necessarily solvable.
+- Only the filled cells need to be validated according to the mentioned rules.
+- The given board contain only digits 1-9 and the character '.'.
+- The given board size is always 9x9.

algorithm/36.ValidSudoku/main.go

@@ -0,0 +1,63 @@
+package isValidSudoku
+
+import "fmt"
+
+func isValidSudoku(board [][]byte) bool {
+	// ◀️️️️️️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ◀️️️️️️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ◀️️️️️️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ◀️️️️️️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ️ ️
+	// check line
+	for _, col := range board {
+		Map := map[byte]int{}
+		for _, e := range col {
+			if e != '.' {
+				if _, ok := Map[e]; ok {
+					return false
+				} else {
+					Map[e] = 1
+				}
+			}
+		}
+	}
+	// check column
+	// 🔽🔽🔽🔽🔽🔽🔽🔽🔽🔽🔽🔽
+	for i, col := range board {
+		Map := map[byte]int{}
+		for j := range col {
+			e := board[j][i]
+			if e != '.' {
+				if _, ok := Map[e]; ok {
+					return false
+				} else {
+					Map[e] = 1
+				}
+			}
+		}
+	}
+	// check 3x3 box
+	for i := 0; i < 3; i++ {
+		for j := 0; j < 3; j++ {
+			if !isSame3X3(board, i, j) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func isSame3X3(board [][]byte, m, n int) bool {
+	fmt.Println("===================")
+	Map := map[byte]int{}
+	for i := 3 * m; i < 3*(m+1); i++ {
+		for j := 3 * n; j < 3*(n+1); j++ {
+			e := board[i][j]
+			if e != '.' {
+				// fmt.Println(e, i, j)
+				if _, ok := Map[e]; ok {
+					return false
+				} else {
+					Map[e] = 1
+				}
+			}
+		}
+	}
+	return true
+}

algorithm/36.ValidSudoku/main_test.go

@@ -0,0 +1,62 @@
+package isValidSudoku
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  [][]byte
+	ans bool
+}{
+	{
+		[][]byte{
+			[]byte{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
+			[]byte{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+			[]byte{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+			[]byte{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+			[]byte{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+			[]byte{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+			[]byte{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+			[]byte{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+			[]byte{'.', '.', '.', '.', '8', '.', '.', '7', '9'},
+		},
+		true,
+	},
+	{
+		[][]byte{
+			[]byte{'8', '3', '.', '.', '7', '.', '.', '.', '.'},
+			[]byte{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+			[]byte{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+			[]byte{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+			[]byte{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+			[]byte{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+			[]byte{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+			[]byte{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+			[]byte{'.', '.', '.', '.', '8', '.', '.', '7', '9'},
+		},
+		false,
+	},
+	{
+		[][]byte{
+			[]byte{'.', '.', '.', '.', '5', '.', '.', '1', '.'},
+			[]byte{'.', '4', '.', '3', '.', '.', '.', '.', '.'},
+			[]byte{'.', '.', '.', '.', '.', '3', '.', '.', '1'},
+			[]byte{'8', '.', '.', '.', '.', '.', '.', '2', '.'},
+			[]byte{'.', '.', '2', '.', '7', '.', '.', '.', '.'},
+			[]byte{'.', '1', '5', '.', '.', '.', '.', '.', '.'},
+			[]byte{'.', '.', '.', '.', '.', '2', '.', '.', '.'},
+			[]byte{'.', '2', '.', '9', '.', '.', '.', '.', '.'},
+			[]byte{'.', '.', '4', '.', '.', '.', '.', '.', '.'},
+		},
+		false,
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, isValidSudoku(tc.N1), "输入:%v", tc)
+	}
+}