From e970ca26e1137ed88877186a754c7d3e070270c5 Mon Sep 17 00:00:00 2001 From: Anurag Singh Date: Sat, 26 Jan 2019 10:06:00 -0800 Subject: [PATCH] Up to reverse linked list II --- decode-ways.go | 61 +++++++++++ gray-code.go | 44 ++++++++ partition-list.go | 74 +++++++++++++ remove-duplicates-from-sorted-list-ii.go | 80 ++++++++++++++ reverse-linked-list-ii.go | 129 +++++++++++++++++++++++ search-in-rotated-sorted-array-ii.go | 31 ++++++ subsets-ii.go | 77 ++++++++++++++ 7 files changed, 496 insertions(+) create mode 100644 decode-ways.go create mode 100644 gray-code.go create mode 100644 partition-list.go create mode 100644 remove-duplicates-from-sorted-list-ii.go create mode 100644 reverse-linked-list-ii.go create mode 100644 search-in-rotated-sorted-array-ii.go create mode 100644 subsets-ii.go diff --git a/decode-ways.go b/decode-ways.go new file mode 100644 index 0000000..84c6970 --- /dev/null +++ b/decode-ways.go @@ -0,0 +1,61 @@ +package main + +import "fmt" + +func countDecodings(nums []rune, remaining int, cache map[int]int) int { + if d, ok := cache[remaining]; ok { + return d + } + + if remaining == 0 { + return 1 + } + + if remaining < 0 { + return 0 + } + + // Case 1: take 1 + num1 := nums[0] - '0' + + if num1 == 0 { + return 0 + } + + decodings := countDecodings(nums[1:], remaining-1, cache) + cache[remaining-1] = decodings + + // Case 2: take 2 if possible + if len(nums) < 2 { + return decodings + } + + num2 := nums[1] - '0' + num12 := 10*num1 + num2 + + if num12 >= 10 && num12 <= 26 { + decodings12 := countDecodings(nums[2:], remaining-2, cache) + cache[remaining-2] = decodings12 + decodings += decodings12 + } + + return decodings +} + +func numDecodings(s string) int { + cache := make(map[int]int) + return countDecodings([]rune(s), len(s), cache) +} + +func test1() { + fmt.Printf("ans = %d\n", numDecodings("12")) +} + +func test2() { + fmt.Printf("ans = %d\n", numDecodings("226")) +} + +func main() { + test1() + test2() +} diff --git a/gray-code.go b/gray-code.go new file mode 100644 index 0000000..6168354 --- /dev/null +++ b/gray-code.go @@ -0,0 +1,44 @@ +package main + +import "fmt" + +func grayCode(n int) []int { + if n == 0 { + return []int{0} + } + + if n == 1 { + return []int{0, 1} + } + + codes := make([]int, 1< ") + } + } + + fmt.Println() +} + +func test1() { + nodes := []ListNode{ListNode{1, nil}, ListNode{4, nil}, ListNode{3, nil}, ListNode{2, nil}} + nodes[0].Next = &nodes[1] + nodes[1].Next = &nodes[2] + nodes[2].Next = &nodes[3] + + printList(partition(&nodes[0], 3)) +} + +func main() { + test1() +} diff --git a/remove-duplicates-from-sorted-list-ii.go b/remove-duplicates-from-sorted-list-ii.go new file mode 100644 index 0000000..b3f938d --- /dev/null +++ b/remove-duplicates-from-sorted-list-ii.go @@ -0,0 +1,80 @@ +package main + +import "fmt" + +type ListNode struct { + Val int + Next *ListNode +} + +func deleteDuplicates(head *ListNode) *ListNode { + if head == nil { + return head + } + + headNext := head.Next + duplicatesFound := false + + for ; headNext != nil && headNext.Val == head.Val; headNext = headNext.Next { + duplicatesFound = true + } + + if duplicatesFound { + return deleteDuplicates(headNext) + } else { + head.Next = deleteDuplicates(headNext) + } + + return head +} + +func printList(head *ListNode) { + for ; head != nil; head = head.Next { + fmt.Printf("%d", head.Val) + + if head.Next != nil { + fmt.Printf(" -> ") + } + } + + fmt.Println() +} + +func test1() { + nodes := []ListNode{ListNode{1, nil}, ListNode{2, nil}, ListNode{3, nil}} + nodes[0].Next = &nodes[1] + nodes[1].Next = &nodes[2] + + printList(deleteDuplicates(&nodes[0])) +} + +func test2() { + nodes := []ListNode{ListNode{1, nil}, ListNode{2, nil}, ListNode{2, nil}} + nodes[0].Next = &nodes[1] + nodes[1].Next = &nodes[2] + + printList(deleteDuplicates(&nodes[0])) +} + +func test3() { + nodes := []ListNode{ListNode{1, nil}, ListNode{2, nil}, ListNode{2, nil}, ListNode{3, nil}} + nodes[0].Next = &nodes[1] + nodes[1].Next = &nodes[2] + nodes[2].Next = &nodes[3] + + printList(deleteDuplicates(&nodes[0])) +} + +func test4() { + nodes := []ListNode{ListNode{1, nil}, ListNode{1, nil}} + nodes[0].Next = &nodes[1] + + printList(deleteDuplicates(&nodes[0])) +} + +func main() { + // test1() + // test2() + // test3() + test4() +} diff --git a/reverse-linked-list-ii.go b/reverse-linked-list-ii.go new file mode 100644 index 0000000..e3b31e1 --- /dev/null +++ b/reverse-linked-list-ii.go @@ -0,0 +1,129 @@ +package main + +import "fmt" + +type ListNode struct { + Val int + Next *ListNode +} + +func reverseN(head *ListNode, rem int, prev *ListNode, sentinel **ListNode) *ListNode { + if head == nil || rem < 0 { + return nil + } + + if rem == 0 { + *sentinel = head.Next + head.Next = prev + return head + } + + remCurrHead := head.Next + head.Next = prev + + return reverseN(remCurrHead, rem-1, head, sentinel) +} + +func reverseBetween(head *ListNode, m int, n int) *ListNode { + start := head + var prev *ListNode + + for i := 0; i < m-1; i++ { + prev = start + start = start.Next + } + + var sentinel *ListNode + + mnRevHead := reverseN(start, n-m, prev, &sentinel) + + if prev != nil { + prev.Next = mnRevHead + } + + start.Next = sentinel + + if prev != nil { + return head + } else { + return mnRevHead + } +} + +func printList(head *ListNode) { + fmt.Printf("List: ") + + for ; head != nil; head = head.Next { + fmt.Printf("%v", head.Val) + + if head.Next != nil { + fmt.Printf(" -> ") + } + } + + fmt.Println() +} + +func test1() { + n5 := &ListNode{5, nil} + n4 := &ListNode{4, n5} + n3 := &ListNode{3, n4} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + mnReversed := reverseBetween(n1, 2, 4) + + printList(mnReversed) +} + +func test2() { + n5 := &ListNode{5, nil} + n4 := &ListNode{4, n5} + n3 := &ListNode{3, n4} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + mnReversed := reverseBetween(n1, 1, 3) + + printList(mnReversed) +} + +func test3() { + n5 := &ListNode{5, nil} + n4 := &ListNode{4, n5} + n3 := &ListNode{3, n4} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + mnReversed := reverseBetween(n1, 1, 5) + + printList(mnReversed) +} + +func test4() { + n5 := &ListNode{5, nil} + n4 := &ListNode{4, n5} + n3 := &ListNode{3, n4} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + mnReversed := reverseBetween(n1, 5, 5) + + printList(mnReversed) +} + +func test5() { + n1 := &ListNode{1, nil} + + mnReversed := reverseBetween(n1, 1, 1) + + printList(mnReversed) +} + +func main() { + // test1() + // test2() + // test3() + // test4() + test5() +} diff --git a/search-in-rotated-sorted-array-ii.go b/search-in-rotated-sorted-array-ii.go new file mode 100644 index 0000000..015f5e7 --- /dev/null +++ b/search-in-rotated-sorted-array-ii.go @@ -0,0 +1,31 @@ +package main + +import "fmt" + +func searchInRange(nums []int, low, high, target int) bool { + if low > high { + return false + } + + mid := (low + high) / 2 + + if target == nums[mid] { + return true + } else { + return (searchInRange(nums, low, mid-1, target) || searchInRange(nums, mid+1, high, target)) + } +} + +func search(nums []int, target int) bool { + return searchInRange(nums, 0, len(nums)-1, target) +} + +func test1() { + nums := []int{3, 1} + + fmt.Printf("ans = %v\n", search(nums, 1)) +} + +func main() { + test1() +} diff --git a/subsets-ii.go b/subsets-ii.go new file mode 100644 index 0000000..b3f61ec --- /dev/null +++ b/subsets-ii.go @@ -0,0 +1,77 @@ +package main + +import ( + "fmt" + "sort" +) + +func subsetsWithDup(nums []int) [][]int { + sort.Ints(nums) + return computePowerSetWithDup(nums, 0, []int{}, [][]int{}) +} + +func computePowerSetWithDup(nums []int, pos int, setSoFar []int, results [][]int) [][]int { + if pos >= len(nums) { + resultSet := make([]int, len(setSoFar)) + copy(resultSet, setSoFar) + return append(results, resultSet) + } + + posrlc := 0 + + for i := pos; i < len(nums) && nums[i] == nums[pos]; i++ { + posrlc++ + } + + // Case 1: move forward, excluding nums[pos] + tempSetWithoutPos := make([]int, len(setSoFar)) + copy(tempSetWithoutPos, setSoFar) + + newResults := computePowerSetWithDup(nums, pos+posrlc, tempSetWithoutPos, results) + + // Case 2: move forwawrd, including nums[pos] + for i := 1; i <= posrlc; i++ { + tempSetWithPos := []int{} + + tempSetWithPos = append(tempSetWithPos, setSoFar...) + + for j := 0; j < i; j++ { + tempSetWithPos = append(tempSetWithPos, nums[pos]) + } + + newResults = computePowerSetWithDup(nums, pos+posrlc, tempSetWithPos, newResults) + } + + return newResults +} + +func test1() { + results := subsetsWithDup([]int{1, 2, 3}) + + fmt.Printf("power set: %v\n", results) +} + +func test2() { + results := subsetsWithDup([]int{}) + + fmt.Printf("power set: %v\n", results) +} + +func test3() { + results := subsetsWithDup([]int{1}) + + fmt.Printf("power set: %v\n", results) +} + +func test4() { + results := subsetsWithDup([]int{1, 2, 2}) + + fmt.Printf("power set: %v\n", results) +} + +func main() { + test1() + test2() + test3() + test4() +}