add new solutions

solutions/0/q17/solution.go

@@ -0,0 +1,39 @@
+package q17
+
+var alphabets = [][]byte{
+	[]byte("abc"),
+	[]byte("def"),
+	[]byte("ghi"),
+	[]byte("jkl"),
+	[]byte("mno"),
+	[]byte("pqrs"),
+	[]byte("tuv"),
+	[]byte("wxyz"),
+}
+
+func combinations(offsets []int, i int, buffer []byte, strings []string) []string {
+	if buffer == nil {
+		buffer = make([]byte, len(offsets))
+	}
+
+	if i == len(offsets) {
+		return append(strings, string(buffer))
+	}
+
+	for _, c := range alphabets[offsets[i]] {
+		buffer[i] = c
+		strings = combinations(offsets, i+1, buffer, strings)
+	}
+	return strings
+}
+
+func letterCombinations(digits string) []string {
+	offsets := make([]int, len(digits))
+	for i := range len(digits) {
+		offsets[i] = int(digits[i] - '2')
+	}
+
+	return combinations(offsets, 0, nil, []string{})
+}
+
+var _ = letterCombinations

solutions/0/q35/solution.go

@@ -0,0 +1,19 @@
+package q35
+
+func searchInsert(nums []int, target int) int {
+	l, r := 0, len(nums)
+	for l < r {
+		mid := (l + r) / 2
+		switch {
+		case nums[mid] == target:
+			return mid
+		case nums[mid] > target:
+			r = mid
+		default:
+			l = mid + 1
+		}
+	}
+	return l
+}
+
+var _ = searchInsert

solutions/0/q53/solution.go

@@ -0,0 +1,18 @@
+package q53
+
+import "math"
+
+func maxSubArray(nums []int) int {
+	sum := 0
+	minSubstract := 0
+	maxSubArr := math.MinInt
+	for i := range nums {
+		sum += nums[i]
+		nums[i] = sum
+		maxSubArr = max(maxSubArr, nums[i]-minSubstract)
+		minSubstract = min(minSubstract, nums[i])
+	}
+	return maxSubArr
+}
+
+var _ = maxSubArray

solutions/0/q66/solution.go

@@ -0,0 +1,22 @@
+package q66
+
+func plusOne(digits []int) []int {
+	digits[len(digits)-1]++
+	for i := len(digits) - 1; i > 0; i-- {
+		if digits[i] > 9 {
+			digits[i] -= 10
+			digits[i-1]++
+		} else {
+			break
+		}
+	}
+	if digits[0] > 9 {
+		digits[0] -= 10
+		ret := make([]int, 0, len(digits)+1)
+		ret = append(ret, 1)
+		return append(ret, digits...)
+	}
+	return digits
+}
+
+var _ = plusOne

solutions/0/q67/solution.go

@@ -0,0 +1,28 @@
+package q67
+
+func toDigit(byt byte) uint8  { return byt - '0' }
+func toByte(digit uint8) byte { return '0' + digit }
+
+func addBinary(a string, b string) string {
+	lenA, lenB := len(a), len(b)
+	ret := make([]byte, max(lenA, lenB)+1)
+	var carry uint8
+	for i := range ret {
+		d := carry
+		if i < lenA {
+			d += toDigit(a[lenA-i-1])
+		}
+		if i < lenB {
+			d += toDigit(b[lenB-i-1])
+		}
+		carry = d / 2
+		ret[len(ret)-i-1] = toByte(d % 2)
+	}
+
+	if ret[0] != '1' {
+		return string(ret[1:])
+	}
+	return string(ret)
+}
+
+var _ = addBinary

solutions/0/q69/solution.go

@@ -0,0 +1,26 @@
+package q69
+
+func mySqrt(x int) int {
+	if x < 2 {
+		return x
+	}
+	l, r := 0, x/2+1
+	for l < r {
+		m := (l + r) / 2
+		sq := m * m
+		switch {
+		case sq == x:
+			return m
+		case sq < x:
+			if (m+1)*(m+1) > x {
+				return m
+			}
+			l = m + 1
+		case sq > x:
+			r = m
+		}
+	}
+	return -1
+}
+
+var _ = mySqrt

solutions/0/q70/solution.go

@@ -0,0 +1,24 @@
+package q70
+
+func nWays(n, i int, cache []int) int {
+	if i == n {
+		return 1
+	}
+	if i > n {
+		return 0
+	}
+	if cache == nil {
+		cache = make([]int, n)
+	} else if cache[i] != 0 {
+		return cache[i]
+	}
+	ret := nWays(n, i+1, cache) + nWays(n, i+2, cache)
+	cache[i] = ret
+	return ret
+}
+
+func climbStairs(n int) int {
+	return nWays(n, 0, nil)
+}
+
+var _ = climbStairs

solutions/0/q9/solution.go

@@ -0,0 +1,18 @@
+package q9
+
+import "strconv"
+
+func isPalindrome(x int) bool {
+	if x < 0 {
+		return false
+	}
+	str := strconv.FormatInt(int64(x), 10)
+	for i := range len(str) / 2 {
+		if str[i] != str[len(str)-1-i] {
+			return false
+		}
+	}
+	return true
+}
+
+var _ = isPalindrome