add new solutions

solutions/0/q15/solution.go

@@ -0,0 +1,65 @@
+package q15
+
+import "slices"
+
+func sortAndDedup3(nums []int) []int {
+	slices.Sort(nums)
+	head, dup := 0, 0
+	for i := 1; i < len(nums); i++ {
+		if nums[i] == nums[head] {
+			dup++
+		} else {
+			dup = 0
+		}
+		if dup < 3 {
+			head++
+			nums[head] = nums[i]
+		}
+	}
+	return nums[:head+1]
+}
+
+func threeSum(nums []int) [][]int {
+	nums = sortAndDedup3(nums)
+	ret := [][]int{}
+
+	appendResult := func(a, b, c int) {
+		triplet := []int{a, b, c}
+		if len(ret) > 0 && slices.Equal(triplet, ret[len(ret)-1]) {
+			return
+		}
+		ret = append(ret, triplet)
+	}
+
+	for i := 0; i < len(nums)-2; i++ {
+		if nums[i] > 0 {
+			break
+		}
+		wants := -nums[i]
+		l, r := i+1, len(nums)-1
+		for l < r {
+			for l < r && nums[l]+nums[r] > wants {
+				r--
+			}
+			if l < r && nums[l]+nums[r] == wants {
+				appendResult(nums[i], nums[l], nums[r])
+				r--
+			}
+			for l < r && nums[l]+nums[r] < wants {
+				l++
+			}
+			if l < r && nums[l]+nums[r] == wants {
+				appendResult(nums[i], nums[l], nums[r])
+				l++
+			}
+		}
+
+		// skip same numbers
+		for ; i < len(nums)-2 && nums[i] == nums[i+1]; i++ {
+		}
+	}
+
+	return ret
+}
+
+var _ = threeSum

solutions/0/q20/solution.go

@@ -0,0 +1,32 @@
+package q20
+
+func isValid(s string) bool {
+	stack := make([]byte, 0, len(s)/2)
+
+	for i := range len(s) {
+		switch s[i] {
+		case '(', '[', '{':
+			stack = append(stack, s[i])
+		case ')':
+			if len(stack) == 0 || stack[len(stack)-1] != '(' {
+				return false
+			}
+			stack = stack[:len(stack)-1]
+
+		case ']':
+			if len(stack) == 0 || stack[len(stack)-1] != '[' {
+				return false
+			}
+			stack = stack[:len(stack)-1]
+
+		case '}':
+			if len(stack) == 0 || stack[len(stack)-1] != '{' {
+				return false
+			}
+			stack = stack[:len(stack)-1]
+		}
+	}
+	return len(stack) == 0
+}
+
+var _ = isValid

solutions/1/q104/solution.go

@@ -0,0 +1,20 @@
+package q104
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func md(d int, node *TreeNode) int {
+	if node == nil {
+		return d - 1
+	}
+	return max(md(d+1, node.Left), md(d+1, node.Right))
+}
+
+func maxDepth(root *TreeNode) int {
+	return md(1, root)
+}
+
+var _ = maxDepth

solutions/1/q141/solution.go

@@ -0,0 +1,28 @@
+package q141
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func hasCycle(head *ListNode) bool {
+	if head == nil {
+		return false
+	}
+
+	p1, p2 := head, head
+	for {
+		for range 2 {
+			p2 = p2.Next
+			switch p2 {
+			case nil:
+				return false
+			case p1:
+				return true
+			}
+		}
+		p1 = p1.Next
+	}
+}
+
+var _ = hasCycle

solutions/2/q228/solution.go

@@ -0,0 +1,32 @@
+package q228
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func addToRanges(output []string, a, b int) []string {
+	if a == b {
+		return append(output, strconv.FormatInt(int64(a), 10))
+	}
+	return append(output, fmt.Sprintf("%d->%d", a, b))
+}
+
+func summaryRanges(nums []int) []string {
+	if len(nums) == 0 {
+		return nil
+	}
+
+	output := []string{}
+	l := 0
+	for r := 1; r < len(nums); r++ {
+		if nums[r]-nums[r-1] != 1 {
+			output = addToRanges(output, nums[l], nums[r-1])
+			l = r
+		}
+	}
+	output = addToRanges(output, nums[l], nums[len(nums)-1])
+	return output
+}
+
+var _ = summaryRanges

solutions/3/q383/solution.go

@@ -0,0 +1,25 @@
+package q383
+
+func canConstruct(ransomNote string, magazine string) bool {
+	counts := make([]int, 'z'-'a'+1)
+
+	for _, c := range magazine {
+		if c < 'a' || c > 'z' {
+			continue
+		}
+		counts[int(c)-int('a')]++
+	}
+	for _, c := range ransomNote {
+		if c < 'a' || c > 'z' {
+			continue
+		}
+		offset := int(c) - int('a')
+		counts[offset]--
+		if counts[offset] < 0 {
+			return false
+		}
+	}
+	return true
+}
+
+var _ = canConstruct