init project

easy/1.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+    "fmt"
+)
+
+func twoSum(nums []int, target int) []int {
+	var i, j, v int
+    for i, v = range nums {
+        for j = i+1; j < len(nums); j++ {
+            if v + nums[j] == target {
+                return []int{i, j}
+            }
+        }
+    }
+    // not found, [-1 -1]
+	return []int{-1, -1}
+}

easy/10.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+// search needle in haystack
+func strStr(haystack string, needle string) int {
+    for i := 0; i <= len(haystack) - len(needle); i++ {
+        j := 0
+        for ; j < len(needle); j++ {
+            if haystack[i + j] != needle[j] { break }
+        }
+        if j == len(needle) { return i }
+    }
+    return -1
+}

easy/11.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+// (3->2->1) + (2->1) = (5->3->1), 123 + 12 = 135
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+    // get head of result list
+    head := &ListNode{(l1.Val + l2.Val) % 10, nil}
+    remain := int((l1.Val + l2.Val) / 10)
+    curr := head
+    l1 = l1.Next
+    l2 = l2.Next
+    // while l1 != [] and l2 != [], calculate l1 + l2
+    for l1 != nil && l2 != nil {
+        curr.Next = &ListNode{(l1.Val + l2.Val + remain) % 10, nil}
+        remain = int((l1.Val + l2.Val + remain) / 10)
+        curr = curr.Next
+        l1 = l1.Next
+        l2 = l2.Next
+    }
+    // l1 / l2 is nil 
+    if l1 != nil {
+        curr.Next = &ListNode{(l1.Val + remain) % 10, l1.Next}
+        remain = int((l1.Val + remain) / 10)
+    } else if l2 != nil {
+        curr.Next = &ListNode{(l2.Val + remain) % 10, l2.Next}
+        remain = int((l2.Val + remain) / 10)
+    }
+    curr = curr.Next
+    // add remainder
+    for remain != 0 {
+        if curr.Next != nil {
+            curr.Next.Val += remain
+            remain = int(curr.Next.Val / 10)
+            curr.Next.Val %= 10
+            curr = curr.Next
+        } else {
+            curr.Next = &ListNode{remain, nil}
+            remain = 0
+        }
+    }
+    return head
+}

easy/12.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+func searchInsert(nums []int, target int) int {
+    idx := 0
+    for i, v := range nums {
+        if v == target { return i }
+        if v < target { idx = i + 1 }
+    }
+    return idx
+}

easy/13.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+// iterator of countAndSay function
+func casIter(last string, n int) string {
+    if n == 1 { return last }
+    next := make([]rune, 0)
+    curr := last[0]
+    cnt := 1
+    for i := 1; i < len(last); i++ {
+        if curr != last[i] {
+            next = append(next, rune(cnt + '0'), rune(curr))
+            curr = last[i]
+            cnt = 1
+        } else {
+            cnt++
+        }
+    }
+    next = append(next, rune(cnt + '0'), rune(curr))    
+    return casIter(string(next), n - 1)
+}
+
+func countAndSay(n int) string {
+    return casIter("1", n)
+}

easy/14.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+// important. maxLeft: maximum of sum(nums[x], nums[i])
+func maxSubArray(nums []int) int {
+    max, maxLeft := nums[0], nums[0]
+    for i := 1; i < len(nums); i++ {
+        maxLeft = maxInt(maxLeft + nums[i], nums[i])
+        max = maxInt(max, maxLeft)
+    }
+    return max
+}

easy/15.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+func lengthOfLastWord(s string) int {
+    arr := strings.Fields(s)
+    if len(arr) == 0 { return 0 }
+    return len(arr[len(arr)-1])
+}

easy/16.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+func lengthOfLongestSubstring(s string) int {
+    max := 0
+    for i := 0; i < len(s); i++ {
+        // a map stores all runes showed up after index i
+        m := map[byte]int{ s[i]: 1 }
+        for j := i + 1; j < len(s); j++ {
+            if m[s[j]] == 1 {
+                max = maxInt(len(m), max)
+                break
+            }
+            m[s[j]] = 1
+        }
+        max = maxInt(len(m), max)
+    }
+    return max
+}

easy/17.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+// just like "add two numbers"
+func plusOne(digits []int) []int {
+    i, remain := len(digits) - 1, 0
+    for digits[len(digits) - 1] = digits[len(digits) - 1] + 1; i >= 0; i-- {
+        digits[i] += remain
+        remain = int(digits[i] / 10)
+        digits[i] %= 10
+    }
+    // way to concat two slice: append(a, b...)
+    if remain == 1 { return append([]int{1}, digits...) }
+    return digits
+}

easy/18.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+// add binary
+func minInt(x, y int) int {
+    if x < y { return x }
+    return y
+}
+
+const one, zero = byte('1'), byte('0')
+
+func add3Bi(x, y, z byte) (sum, remain byte) {
+    switch x + y + z - 3 * zero {
+    case 0: return zero, zero
+    case 1: return one, zero
+    case 2: return zero, one
+    case 3: return one, one
+    default: return
+    }
+}
+
+func reverseStr(s string) string {
+    runes := []rune(s)
+    for from, to := 0, len(s) - 1; from < to; from, to = from + 1, to - 1 {
+        runes[from], runes[to] = runes[to], runes[from]
+    }
+    return string(runes)
+}
+
+func addBinary(a string, b string) string {
+    la, lb := len(a) - 1, len(b) - 1
+    sum, remain := zero, zero
+    res := make([]rune, 0)
+    for i := 0; i <= minInt(la, lb); i++ {
+         sum, remain = add3Bi(a[la - i], b[lb - i], remain)
+         res = append(res, rune(sum))
+    }
+    lc := 0
+    var c string
+    if la < lb {
+        c = b
+        lc = lb
+    } else {
+        c = a
+        lc = la
+    }
+    for i := minInt(la, lb) + 1; i <= lc; i++ {
+        sum, remain = add3Bi(zero, c[lc - i], remain)
+        res = append(res, rune(sum))
+    }
+    if remain == one { res = append(res, rune(one)) }
+    return reverseStr(string(res))
+}

easy/19.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+func mySqrt(x int) int {
+    var i int
+    for i = 0; i * i <= x; i++ { }
+    return i - 1
+}

easy/2.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+func reverseOld(x int) int {
+    stack := make([]int, 0)
+    neg := false
+    if x < 0 {
+        neg = true
+        x = -x
+    }
+    for remain := x % 10; x > 0; remain = x % 10 {
+        stack = append(stack, remain)
+        x /= 10
+    }
+    res := 0
+    for i, v := range stack {
+        res += v * int(math.Pow10(len(stack) - i - 1))
+    }
+    if res > 1 << 31 - 1 || res < -1 << 31 {
+        return 0
+    }
+    if neg {
+        return -res
+    }
+    return res
+}
+
+func reverse(x int) int {
+    res := int64(0)
+    for ; x != 0; x /= 10 {
+        res = res * 10 + int64(x % 10)
+        // overflow: -2^31 ~ 2^31-1
+        // if res > 1 << 31 - 1 || res < -1 << 31 { return 0 }
+        if res < math.MinInt32 || res > math.MaxInt32 { return 0 }
+    }
+    return int(res)
+}

easy/20.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+func climbStairsIter(n, x, y int) int {
+    if n == 1 { return y }
+    return climbStairsIter(n - 1, x + y, x)
+}
+
+func climbStairs(n int) int {
+    return climbStairsIter(n, 2, 1)
+}

easy/21.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+// lots of pits!! [] [1] [1 1 1]
+func deleteDuplicates(head *ListNode) *ListNode {
+    if head == nil { return nil }
+    if head.Next == nil { return head }
+    curr := head
+    for curr != nil && curr.Next != nil {
+        if curr.Next.Val == curr.Val {
+            curr.Next = curr.Next.Next
+        } else { curr = curr.Next }
+    }
+    return head
+}

easy/22.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+func merge(nums1 []int, m int, nums2 []int, n int)  {
+    nums := make([]int, 0)
+    i, j := 0, 0
+    // pit: add the smaller one "once a time"
+    for i < m && j < n {
+        if nums1[i] < nums2[j] {
+            nums = append(nums, nums1[i])
+            i++
+        } else {
+            nums = append(nums, nums2[j])
+            j++
+        }
+    }
+    if i == m && j == n {
+    } else if i == m {
+        nums = append(nums, nums2[j:]...)
+    } else {
+        nums = append(nums, nums1[i:]...)
+    }
+    for i = 0; i < m + n; i++ {
+        nums1[i] = nums[i]
+    }
+}

easy/3.go

@@ -0,0 +1,12 @@
+package main
+
+func isPalindrome(x int) bool {
+    // -1 --> -1-, impossible
+    if x < 0 { return false }
+    // judge if reverse(x) == x
+    res, y := 0, x
+    for ; x != 0; x /= 10 {
+        res = res * 10 + x % 10
+    }
+    return res == y
+}

easy/4.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+var m_roman = map[rune]int {
+    'I': 1,
+    'V': 5,
+    'X': 10,
+    'L': 50,
+    'C': 100,
+    'D': 500,
+    'M': 1000,
+}
+
+func romanToInt(s string) int {
+    res := 0
+    last := 1000
+    for _, v := range s {
+        // IV --> V - I
+        if last < m_roman[v] { res -= 2 * last }
+        res += m_roman[v]
+        last = m_roman[v]
+    }
+    return res
+}

easy/5.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+func longestCommonPrefix(strs []string) string {
+    res := make([]rune, 0)
+    // spacial case
+    if len(res) == 0 {return ""}
+    cnt := len(strs[0])
+    // find minimum length of strings
+    for _, v := range strs {
+        if cnt > len(v) { cnt = len(v) }
+    }
+    // vertical serach
+    // [0 _] [0 _] [0 _] --> [_ 1] [_ 1] [_ 0] --> [0]
+    for i := 0; i < cnt; i++ {
+        curr_r := strs[0][i]
+        for _, v := range strs {
+            if (curr_r != v[i]) { cnt = -1 }
+        }
+        if cnt != -1 { 
+            res = append(res, rune(curr_r))
+        }
+    }
+    return string(res)
+}

easy/6.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+var m_brac = map[rune]rune {
+    '}': '{',
+    ']': '[',
+    ')': '(',
+}
+
+func isValid(s string) bool {
+    // store all brackets
+    slice := make([]rune, 0)
+    for _, v := range s {
+        if len(slice) == 0 {
+            slice = append(slice, v)
+            continue
+        }
+        // not match
+        if slice[len(slice)-1] != m_brac[v] {
+            slice = append(slice, v)
+        // match
+        } else {
+            slice = slice[:len(slice)-1]
+        }
+    }
+    if len(slice) != 0 { return false }
+    return true
+}

easy/7.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+type ListNode struct {
+    Val int
+    Next *ListNode
+}
+
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+    // special cases: [] []; [0] []; [] [0]
+    if l1 == nil && l2 == nil { return nil }
+    if l1 == nil && l2 != nil { return l2 }    
+    if l1 != nil && l2 == nil { return l1 }    
+    var curr *ListNode
+    // decide which one is head
+    if l1.Val < l2.Val {
+        curr = l1
+        l1 = l1.Next
+    } else {
+        curr = l2
+        l2 = l2.Next
+    }
+    head := curr
+    // merge 2 list until one of them is []
+    for l1 != nil && l2 != nil {
+        if l1.Val < l2.Val {
+            curr.Next = l1
+            curr = l1
+            l1 = l1.Next
+        } else {
+            curr.Next = l2
+            curr = l2
+            l2 = l2.Next
+        }
+    }
+    // add tail
+    if l1 != nil {
+        curr.Next = l1
+    } else {
+        curr.Next = l2
+    }
+    return head
+}

easy/8.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+
+
+// in-place
+func removeDuplicates(nums []int) int {
+    if len(nums) == 0 { return 0 }
+    // index of the last element in array
+    last := 0
+    for curr := 1; curr < len(nums); curr++ {
+        if nums[curr] != nums[last] {
+            nums[last + 1] = nums[curr]
+            last++
+        }
+    }
+    // size = last_index + 1
+    return last + 1
+}

easy/9.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"strings"
+    "fmt"
+    "math"
+)
+
+// in-palce
+func removeElement(nums []int, val int) int {
+    // index of the last element in array
+    last := -1
+    for curr := 0; curr < len(nums); curr++ {
+        if nums[curr] != val {
+            nums[last + 1] = nums[curr]
+            last++
+        }
+    }
+    return last + 1
+}

easy/leet.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	// "strings"
+    "fmt"
+    // "math"
+)
+
+func main()  {
+    fmt.Println("123")
+}

helper.go

@@ -0,0 +1,17 @@
+package helper
+
+
+func maxInt(x, y int) int {
+    if x > y { return x }
+    return y
+}
+
+func list2str(head *ListNode) string {
+    curr := head
+    str := make([]rune, 0)
+    for curr != nil {
+        str = append(str, rune(curr.Val + '0'))
+        curr = curr.Next
+    }
+    return string(str)
+}