Merge branch 'develop'

chapter 16 done

README.md

@@ -20,7 +20,7 @@ Suggested usage:
 Having trouble solving a problem?
 * The book contains hints that I intentionally omitted from this repository
 * The book contains thorough solutions
-* My (sometimes commented) solutions are available in the [solutions] branch
+* My (sometimes commented) [solutions] are available
 
 This project is open source so please fork it and help me create a supplement to this phenomenal book. Always looking for edge cases.
 

arrays/src/test/java/SudokuCheckerTest.java

@@ -40,7 +40,8 @@ public void isValidSudoku2() {
                 Arrays.asList(7,0,0,0,2,0,0,0,6),
                 Arrays.asList(0,6,0,0,0,0,2,8,0),
                 Arrays.asList(0,0,0,4,1,9,0,0,5),
-                Arrays.asList(0,0,0,0,8,0,0,7,9));
+                Arrays.asList(0,0,0,0,8,0,0,7,9)
+        );
 
         test(expected, board);
     }
@@ -57,7 +58,8 @@ public void isValidSudoku3() {
                 Arrays.asList(7,0,0,0,2,0,0,0,6),
                 Arrays.asList(0,6,0,0,0,0,2,8,0),
                 Arrays.asList(6,0,0,4,1,9,0,0,5),
-                Arrays.asList(0,0,0,0,8,0,0,7,9));
+                Arrays.asList(0,0,0,0,8,0,0,7,9)
+        );
 
         test(expected, board);
     }
@@ -74,7 +76,8 @@ public void isValidSudoku4() {
                 Arrays.asList(7,0,0,0,2,0,0,0,6),
                 Arrays.asList(0,6,0,0,0,0,2,8,0),
                 Arrays.asList(0,0,0,4,1,9,0,0,5),
-                Arrays.asList(0,0,0,0,8,0,0,7,9));
+                Arrays.asList(0,0,0,0,8,0,0,7,9)
+        );
 
         test(expected, board);
     }

datastructures/src/main/java/TreeNode.java

@@ -0,0 +1,21 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class TreeNode {
+    public List<Edge> edges = new ArrayList<>();
+
+    public static class Edge {
+        public TreeNode root;
+        public double length;
+
+        public Edge(double length) {
+            this.length = length;
+            root = new TreeNode();
+        }
+
+        public Edge(TreeNode root, double length) {
+            this.root = root;
+            this.length = length;
+        }
+    }
+}

pom.xml

@@ -20,6 +20,7 @@
         <module>hashtables</module>
         <module>sorting</module>
         <module>binarysearchtrees</module>
+        <module>recursion</module>
     </modules>
     <packaging>pom</packaging>
 

recursion/README.md

@@ -0,0 +1,13 @@
+# Chapter 16: Recursion
+
+* 16.1 TowersOfHanoi
+* 16.2 NQueens
+* 16.3 GeneratePermutations
+* 16.4 GeneratePowerSet
+* 16.5 GenerateSubsetsK
+* 16.6 GenerateStrings
+* 16.7 GeneratePalindromicDecompositions
+* 16.8 GenerateBinaryTrees
+* 16.9 SudokuSolver
+* 16.10 ComputeGrayCode
+* 16.11 ComputeDiameter

recursion/pom.xml

@@ -0,0 +1,29 @@
+<?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>recursion</artifactId>
+    <name>Chapter 16: Recursion</name>
+    <dependencies>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>datastructures</artifactId>
+            <version>1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>utils</artifactId>
+            <version>1.0</version>
+        </dependency>
+    </dependencies>
+
+
+
+</project>

recursion/src/main/java/ComputeDiameter.java

@@ -0,0 +1,15 @@
+public class ComputeDiameter {
+
+    /*
+    16.11
+
+    The diameter of a tree is defined to be the length
+    of a longest path in the tree. Design an efficient
+    algorithm to compute the diameter of a tree.
+     */
+
+    public static int computeDiameter(TreeNode T) {
+
+        return 0;
+    }
+}

recursion/src/main/java/ComputeGrayCode.java

@@ -0,0 +1,16 @@
+import java.util.Collections;
+import java.util.List;
+
+public class ComputeGrayCode {
+
+    /*
+    16.10
+
+    Write a program which takes n as input and returns an n-bit Gray code.
+     */
+
+    public static List<Integer> grayCode(int numBits) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GenerateBinaryTrees.java

@@ -0,0 +1,18 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GenerateBinaryTrees {
+
+    /*
+    16.8
+
+    Write a program that returns all distinct binary
+    trees with a specified number of nodes. All node
+    data must be 0.
+     */
+
+    public static List<BinaryTree<Integer>> generateAllBinaryTrees(int numNodes) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GeneratePalindromicDecompositions.java

@@ -0,0 +1,16 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GeneratePalindromicDecompositions {
+
+    /*
+    16.7
+
+    Compute all palindromic decompositions of a given string.
+     */
+
+    public static List<List<String>> palindromicPartitioning(String input) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GeneratePermutations.java

@@ -0,0 +1,18 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GeneratePermutations {
+
+    /*
+    16.3
+
+    Write a program which takes as input an array of distinct
+    integers and generates all permutations of that array. No
+    permutation of the array may appear more that once.
+     */
+
+    public static List<List<Integer>> permutations(List<Integer> A) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GeneratePowerSet.java

@@ -0,0 +1,17 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GeneratePowerSet {
+
+    /*
+    16.4
+
+    Write a function that takes as input a set and returns its
+    power set.
+     */
+
+    public static List<List<Integer>> generatePowerSet(List<Integer> inputSet) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GenerateStrings.java

@@ -0,0 +1,18 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GenerateStrings {
+
+    /*
+    16.6
+
+    Write a program that takes as input a number and returns
+    all the strings with that number of matched pairs of
+    parens.
+     */
+
+    public static List<String> generateBalancedParentheses(int numpairs) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/GenerateSubsetsK.java

@@ -0,0 +1,17 @@
+import java.util.Collections;
+import java.util.List;
+
+public class GenerateSubsetsK {
+
+    /*
+    16.5
+
+    Write a program which computes all size k subsets of [0,1,...,n],
+    where k and n are program inputs.
+     */
+
+    public static List<List<Integer>> combinations(int n, int k) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/NQueens.java

@@ -0,0 +1,18 @@
+import java.util.Collections;
+import java.util.List;
+
+public class NQueens {
+
+    /*
+    16.2
+
+    Write a program which returns all distinct non-attacking
+    placements of n queens on an nxn chessboard where n is
+    the input to the program.
+     */
+
+    public static List<List<Integer>> nQueens(int n) {
+
+        return Collections.emptyList();
+    }
+}

recursion/src/main/java/SudokuSolver.java

@@ -0,0 +1,15 @@
+import java.util.List;
+
+public class SudokuSolver {
+
+    /*
+    16.9
+
+    Implement a Sudoku solver.
+     */
+
+    public static boolean solveSudoku(List<List<Integer>> partialAssignment) {
+
+        return false;
+    }
+}

recursion/src/main/java/TowersOfHanoi.java

@@ -0,0 +1,19 @@
+public class TowersOfHanoi {
+
+    /*
+    16.1
+
+    Write a program which prints a sequence of operations that
+    transfers n rings from one peg to another. You have a third
+    peg, which is initially empty. The only operation you can
+    perform is taking a single ring from the top of one peg and
+    placing it on teh top of another peg. You must never place a
+    larger ring above a smaller ring.
+     */
+
+    private static final int NUM_PEGS = 3;
+
+    public static void compute(int numRings) {
+
+    }
+}

recursion/src/test/java/ComputeDiameterTest.java

@@ -0,0 +1,22 @@
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ComputeDiameterTest {
+
+    private int expected;
+    private TreeNode T;
+
+    @Test
+    public void computeDiameter1() throws Exception {
+        expected = 31;
+        T = TreeNodeUtil.getTreeNode();
+
+        test(expected, T);
+    }
+
+    private void test(int expected, TreeNode T) {
+        assertEquals(expected, ComputeDiameter.computeDiameter(T));
+    }
+
+}

recursion/src/test/java/ComputeGrayCodeTest.java

@@ -0,0 +1,33 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class ComputeGrayCodeTest {
+
+    private List<Integer> expected;
+    private int numBits;
+
+    @Test
+    public void grayCode1() throws Exception {
+        expected = Arrays.asList(0,1,2,3);
+        numBits = 2;
+
+        test(expected, numBits);
+    }
+
+    @Test
+    public void grayCode2() throws Exception {
+        expected = Arrays.asList(0,1,3,2,6,7,5,4);
+        numBits = 3;
+
+        test(expected, numBits);
+    }
+
+    private void test(List<Integer> expected, int numBits) {
+        AssertUtils.assertSameContentsInt(expected, ComputeGrayCode.grayCode(numBits));
+    }
+
+}