dynamic prog HF

dynamicprogramming/java/dynamicprog.iml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

dynamicprogramming/java/src/com/brainbaking/dynamic/sequencing/LongestCommonSubsequence.java

@@ -0,0 +1,41 @@
+package com.brainbaking.dynamic.sequencing;
+
+public class LongestCommonSubsequence {
+
+    public String calculate(String a, String b) {
+        int[][] lengths = new int[a.length() + 1][b.length() + 1];
+        char[] as = a.toCharArray();
+        char[] bs = b.toCharArray();
+
+        for(int i = 1; i <= a.length(); i++) {
+            for(int j = 1; j <= b.length(); j++) {
+
+                if(as[i - 1] == bs[j - 1]) {
+                    lengths[i][j] = lengths[i - 1][j - 1] + 1;
+                } else {
+                    lengths[i][j] = Math.max(lengths[i][j - 1], lengths[i - 1][j]);
+                }
+            }
+        }
+
+        return retrace(lengths, as, as.length, bs.length);
+    }
+
+    private String retrace(int[][] lengths, char[] as, int i, int j) {
+        if(i == 0 || j == 0) return "";
+
+        int l = lengths[i][j];
+        int ltop = lengths[i - 1][j];
+        int lright = lengths[i][j - 1];
+
+        if(ltop == l) {
+            return retrace(lengths, as, i - 1, j);
+        } else if(lright == l) {
+            return retrace(lengths, as, i, j - 1);
+        } else {
+            return retrace(lengths, as, i - 1, j - 1) + as[i - 1];
+        }
+
+    }
+
+}

dynamicprogramming/java/src/com/brianbaking/dynamic/fibo/Fiboable.java

@@ -0,0 +1,9 @@
+package com.brianbaking.dynamic.fibo;
+
+import java.util.List;
+
+public interface Fiboable {
+
+    List<Integer> calculate(int count);
+
+}

dynamicprogramming/java/src/com/brianbaking/dynamic/fibo/NaiveFibonacci.java

@@ -0,0 +1,19 @@
+package com.brianbaking.dynamic.fibo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NaiveFibonacci implements Fiboable {
+
+    public List<Integer> calculate(int count) {
+        List<Integer> nrs = new ArrayList<>();
+        nrs.add(0);
+        nrs.add(1);
+
+        for(int i = 2; i <= count; i++) {
+            nrs.add(nrs.get(i - 1) + nrs.get(i - 2));
+        }
+
+        return nrs;
+    }
+}

dynamicprogramming/java/src/com/brianbaking/dynamic/fibo/RecursiveFibo.java

@@ -0,0 +1,24 @@
+package com.brianbaking.dynamic.fibo;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class RecursiveFibo implements Fiboable {
+
+    @Override
+    public List<Integer> calculate(int count) {
+        ArrayList<Integer> list = new ArrayList<>();
+        list.addAll(Arrays.asList(0, 1));
+        calculateRecursively(2, count, list);
+        return list;
+    }
+
+    private void calculateRecursively(int index, int count, List<Integer> list) {
+        if(index <= count) {
+            list.add(list.get(index - 1) + list.get(index - 2));
+            calculateRecursively(index + 1, count, list);
+        }
+    }
+}

dynamicprogramming/java/test/com/brainbaking/dynamic/fibo/FibonacciTest.java

@@ -0,0 +1,30 @@
+package com.brainbaking.dynamic.fibo;
+
+import com.brianbaking.dynamic.fibo.Fiboable;
+import com.brianbaking.dynamic.fibo.NaiveFibonacci;
+import com.brianbaking.dynamic.fibo.RecursiveFibo;
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class FibonacciTest {
+
+    @Test
+    public void calculateNaive() {
+        testFibo(new NaiveFibonacci());
+    }
+
+    @Test
+    public void calculateRecursively() {
+        testFibo(new RecursiveFibo());
+    }
+
+    private void testFibo(Fiboable fibo) {
+        String result = fibo.calculate(10).stream().map(i -> i.toString()).collect(Collectors.joining(","));
+
+        assertEquals("0,1,1,2,3,5,8,13,21,34,55", result);
+    }
+
+}

dynamicprogramming/java/test/com/brainbaking/dynamic/sequencing/LongestCommonSubsequenceTest.java

@@ -0,0 +1,18 @@
+package com.brainbaking.dynamic.sequencing;
+
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class LongestCommonSubsequenceTest {
+
+    @Test
+    public void longestCommonSubSequence() {
+        LongestCommonSubsequence sequencer = new LongestCommonSubsequence();
+
+        String result = sequencer.calculate("ABCBDAB", "BDCABA");
+
+        assertEquals("BCBA", result);
+    }
+
+}