add max number and interleaving strings problems (#114)

Author: spring1843

README.md

@@ -8,6 +8,7 @@
 
 Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is designed as a dynamic, hands-on resource for learning and practicing data structures and algorithms in the Go programming language.
 
+* At least six problems and solutions for each of the fourteen topics
 * Completely free, community-driven, and continuously evolving
 * Executes and comes with 100% test coverage, ensuring a high level of quality
 * Ability to use in your favorite IDE, editor, or web browser
@@ -122,11 +123,13 @@ Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is design
         * [Activity Selector](./greedy/activity_selector_test.go)
         * [Knapsack](./greedy/knapsack_test.go)
         * [Jump Game](./greedy/jump_game_test.go)
+        * [Maximum Number](./greedy/max_number_test.go)
         * [Task Scheduling](./greedy/task_scheduling_test.go)
     * [Dynamic Programming](./dp/README.md)
         * [Rod Cutting](./dp/rod_cutting_test.go)
         * [Sum Up to Number](./dp/sum_up_to_integer_test.go)
         * [House Robber](./dp/house_robber_test.go)
+        * [Interleaving String](./dp/interleaving_string_test.go)
         * [Minimum Deletion to Make a Palindrome](./dp/minimum_deletion_to_make_palindrome_test.go)
         * [Word Distance](./dp/word_distance_test.go)
 

dp/README.md

@@ -31,8 +31,9 @@ DP is well-suited for tackling complex problems, including logistics, game theor
 
 ## Rehearsal
 
-* [Rod Cutting](rod_cutting_test.go), [Solution](rod_cutting.go)
-* [Sum Up to Number](sum_up_to_integer_test.go), [Solution](sum_up_to_integer.go)
-* [House Robber](house_robber_test.go), [Solution](house_robber.go).
-* [Minimum Deletion to Make a Palindrome](minimum_deletion_to_make_palindrome_test.go), [Solution](minimum_deletion_to_make_palindrome.go)
-* [Word Distance](word_distance_test.go), [Solution](word_distance.go.go)
+* [Rod Cutting](./rod_cutting_test.go), [Solution](./rod_cutting.go)
+* [Sum Up to Number](./sum_up_to_integer_test.go), [Solution](./sum_up_to_integer.go)
+* [House Robber](./house_robber_test.go), [Solution](./house_robber.go).
+* [Interleaving String](./interleaving_string_test.go), [Solution](./interleaving_string.go)
+* [Minimum Deletion to Make a Palindrome](./minimum_deletion_to_make_palindrome_test.go), [Solution](./minimum_deletion_to_make_palindrome.go)
+* [Word Distance](./word_distance_test.go), [Solution](./word_distance.go.go)

dp/interleaving_string.go

@@ -0,0 +1,42 @@
+package dp
+
+// IsInterleavingString solves the problem in O(m*n) time and O(m*n) space.
+func IsInterleavingString(a, b, input string) bool {
+	m, n := len(a), len(b)
+	if len(input) != m+n {
+		return false
+	}
+
+	dp := dpMap(m, n, a, b, input)
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			if a[i-1] == input[i+j-1] {
+				dp[i][j] = dp[i][j] || dp[i-1][j]
+			}
+			if b[j-1] == input[i+j-1] {
+				dp[i][j] = dp[i][j] || dp[i][j-1]
+			}
+		}
+	}
+	return dp[m][n]
+}
+
+func dpMap(m, n int, a, b, input string) [][]bool {
+	dp := make([][]bool, m+1)
+	for i := range dp {
+		dp[i] = make([]bool, n+1)
+	}
+	dp[0][0] = true
+	for i := 1; i <= m; i++ {
+		if a[i-1] == input[i-1] {
+			dp[i][0] = dp[i-1][0]
+		}
+	}
+
+	for j := 1; j <= n; j++ {
+		if b[j-1] == input[j-1] {
+			dp[0][j] = dp[0][j-1]
+		}
+	}
+	return dp
+}

dp/interleaving_string_test.go

@@ -0,0 +1,44 @@
+package dp
+
+import (
+	"testing"
+)
+
+/*
+TestIsInterleavingString tests solution(s) with the following signature and problem description:
+
+	IsInterleavingString(a, b, input string) bool
+
+Given three strings a,b, and input, return true if input is made by interleaving a and b such that
+it contains all their characters while maintaining their order.
+
+Example:
+"a", "bcd", "abcd" would return true.
+"a", "bdc", "abd" would return false, because c is missing.
+"a", "bdc", "abc" would return false, because d is missing.
+*/
+func TestIsInterleavingString(t *testing.T) {
+	tests := []struct {
+		a, b, input          string
+		isInterleavingString bool
+	}{
+		{"a", "b", "ab", true},
+		{"abc", "def", "abcdef", true},
+		{"ac", "bdef", "abcdef", true},
+		{"abe", "cdf", "abcdef", true},
+		{"abd", "cef", "abcdef", true},
+		{"a", "bdc", "abdc", true},
+		{"a", "bdc", "abd", false},
+		{"a", "bdc", "abc", false},
+		{"bdc", "a", "abc", false},
+		{"bcd", "a", "abcd", true},
+		{"abcd", "a", "aabcd", true},
+		{"aaac", "aaab", "aaaaaabc", true},
+	}
+
+	for i, test := range tests {
+		if got := IsInterleavingString(test.a, test.b, test.input); test.isInterleavingString != got {
+			t.Fatalf("Failed test case #%d. Want %t got %t", i, test.isInterleavingString, got)
+		}
+	}
+}

greedy/README.md

@@ -29,8 +29,9 @@ Greedy algorithms can be applied to optimization problems in which the aim is to
 
 ## Rehearsal
 
-* [Maximum Stock Profit](max_stock_profit_test.go), [Solution](max_stock_profit.go)
-* [Activity Selector](activity_selector_test.go), [Solution](activity_selector.go)
-* [Knapsack](knapsack_test.go), [Solution](knapsack.go)
-* [Jump Game](jump_game_test.go), [Solution](jump_game.go)
-* [Task Scheduling](task_scheduling_test.go), [Solution](task_scheduling.go)
+* [Maximum Stock Profit](./max_stock_profit_test.go), [Solution](./max_stock_profit.go)
+* [Activity Selector](./activity_selector_test.go), [Solution](./activity_selector.go)
+* [Knapsack](./knapsack_test.go), [Solution](./knapsack.go)
+* [Jump Game](./jump_game_test.go), [Solution](./jump_game.go)
+* [Maximum Number](./max_number_test.go), [Solution](./max_number.go)
+* [Task Scheduling](./task_scheduling_test.go), [Solution](./task_scheduling.go)

greedy/max_number.go

@@ -0,0 +1,64 @@
+package greedy
+
+// MaxNumber solves the problem in O(n^2) time and O(n) space.
+func MaxNumber(number1, number2 []int, n int) []int {
+	output := []int{}
+	if n > len(number1)+len(number2) {
+		return output
+	}
+
+	for pickFromNumber1 := min(len(number1), n); pickFromNumber1 >= 0; pickFromNumber1-- {
+		pickFromNumber2 := n - pickFromNumber1
+		if pickFromNumber2 <= len(number2) {
+			merged := merge(maximumNumberInSequence(number1, pickFromNumber1), maximumNumberInSequence(number2, pickFromNumber2))
+			if len(output) == 0 || isGreater(merged, output) {
+				output = merged
+			}
+		}
+	}
+	return output
+}
+
+func merge(a, b []int) []int {
+	output := make([]int, len(a)+len(b))
+	var i, j int
+	for k := 0; k < len(a)+len(b); k++ {
+		if isGreater(a[i:], b[j:]) {
+			output[k] = a[i]
+			i++
+			continue
+		}
+		output[k] = b[j]
+		j++
+	}
+	return output
+}
+
+func isGreater(a, b []int) bool {
+	for i := 0; i < len(a) && i < len(b); i++ {
+		if a[i] != b[i] {
+			return a[i] > b[i]
+		}
+	}
+	return len(a) > len(b)
+}
+
+func maximumNumberInSequence(input []int, k int) []int {
+	stack := make([]int, 0, k)
+	for i, num := range input {
+		for len(stack) > 0 && len(input)-i > k-len(stack) && num > stack[len(stack)-1] {
+			stack = stack[:len(stack)-1]
+		}
+		if len(stack) < k {
+			stack = append(stack, num)
+		}
+	}
+	return stack
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

greedy/max_number_test.go

@@ -0,0 +1,46 @@
+package greedy
+
+import (
+	"reflect"
+	"testing"
+)
+
+/*
+TestMaxNumber tests solution(s) with the following signature and problem description:
+
+	func MaxNumber(number1, number2 []int, n int) []int
+
+Given two numbers represented as list of positive integers, and an integer n, return the
+largest possible integer with n digits that can be constructed by merging digits from two
+numbers while respecting the order of digits in each number.
+
+For example given {5, 4, 3, 2, 1}, {9, 8, 7, 6} and 9, it should return a 9 digit number
+{9, 8, 7, 6, 5, 4, 3, 2, 1}.
+*/
+func TestMaxNumber(t *testing.T) {
+	tests := []struct {
+		number1       []int
+		number2       []int
+		k             int
+		largestNumber []int
+	}{
+		{[]int{}, []int{}, 1, []int{}},
+		{[]int{}, []int{1}, 1, []int{1}},
+		{[]int{0}, []int{1}, 1, []int{1}},
+		{[]int{0}, []int{1}, 2, []int{1, 0}},
+		{[]int{1}, []int{0}, 2, []int{1, 0}},
+		{[]int{1}, []int{2}, 4, []int{}},
+		{[]int{2}, []int{1}, 4, []int{}},
+		{[]int{3, 2, 1}, []int{1}, 3, []int{3, 2, 1}},
+		{[]int{6, 9}, []int{6, 0, 4}, 5, []int{6, 9, 6, 0, 4}},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, 4, []int{3, 1, 2, 3}},
+		{[]int{5, 4, 3, 2, 1}, []int{9, 8, 7, 6}, 9, []int{9, 8, 7, 6, 5, 4, 3, 2, 1}},
+		{[]int{5, 4, 3, 2, 1}, []int{9, 8, 7, 6}, 8, []int{9, 8, 7, 6, 5, 4, 3, 2}},
+	}
+
+	for i, test := range tests {
+		if got := MaxNumber(test.number1, test.number2, test.k); !reflect.DeepEqual(got, test.largestNumber) {
+			t.Fatalf("Failed test case #%d. Want %#v got %#v", i, test.largestNumber, got)
+		}
+	}
+}