chapter 17: dynamic programming done

Author: gardncl

dynamicprogramming/src/main/java/KnapsackProblem.java

@@ -8,6 +8,8 @@ public class KnapsackProblem {
     Write a program for the knapsack problem that selects a
     subset of items that has maximum value and satisfies
     the weight constraint.
+
+    Tuple -> (cost,weight)
      */
 
     public static int compute(List<Tuple> items, int capacity) {

dynamicprogramming/src/test/java/BedBathBeyondProblemTest.java

@@ -0,0 +1,41 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+public class BedBathBeyondProblemTest {
+
+    private List<String> expected;
+    private String domain;
+    private Set<String> dictionary;
+
+    @Test
+    public void decompose1() throws Exception {
+        expected = Arrays.asList(
+                "a",
+                "man",
+                "a",
+                "plan",
+                "a",
+                "canal"
+        );
+        domain = "amanaplanacanal";
+        dictionary = new HashSet<>(Arrays.asList(
+                "a",
+                "man",
+                "plan",
+                "canal"
+        ));
+
+        test(expected, domain, dictionary);
+    }
+
+    private static void test(List<String> expected, String domain, Set<String> dictionary) {
+        assertEquals(expected, BedBathBeyondProblem.decompose(domain, dictionary));
+    }
+
+}

dynamicprogramming/src/test/java/ComputeBinomialCoefficientsTest.java

@@ -0,0 +1,42 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ComputeBinomialCoefficientsTest {
+
+    private int expected;
+    private int n;
+    private int m;
+
+    @Test
+    public void compute1() throws Exception {
+        expected = 10;
+        n = 5;
+        m = 2;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void compute2() throws Exception {
+        expected = 850668;
+        n = 42;
+        m = 37;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void compute3() throws Exception {
+        expected = 245157;
+        n = 23;
+        m = 7;
+
+        test(expected, n, m);
+    }
+
+    private void test(int expected, int n, int m) {
+        assertEquals(expected, ComputeBinomialCoefficients.compute(n, m));
+    }
+
+}

dynamicprogramming/src/test/java/ComputeLevenshteinTest.java

@@ -0,0 +1,42 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ComputeLevenshteinTest {
+
+    private int expected;
+    private String A;
+    private String B;
+
+    @Test
+    public void levenschteinDistance1() throws Exception {
+        expected = 4;
+        A = "Saturday";
+        B = "Sunday";
+
+        test(expected, A, B);
+    }
+
+    @Test
+    public void levenschteinDistance2() throws Exception {
+        expected = 2;
+        A = "book";
+        B = "back";
+
+        test(expected, A, B);
+    }
+
+    @Test
+    public void levenschteinDistance3() throws Exception {
+        expected = 9;
+        A = "fantastic";
+        B = "excellent";
+
+        test(expected, A, B);
+    }
+
+    private void test(int expected, String A, String B) {
+        assertEquals(expected, ComputeLevenshtein.levenschteinDistance(A,B));
+    }
+
+}

dynamicprogramming/src/test/java/CountMovesToClimbStairsTest.java

@@ -0,0 +1,33 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CountMovesToClimbStairsTest {
+
+    private int expected;
+    private int top;
+    private int maximumStep;
+
+    @Test
+    public void numberOfWays1() throws Exception {
+        expected = 5;
+        top = 4;
+        maximumStep = 2;
+
+        test(expected, top, maximumStep);
+    }
+
+    @Test
+    public void numberOfWays2() throws Exception {
+        expected = 12;
+        top = 5;
+        maximumStep = 3;
+
+        test(expected, top, maximumStep);
+    }
+
+    private void test(int expected, int top, int maximumStep) {
+        assertEquals(expected, CountMovesToClimbStairs.numberOfWays(top, maximumStep));
+    }
+
+}

dynamicprogramming/src/test/java/CountPossibleTraversalsTest.java

@@ -0,0 +1,60 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CountPossibleTraversalsTest {
+
+    private int expected;
+    private int n;
+    private int m;
+
+    @Test
+    public void numberOfWays1() throws Exception {
+        expected = 2;
+        n = 2;
+        m = 2;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void numberOfWays2() throws Exception {
+        expected = 3;
+        n = 2;
+        m = 3;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void numberOfWays3() throws Exception {
+        expected = 20;
+        n = 3;
+        m = 4;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void numberOfWays4() throws Exception {
+        expected = 35;
+        n = 4;
+        m = 5;
+
+        test(expected, n, m);
+    }
+
+    @Test
+    public void numberOfWays5() throws Exception {
+        expected = 70;
+        n = 5;
+        m = 5;
+
+        test(expected, n, m);
+    }
+
+    private void test(int expected, int n, int m) {
+        assertEquals(expected, CountPossibleTraversals.numberOfWays(n, m));
+    }
+
+}

dynamicprogramming/src/test/java/KnapsackProblemTest.java

@@ -0,0 +1,44 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class KnapsackProblemTest {
+
+    private int expected;
+    private List<Tuple> items;
+    private int capacity;
+
+    @Test
+    public void compute1() throws Exception {
+        expected = 695;
+        items = Arrays.asList(
+                new Tuple(65,20),
+                new Tuple(35,8),
+                new Tuple(245,60),
+                new Tuple(195,55),
+                new Tuple(65,55),
+                new Tuple(150,70),
+                new Tuple(275,85),
+                new Tuple(155,25),
+                new Tuple(120,30),
+                new Tuple(320,65),
+                new Tuple(75,75),
+                new Tuple(40,10),
+                new Tuple(200,95),
+                new Tuple(100,50),
+                new Tuple(220,40),
+                new Tuple(99,10)
+        );
+        capacity = 130;
+
+        test(expected, items, capacity);
+    }
+
+    private void test(int expected, List<Tuple> items, int capacity) {
+        assertEquals(expected, KnapsackProblem.compute(items, capacity));
+    }
+
+}

dynamicprogramming/src/test/java/LongestNondecreasingSubsequenceTest.java

@@ -0,0 +1,41 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class LongestNondecreasingSubsequenceTest {
+
+    private int expected;
+    private List<Integer> A;
+
+    @Test
+    public void compute1() throws Exception {
+        expected = 4;
+        A = Arrays.asList(0,8,4,12,2,10,6,14,1,9);
+
+        test(expected, A);
+    }
+
+    @Test
+    public void compute2() throws Exception {
+        expected = 5;
+        A = Arrays.asList(0,8,4,12,2,10,6,14,1,14);
+
+        test(expected, A);
+    }
+
+    @Test
+    public void compute3() throws Exception {
+        expected = 4;
+        A = Arrays.asList(0,8,4,12,2,15,6,14,1,9);
+
+        test(expected, A);
+    }
+
+    private void test(int expected, List<Integer> A) {
+        assertEquals(expected, LongestNondecreasingSubsequence.compute(A));
+    }
+
+}

dynamicprogramming/src/test/java/MaximumCoinsGainTest.java

@@ -0,0 +1,41 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class MaximumCoinsGainTest {
+
+    private int expected;
+    private List<Integer> coins;
+
+    @Test
+    public void computeMaximum1() throws Exception {
+        expected = 5;
+        coins = Arrays.asList(1,5);
+
+        test(expected, coins);
+    }
+
+    @Test
+    public void computeMaximum2() throws Exception {
+        expected = 15;
+        coins = Arrays.asList(5,1,10,5);
+
+        test(expected, coins);
+    }
+
+    @Test
+    public void computeMaximum3() throws Exception {
+        expected = 31;
+        coins = Arrays.asList(10,25,5,1,10,5);
+
+        test(expected, coins);
+    }
+
+    private static void test(int expected, List<Integer> coins) {
+        assertEquals(expected, MaximumCoinsGain.computeMaximum(coins));
+    }
+
+}