problem 49,50

Author: TipsyPixie

Makefile

@@ -1,4 +1,4 @@
-TEST_OPTS=-v -cover -timeout 10s -count 1
+TEST_OPTS=-cover -timeout 10s -count 1
 FIND=find -maxdepth 1 -type d -regextype posix-extended -regex '^\.\/problem[0-9]{1,3}$$'
 VET_OPTS=
 FMT_OPTS=-l -s -w

README.md

@@ -64,7 +64,7 @@ Number | Difficulty | Asked By | Title
 [#45](problem045) | EASY | Two Sigma | Writing rand function
 [#46](problem046) | HARD | Amazon | Finding the longest palindromic substring
 [#47](problem047) | EASY | Facebook | Calculating maximum profit with chronological stock prices
-[#48](problem048) | MEDIUM | Google | Build a tree with given pre-order and in-order traversals
-[#49](problem049) |  |  |
-[#50](problem050) |  |  |
+[#48](problem048) | MEDIUM | Google | Building a tree with given pre-order and in-order traversals
+[#49](problem049) | MEDIUM | Amazon | Finding the maximum sum of contiguous subarray
+[#50](problem050) | EASY | Microsoft | Arithmetic binary tree
 

problem048/problem048_test.go

@@ -40,7 +40,7 @@ func TestFromValues(t *testing.T) {
 			},
 		},
 	}
-	for i, _ := range testArgs {
+	for i := range testArgs {
 		answer := FromValues(testArgs[i], testArgs2[i])
 		if !answer.Equal(&correctAnswer) {
 			t.Log(fmt.Sprintf("failed at %v, %v", testArgs[i], testArgs2[i]))

problem049/README.md

@@ -0,0 +1,14 @@
+## Daily Coding Problem: Problem #49
+
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Amazon.
+
+Given an array of numbers, find the maximum sum of any contiguous subarray of the array.
+
+For example, given the array `[34, -50, 42, 14, -5, 86]`, the maximum sum would be 137, since we would take elements 42, 14, -5, and 86.
+
+Given the array `[-5, -1, -8, -9]`, the maximum sum would be 0, since we would not take any elements.
+
+Do this in O(N) time.
+

problem049/problem049.go

@@ -0,0 +1,29 @@
+package problem049
+
+func MaximizeContiguousSum(values []int) int {
+	// ex) [10, 20, -50, 24, 1, -10, 20, -6] => [10, 20, -50] [24, 1, -10, 20] [-6]
+	totalSum := 0
+	for _, value := range values {
+		totalSum += value
+	}
+
+	leftExcludedMinSum, leftExcludedSum, leftExcludedEndsAt := 0, 0, 0
+	rightExcludedMinSum, rightExcludedSum, rightExcludedStartsAt := totalSum, totalSum, 0
+	for i := range values {
+		if leftExcludedSum += values[i]; leftExcludedSum < leftExcludedMinSum {
+			leftExcludedEndsAt = i + 1
+		}
+		if rightExcludedSum -= values[i]; rightExcludedSum < rightExcludedMinSum {
+			rightExcludedStartsAt = i + 1
+		}
+	}
+
+	if leftExcludedEndsAt >= rightExcludedStartsAt {
+		return 0
+	}
+	maxContiguousSum := 0
+	for _, value := range values[leftExcludedEndsAt:rightExcludedStartsAt] {
+		maxContiguousSum += value
+	}
+	return maxContiguousSum
+}

problem049/problem049_test.go

@@ -0,0 +1,21 @@
+package problem049
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMaximizeContiguousSum(t *testing.T) {
+	testArgs := [][]int{
+		{34, -50, 42, 14, -5, 86},
+		{-5, -1, -8, -9},
+	}
+	correctResult := []int{137, 0}
+	for i, arg := range testArgs {
+		result := MaximizeContiguousSum(arg)
+		if result != correctResult[i] {
+			t.Log(fmt.Sprintf("%v: %d != %d", arg, result, correctResult))
+			t.Fail()
+		}
+	}
+}

problem050/README.md

@@ -0,0 +1,21 @@
+## Daily Coding Problem: Problem #50
+
+Good morning! Here's your coding interview problem for today.
+
+This problem was asked by Microsoft.
+
+Suppose an arithmetic expression is given as a binary tree. Each leaf is an integer and each internal node is one of '+', '−', '∗', or '/'.
+
+Given the root to such a tree, write a function to evaluate it.
+
+For example, given the following tree:
+
+```
+    *
+   / \
+  +    +
+ / \  / \
+3  2  4  5
+```
+
+You should return 45, as it is (3 + 2) * (4 + 5).

problem050/problem050.go

@@ -0,0 +1,44 @@
+package problem050
+
+import "errors"
+
+type TreeNode interface {
+	evaluate() (int, error)
+}
+
+type OperatorNode struct {
+	value rune
+	left  TreeNode
+	right TreeNode
+}
+
+func (operatorNode OperatorNode) evaluate() (int, error) {
+	leftValue, err := operatorNode.left.evaluate()
+	if err != nil {
+		return 0, err
+	}
+	rightValue, err := operatorNode.right.evaluate()
+	if err != nil {
+		return 0, err
+	}
+	switch operatorNode.value {
+	case '+':
+		return leftValue + rightValue, nil
+	case '-':
+		return leftValue - rightValue, nil
+	case '*':
+		return leftValue * rightValue, nil
+	case '/':
+		return leftValue / rightValue, nil
+	default:
+		return 0, errors.New("invalid operator")
+	}
+}
+
+type NumberNode struct {
+	value int
+}
+
+func (numberNode NumberNode) evaluate() (int, error) {
+	return numberNode.value, nil
+}

problem050/problem050_test.go

@@ -0,0 +1,29 @@
+package problem050
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestEvaluate(t *testing.T) {
+	tree := OperatorNode{
+		value: '*',
+		left: OperatorNode{
+			value: '+',
+			left:  TreeNode(&NumberNode{3}),
+			right: TreeNode(&NumberNode{2}),
+		},
+		right: OperatorNode{
+			value: '+',
+			left:  TreeNode(&NumberNode{4}),
+			right: TreeNode(&NumberNode{5}),
+		},
+	}
+	result, err := tree.evaluate()
+	correctResult := (3 + 2) * (4 + 5)
+	if err != nil || result != correctResult {
+		t.Error(err)
+		t.Error(fmt.Sprintf("%d != %d", result, correctResult))
+		t.Fail()
+	}
+}