problem 42, 43

Author: TipsyPixie

README.md

@@ -58,3 +58,6 @@ Number | Difficulty | Asked By | Title
 [#39](problem039) | MEDIUM | Dropbox | Conway's Game of Life
 [#40](problem040) | HARD | Google | Finding the non-duplicated number
 [#41](problem041) | MEDIUM | Facebook | Finding full itinerary from a list of flights
+[#42](problem042) | HARD | Google | Finding a subset of S that adds up to k
+[#43](problem043) | EASY | Amazon | Implementing Stack
+

problem041/README.md

@@ -11,4 +11,4 @@ For example, given the list of flights `[('SFO', 'HKO'), ('YYZ', 'SFO'), ('YUL',
 Given the list of flights `[('SFO', 'COM'), ('COM', 'YYZ')]` and starting airport 'COM', you should return null.
 
 Given the list of flights `[('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'A')]` and starting airport 'A', ~~you should return the list `['A', 'B', 'C', 'A', 'C']` even though `['A', 'C', 'A', 'B', 'C']` is also a valid itinerary. However, the first one is lexicographically smaller.~~
-**you should return nil.**
+**you should return null.**

problem042/README.md

@@ -0,0 +1,11 @@
+## Daily Coding Problem: Problem #42 [HARD]
+
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Google.
+
+Given a list of integers S and a target number k, write a function that returns a subset of S that adds up to k. If such a subset cannot be made, then return null.
+
+Integers can appear more than once in the list. You may assume all numbers in the list are positive.
+
+For example, given S = [12, 1, 61, 5, 9, 2] and k = 24, return [12, 9, 2, 1] since it sums up to 24.

problem042/problem042.go

@@ -0,0 +1,18 @@
+package problem042
+
+func GetSubset(values []int, sum int) []int {
+	if len(values) == 0 {
+		if sum == 0 {
+			return []int{}
+		} else {
+			return nil
+		}
+	}
+	if subsetWithoutFirstItem := GetSubset(values[1:], sum); subsetWithoutFirstItem != nil {
+		return subsetWithoutFirstItem
+	}
+	if subsetWithFirstItem := GetSubset(values[1:], sum-values[0]); subsetWithFirstItem != nil {
+		return append(values[0:1], subsetWithFirstItem...)
+	}
+	return nil
+}

problem042/problem042_test.go

@@ -0,0 +1,23 @@
+package problem042
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestGetSubset(t *testing.T) {
+	values := []int{12, 1, 61, 5, 9, 2}
+	k := 24
+	answer, correctAnswer := GetSubset(values, k), []int{12, 1, 9, 2}
+	if !reflect.DeepEqual(answer, correctAnswer) {
+		t.Log(fmt.Sprintf("%v, %d: %v != %v", values, k, answer, correctAnswer))
+		t.FailNow()
+	}
+	j := 61
+	answer2, correctAnswer2 := GetSubset(values, j), []int{61}
+	if !reflect.DeepEqual(answer, correctAnswer) {
+		t.Log(fmt.Sprintf("%v, %d: %v != %v", values, j, answer2, correctAnswer2))
+		t.FailNow()
+	}
+}

problem043/README.md

@@ -0,0 +1,16 @@
+## Daily Coding Problem: Problem #43 [EASY]
+
+
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Amazon.
+
+Implement a stack that has the following methods:
+
+---
+* push(val), which pushes an element onto the stack
+* pop(), which pops off and returns the topmost element of the stack. If there are no elements in the stack, then it should throw an error or return null.
+* max(), which returns the maximum value in the stack currently. If there are no elements in the stack, then it should throw an error or return null.
+---
+
+Each method should run in constant time.

problem043/problem043.go

@@ -0,0 +1,64 @@
+package problem043
+
+type stack struct {
+	values        []int
+	maxValueStack *stack
+}
+
+type StackEmptyError struct{}
+
+func (stackEmptyError StackEmptyError) Error() string {
+	return "StackEmptyError"
+}
+
+func NewStack(initialCapacity uint) *stack {
+	return &stack{
+		values: make([]int, 0, initialCapacity),
+		maxValueStack: &stack{
+			values:        make([]int, 0, initialCapacity),
+			maxValueStack: nil,
+		},
+	}
+}
+
+func (thisStack *stack) peek() (int, error) {
+	if len(thisStack.values) == 0 {
+		return 0, StackEmptyError{}
+	}
+	return thisStack.values[len(thisStack.values)-1], nil
+}
+
+func (thisStack *stack) Push(value int) *stack {
+	if thisStack.maxValueStack != nil {
+		currentMaxValue, err := thisStack.maxValueStack.peek()
+		if (err != nil && err.Error() == "StackEmptyError") || currentMaxValue <= value {
+			thisStack.maxValueStack.Push(value)
+		}
+	}
+	thisStack.values = append(thisStack.values, value)
+	return thisStack
+}
+
+func (thisStack *stack) Pop() (int, error) {
+	if len(thisStack.values) == 0 {
+		return 0, StackEmptyError{}
+	}
+	value := thisStack.values[len(thisStack.values)-1]
+	thisStack.values = thisStack.values[:len(thisStack.values)-1]
+
+	if thisStack.maxValueStack != nil {
+		currentMaxValue, _ := thisStack.maxValueStack.peek()
+		if currentMaxValue == value {
+			_, _ = thisStack.maxValueStack.Pop()
+		}
+	}
+	return value, nil
+}
+
+func (thisStack *stack) Max() (int, error) {
+	currentMaxValue, err := thisStack.maxValueStack.peek()
+	if err != nil {
+		return 0, err
+	}
+	return currentMaxValue, nil
+}

problem043/problem043_test.go

@@ -0,0 +1,57 @@
+package problem043
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestStack(t *testing.T) {
+	stack := NewStack(32).Push(4).Push(10).Push(12).Push(4).Push(12)
+
+	correctAnswer := 12
+	if maxValue, err := stack.Max(); err != nil || maxValue != correctAnswer {
+		t.Log(fmt.Sprintf("Max %d != %d", maxValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	correctAnswer = 12
+	if poppedValue, err := stack.Pop(); err != nil || poppedValue != correctAnswer {
+		t.Log(fmt.Sprintf("Pop %d != %d", poppedValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	correctAnswer = 12
+	if maxValue, err := stack.Max(); err != nil || maxValue != correctAnswer {
+		t.Log(fmt.Sprintf("Max %d != %d", maxValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	correctAnswer = 4
+	if poppedValue, err := stack.Pop(); err != nil || poppedValue != correctAnswer {
+		t.Log(fmt.Sprintf("Pop %d != %d", poppedValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	_, _ = stack.Pop()
+
+	correctAnswer = 10
+	if maxValue, err := stack.Max(); err != nil || maxValue != correctAnswer {
+		t.Log(fmt.Sprintf("Max %d != %d", maxValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	_, _ = stack.Pop()
+
+	correctAnswer = 4
+	if maxValue, err := stack.Max(); err != nil || maxValue != correctAnswer {
+		t.Log(fmt.Sprintf("Max %d != %d", maxValue, correctAnswer), err)
+		t.Fail()
+	}
+
+	_, _ = stack.Pop()
+
+	if _, err := stack.Pop(); err == nil {
+		t.Log("Pop without error")
+		t.Fail()
+	}
+}