add new solutions

solutions/1/q128/solution.go

@@ -0,0 +1,27 @@
+package q128
+
+func longestConsecutive(nums []int) int {
+	set := make(map[int]struct{}, len(nums))
+	for _, n := range nums {
+		set[n] = struct{}{}
+	}
+
+	longest := 0
+	for n := range set {
+		if _, ok := set[n-1]; ok {
+			continue
+		}
+		r := n
+		for {
+			if _, ok := set[r+1]; ok {
+				r++
+			} else {
+				break
+			}
+		}
+		longest = max(longest, r-n+1)
+	}
+	return longest
+}
+
+var _ = longestConsecutive

solutions/1/q130/solution.go

@@ -0,0 +1,37 @@
+package q130
+
+func markI(board [][]byte, x, y int) {
+	w, h := len(board[0]), len(board)
+	if x < 0 || y < 0 || x >= w || y >= h || board[y][x] != 'O' {
+		return
+	}
+	board[y][x] = 'I'
+	markI(board, x, y+1)
+	markI(board, x, y-1)
+	markI(board, x+1, y)
+	markI(board, x-1, y)
+}
+
+func solve(board [][]byte) {
+	for i := range len(board) {
+		markI(board, 0, i)
+		markI(board, len(board[0])-1, i)
+	}
+	for i := range len(board[0]) {
+		markI(board, i, 0)
+		markI(board, i, len(board)-1)
+	}
+
+	for y := range board {
+		for x := range board[0] {
+			switch board[y][x] {
+			case 'O':
+				board[y][x] = 'X'
+			case 'I':
+				board[y][x] = 'O'
+			}
+		}
+	}
+}
+
+var _ = solve

solutions/1/q138/solution.go

@@ -0,0 +1,34 @@
+package q138
+
+type Node struct {
+	Val    int
+	Next   *Node
+	Random *Node
+}
+
+func copyRandomList(head *Node) *Node {
+	idx := make(map[*Node]*Node, 256)
+
+	p := head
+	for p != nil {
+		newNode := *p // copy
+		idx[p] = &newNode
+		p = p.Next
+	}
+
+	p = head
+	for p != nil {
+		newNode := idx[p]
+		if newNode.Next != nil {
+			newNode.Next = idx[newNode.Next]
+		}
+		if newNode.Random != nil {
+			newNode.Random = idx[newNode.Random]
+		}
+		p = p.Next
+	}
+
+	return idx[head]
+}
+
+var _ = copyRandomList

solutions/1/q139/solution.go

@@ -0,0 +1,28 @@
+package q139
+
+func wordBreak(s string, wordDict []string) bool {
+	possible := make([]bool, len(s)+1)
+	possible[0] = true
+
+	for l := range possible {
+		if !possible[l] {
+			continue
+		}
+		for i := range wordDict {
+			newLen := len(wordDict[i]) + l
+			if newLen > len(s) {
+				continue
+			}
+			if possible[newLen] {
+				continue
+			}
+			if s[l:newLen] == wordDict[i] {
+				possible[newLen] = true
+			}
+		}
+	}
+
+	return possible[len(s)]
+}
+
+var _ = wordBreak

solutions/1/q153/solution.go

@@ -0,0 +1,18 @@
+package q153
+
+func findMin(nums []int) int {
+	l, r := 0, len(nums)
+
+	for l < r && nums[l] > nums[r-1] {
+		m := (l + r) / 2
+		if nums[m] > nums[r-1] {
+			l = m + 1
+		} else {
+			r = m + 1
+			l++
+		}
+	}
+	return nums[l]
+}
+
+var _ = findMin

solutions/1/q162/solution.go

@@ -0,0 +1,24 @@
+package q162
+
+// Important constraint: nums[i] != nums[i + 1]
+
+func findPeakElement(nums []int) int {
+	l, r := 0, len(nums)
+	for l < r {
+		m := (l + r) / 2
+
+		lLower := m == 0 || nums[m-1] < nums[m]
+		rLower := m == len(nums)-1 || nums[m+1] < nums[m]
+		if lLower && rLower {
+			return m
+		}
+		if !lLower { // left side is higher
+			r = m
+		} else {
+			l = m + 1
+		}
+	}
+	return -1
+}
+
+var _ = findPeakElement