Merge branch 'develop'

Chapter 17: Dynamic Programming

Author: gardncl

dynamicprogramming/README.md

@@ -0,0 +1,14 @@
+# Chapter 17: Dynamic Programming
+
+* 17.1 ComputeScoreCombinations
+* 17.2 ComputeLevenshtein
+* 17.3 CountPossibleTraversals
+* 17.4 ComputeBinomialCoefficients
+* 17.5 SearchSequence2D
+* 17.6 KnapsackProblem
+* 17.7 BedBathBeyondProblem
+* 17.8 MinimumWeightPathTriangle
+* 17.9 MaximumCoinsGain
+* 17.10 CountMovesToClimbStairs
+* 17.11 PrettyPrintingProblem
+* 17.12 LongestNondecreasingSubsequence

dynamicprogramming/pom.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>elements-of-programming-interviews</artifactId>
+        <groupId>gardncl</groupId>
+        <version>1.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>dynamicprogramming</artifactId>
+    <name>Chapter 17: Dynamic Programming</name>
+    <dependencies>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>datastructures</artifactId>
+            <version>1.0</version>
+        </dependency>
+    </dependencies>
+
+</project>

dynamicprogramming/src/main/java/BedBathBeyondProblem.java

@@ -0,0 +1,20 @@
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class BedBathBeyondProblem {
+
+    /*
+    17.7
+
+    Given a dictionary, i.e., a set of strings, and a name,
+    design an efficient algorithm that checks whether the
+    name is the concatenation of a sequence of dictionary
+     words. If such a concatenation exists, return it.
+     */
+
+    public static List<String> decompose(String domain, Set<String> dictionary) {
+
+        return Collections.emptyList();
+    }
+}

dynamicprogramming/src/main/java/ComputeBinomialCoefficients.java

@@ -0,0 +1,15 @@
+public class ComputeBinomialCoefficients {
+
+    /*
+    17.4
+
+    Design an efficient algorithm for computing (n choose k)
+    which has the property that it never overflows if the
+    final result fits in the integer work size.
+     */
+
+    public static int compute(int n, int k) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/ComputeLevenshtein.java

@@ -0,0 +1,16 @@
+public class ComputeLevenshtein {
+
+    /*
+    17.2
+
+    Write a program that takes two strings and
+    computes the minimum number of edits needed
+    to transform the first string into the
+    second string.
+     */
+
+    public static int levenschteinDistance(String A, String B) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/ComputeScoreCombinations.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class ComputeScoreCombinations {
+
+    /*
+    17.1
+
+    Write a program that takes a final score and scores for
+    individual plays, and returns the number of combinations
+    of plays that result in teh final score.
+     */
+
+    public static int compute(int finalScore, List<Integer> playScores) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/CountMovesToClimbStairs.java

@@ -0,0 +1,15 @@
+public class CountMovesToClimbStairs {
+
+    /*
+    17.10
+
+    Write a program which takes as inputs n and k and
+    returns the number of ways in which you can get
+    to your destination.
+     */
+
+    public static int numberOfWays(int top, int maximumStep) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/CountPossibleTraversals.java

@@ -0,0 +1,15 @@
+public class CountPossibleTraversals {
+
+    /*
+    17.3
+
+    Write a program that counts how many ways you
+    can go from the top-left to the bottom-right
+    in a 2D array.
+     */
+
+    public static int numberOfWays(int n, int m) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/KnapsackProblem.java

@@ -0,0 +1,19 @@
+import java.util.List;
+
+public class KnapsackProblem {
+
+    /*
+    17.6
+
+    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) {
+
+        return 0;
+    }
+}

dynamicprogramming/src/main/java/LongestNondecreasingSubsequence.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class LongestNondecreasingSubsequence {
+
+    /*
+    17.12
+
+    Write a program that takes as input an array of numbers and
+    returns the length of a longest nondecreasing subsequence
+    in the array.
+     */
+
+    public static int compute(List<Integer> A) {
+
+        return 0;
+    }
+}