add new solutions

solutions/0/q22/solution.go

@@ -0,0 +1,27 @@
+package q22
+
+func gen(n, lvl, used int, buf []byte, ret []string) []string {
+	if buf == nil {
+		buf = make([]byte, 0, n*2)
+	}
+	if len(buf) == n*2 {
+		return append(ret, string(buf))
+	}
+
+	if used < n {
+		buf = append(buf, '(')
+		ret = gen(n, lvl+1, used+1, buf, ret)
+		buf = buf[:len(buf)-1]
+	}
+	if lvl > 0 {
+		buf = append(buf, ')')
+		ret = gen(n, lvl-1, used, buf, ret)
+	}
+	return ret
+}
+
+func generateParenthesis(n int) []string {
+	return gen(n, 0, 0, nil, nil)
+}
+
+var _ = generateParenthesis

solutions/0/q25/solution.go

@@ -0,0 +1,51 @@
+package q25
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func reverse(begin *ListNode, k int) (newHead, newTail *ListNode) {
+	tail := begin
+	for range k - 1 {
+		if tail.Next == nil {
+			return begin, tail // no enough nodes
+		}
+		tail = tail.Next
+	}
+
+	// Reverse
+	cur := begin
+	prev := tail.Next
+	for range k - 1 {
+		t := cur.Next
+		cur.Next = prev
+		prev, cur = cur, t
+	}
+	cur.Next = prev
+	return cur, begin
+}
+
+func reverseKGroup(head *ListNode, k int) *ListNode {
+	if k < 2 {
+		return head
+	}
+
+	var ret, prevTail *ListNode
+	p := head
+	for p != nil {
+		newHead, newTail := reverse(p, k)
+		if ret == nil {
+			ret = newHead
+		}
+		if prevTail != nil {
+			prevTail.Next = newHead
+		}
+		prevTail = newTail
+		p = newTail.Next
+	}
+
+	return ret
+}
+
+var _ = reverseKGroup

solutions/0/q42/solution.go

@@ -0,0 +1,36 @@
+package q42
+
+func trap(height []int) int {
+	water := 0
+	mid := 0
+
+	// From left
+	maxHeight, stash := 0, 0
+	for i, h := range height {
+		if h >= maxHeight {
+			maxHeight = h
+			water += stash
+			stash = 0
+			mid = i
+		} else {
+			stash += maxHeight - h
+		}
+	}
+
+	// From right
+	maxHeight, stash = 0, 0
+	for i := len(height) - 1; i >= mid; i-- {
+		h := height[i]
+		if h >= maxHeight {
+			maxHeight = h
+			water += stash
+			stash = 0
+		} else {
+			stash += maxHeight - h
+		}
+	}
+
+	return water
+}
+
+var _ = trap

solutions/0/q5/solution.go

@@ -0,0 +1,37 @@
+package q5
+
+// Note: Although it can be done in O(N) with, e.g., Manacher's algorithm, the
+// input size is small enough to brute-force.
+
+func expand(s string, l, r int) (int, int) {
+	for l > 0 && r < len(s)-1 && s[l-1] == s[r+1] {
+		l--
+		r++
+	}
+	return l, r
+}
+
+func longestPalindrome(s string) string {
+	maxLen, mL, mR := 0, 0, 0
+
+	for c := range len(s) {
+		l, r := expand(s, c, c)
+		len_ := r - l + 1
+		if len_ > maxLen {
+			maxLen, mL, mR = len_, l, r
+		}
+	}
+
+	for c := range len(s) - 1 {
+		if s[c] == s[c+1] {
+			l, r := expand(s, c, c+1)
+			len_ := r - l + 1
+			if len_ > maxLen {
+				maxLen, mL, mR = len_, l, r
+			}
+		}
+	}
+	return s[mL : mR+1]
+}
+
+var _ = longestPalindrome

solutions/0/q50/solution.go

@@ -0,0 +1,25 @@
+package q50
+
+func myPow(x float64, n int) float64 {
+	neg := n < 0
+	if neg {
+		n = -n
+	}
+
+	var ret float64 = 1
+	for n > 0 {
+		v, p := x, 1
+		for p*2 < n {
+			p *= 2
+			v *= v
+		}
+		n -= p
+		ret *= v
+	}
+	if neg {
+		return 1 / ret
+	}
+	return ret
+}
+
+var _ = myPow

solutions/0/q56/solution.go

@@ -0,0 +1,20 @@
+package q56
+
+import "slices"
+
+func merge(intervals [][]int) [][]int {
+	slices.SortFunc(intervals, func(a, b []int) int { return a[0] - b[0] })
+
+	p := 0
+	for i := 1; i < len(intervals); i++ {
+		if intervals[p][1] >= intervals[i][0] {
+			intervals[p][1] = max(intervals[p][1], intervals[i][1])
+		} else {
+			p++
+			intervals[p][0], intervals[p][1] = intervals[i][0], intervals[i][1]
+		}
+	}
+	return intervals[:min(p+1, len(intervals))]
+}
+
+var _ = merge

solutions/0/q82/solution.go

@@ -0,0 +1,29 @@
+package q82
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func deleteDuplicates(head *ListNode) *ListNode {
+	root := ListNode{}
+	last := &root
+
+	c := head
+	for c != nil {
+		if c.Next != nil && c.Next.Val == c.Val {
+			dupVal := c.Val
+			for c != nil && c.Val == dupVal {
+				c = c.Next
+			}
+			continue
+		}
+		last.Next = c
+		last = c
+		c = c.Next
+		last.Next = nil
+	}
+	return root.Next
+}
+
+var _ = deleteDuplicates