merge-intervals

Author: anurag-prakash-singh

divide-two-integers.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"fmt"
+)
+
+func divide(dividend int, divisor int) int {
+
+	if dividend == divisor {
+		return 1
+	}
+
+	if divisor == 1 {
+		return dividend
+	}
+
+	sgn := 1
+
+	if (dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0) {
+		sgn = -1
+	}
+
+	if dividend < 0 {
+		dividend = -dividend
+	}
+
+	if divisor < 0 {
+		divisor = -divisor
+	}
+
+	if dividend < divisor {
+		return 0
+	}
+
+	ans := 0
+	temp := 0
+
+	for i := uint32(31); ; i-- {
+		if temp+(divisor<<i) <= dividend {
+			temp += divisor << i
+			ans = ans | (1 << i)
+		}
+
+		if i == 0 {
+			break
+		}
+	}
+
+	if sgn == -1 {
+		ans = -ans
+	}
+
+	if ans >= 1<<31 {
+		ans = (1 << 31) - 1
+	}
+
+	return ans
+}
+
+func main() {
+
+	tests := [][3]int{{1, 2, 0}, {10, 3, 3}, {5, 3, 1}, {0, -5, 0}, {-2147483648, -1, 2147483647}, {-2147483647, 2, -2147483647 / 2}}
+
+	for _, test := range tests {
+		dividend, divisor, expAns := test[0], test[1], test[2]
+
+		ans := divide(dividend, divisor)
+
+		if ans != expAns {
+			fmt.Printf("test failed: %d / %d should have been %d. Was %d.\n", dividend, divisor, expAns, ans)
+		}
+	}
+
+}

group-anagrams.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+type ByRune []rune
+
+func (b ByRune) Len() int           { return len(b) }
+func (b ByRune) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b ByRune) Less(i, j int) bool { return b[i] < b[j] }
+
+func groupAnagrams(strs []string) [][]string {
+	anagrams := make(map[string][]int)
+
+	for i, s := range strs {
+		runes := ByRune(s)
+		sort.Sort(runes)
+		normalized := string(runes)
+
+		idxs := anagrams[normalized]
+		idxs = append(idxs, i)
+		anagrams[normalized] = idxs
+	}
+
+	result := make([][]string, 0, 10)
+
+	for _, idxs := range anagrams {
+		vals := make([]string, len(idxs))
+
+		for i, idx := range idxs {
+			vals[i] = strs[idx]
+		}
+
+		result = append(result, vals)
+	}
+
+	return result
+}
+
+func main() {
+
+	var a ByRune = []rune("acb")
+
+	sort.Sort(a)
+
+	fmt.Printf("a: %v\n", string(a))
+
+	input := []string{"eat", "tea", "tan", "ate", "nat", "bat"}
+	ans := groupAnagrams(input)
+
+	fmt.Printf("ans: %v\n", ans)
+
+}

merge-intervals.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+type Interval struct {
+	Start int
+	End   int
+}
+
+type ByStart []Interval
+
+func (intvls ByStart) Len() int {
+	return len(intvls)
+}
+
+func (intvls ByStart) Swap(i, j int) {
+	intvls[i], intvls[j] = intvls[j], intvls[i]
+}
+
+func (intvls ByStart) Less(i, j int) bool {
+	return intvls[i].Start < intvls[j].Start
+}
+
+func intervalsIntersect(intvl1, intvl2 Interval) bool {
+	return ((intvl1.Start >= intvl2.Start && intvl1.Start <= intvl2.End) || (intvl1.End >= intvl2.Start && intvl1.End <= intvl2.End))
+}
+
+func max(a, b int) int {
+	if a >= b {
+		return a
+	}
+
+	return b
+}
+
+func merge(intervals []Interval) []Interval {
+	sort.Sort(ByStart(intervals))
+
+	mergedIntervals := make([]Interval, 0, len(intervals))
+
+	if len(intervals) == 0 {
+		return intervals
+	}
+
+	var currInterval Interval
+
+	for i, interval := range intervals {
+		if i == 0 {
+			currInterval = interval
+
+			continue
+		}
+
+		if intervalsIntersect(currInterval, interval) || intervalsIntersect(interval, currInterval) {
+			currInterval.End = max(currInterval.End, interval.End)
+		} else {
+			mergedIntervals = append(mergedIntervals, currInterval)
+			currInterval = interval
+		}
+	}
+
+	mergedIntervals = append(mergedIntervals, currInterval)
+
+	return mergedIntervals
+}
+
+func test1() {
+	intvls := []Interval{
+		Interval{1, 3},
+		Interval{2, 6},
+		Interval{8, 10},
+		Interval{15, 18},
+	}
+
+	mergedIntervals := merge(intvls)
+
+	fmt.Printf("merged: %v\n", mergedIntervals)
+}
+
+func test2() {
+	intvls := []Interval{
+		Interval{1, 4},
+		Interval{4, 5},
+	}
+
+	mergedIntervals := merge(intvls)
+
+	fmt.Printf("merged: %v\n", mergedIntervals)
+}
+
+func test3() {
+	intvls := []Interval{
+		Interval{1, 4},
+	}
+
+	mergedIntervals := merge(intvls)
+
+	fmt.Printf("merged: %v\n", mergedIntervals)
+}
+
+func test4() {
+	intvls := []Interval{}
+
+	mergedIntervals := merge(intvls)
+
+	fmt.Printf("merged: %v\n", mergedIntervals)
+}
+
+func test5() {
+	intvls := []Interval{
+		Interval{1, 4},
+		Interval{2, 3},
+	}
+
+	mergedIntervals := merge(intvls)
+
+	fmt.Printf("merged: %v\n", mergedIntervals)
+}
+
+func main() {
+
+	// intvls := ByStart([]interval{interval{4, 3}, interval{5, 2}, interval{1, 10}})
+
+	// sort.Sort(intvls)
+
+	// fmt.Printf("sorted: %v\n", intvls)
+
+	test1()
+	test2()
+	test3()
+	test4()
+	test5()
+}

multiply-strings.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// multiplicand should only comprise of digits
+func multiplyByDigit(multiplicand []int, multiplier int, acc []int, accOffset int) {
+	mulCarry := 0
+	accCarry := 0
+
+	for i, mulDigit := range multiplicand {
+		prod := mulDigit*multiplier + mulCarry
+		mulCarry = prod / 10
+		prod %= 10
+		acc[accOffset+i] += prod + accCarry
+		accCarry = acc[accOffset+i] / 10
+		acc[accOffset+i] %= 10
+		// fmt.Printf("prod: %d; mulCarry = %d; accCarry: %d\n", prod, mulCarry, accCarry)
+	}
+
+	accCarry += mulCarry
+
+	for i := (accOffset + len(multiplicand)); accCarry != 0; i++ {
+		acc[i] += accCarry
+		accCarry = acc[i] / 10
+		acc[i] %= 10
+	}
+}
+
+func multiply(num1 string, num2 string) string {
+	num1Digits := make([]int, len(num1))
+	num2Digits := make([]int, len(num2))
+	digitRunes := map[int]rune{
+		0: '0',
+		1: '1',
+		2: '2',
+		3: '3',
+		4: '4',
+		5: '5',
+		6: '6',
+		7: '7',
+		8: '8',
+		9: '9',
+	}
+
+	for i, n1 := range num1 {
+		num1Digits[len(num1)-1-i] = int(byte(n1) - '0')
+	}
+
+	for i, n2 := range num2 {
+		num2Digits[len(num2)-1-i] = int(byte(n2) - '0')
+	}
+
+	acc := make([]int, len(num1)+len(num2)+5, len(num1)+len(num2)+5)
+
+	for i, multiplierDigit := range num2Digits {
+		multiplyByDigit(num1Digits, multiplierDigit, acc, i)
+	}
+
+	prodBuf := bytes.NewBufferString("")
+
+	for i, skip := len(acc)-1, true; i >= 0; i-- {
+		if acc[i] == 0 && skip {
+			continue
+		}
+
+		skip = false
+
+		prodBuf.WriteRune(digitRunes[acc[i]])
+	}
+
+	// fmt.Printf("product: %v\n", acc)
+
+	ans := prodBuf.String()
+
+	if ans == "" {
+		return "0"
+	}
+
+	return prodBuf.String()
+}
+
+func main() {
+	fmt.Printf("17 * 35: %s\n", multiply("17", "35"))
+	fmt.Printf("172 * 543: %s\n", multiply("172", "543"))
+	fmt.Printf("99999 * 99999: %s\n", multiply("99999", "99999"))
+	fmt.Printf("1 * 99999: %s\n", multiply("1", "99999"))
+	fmt.Printf("99999 * 1: %s\n", multiply("99999", "1"))
+	fmt.Printf("0 * 0: %s\n", multiply("0", "0"))
+}