Updated solutions

Author: RodneyShag

Chp. 01 - Arrays and Strings/_1_2_Check_Permutations/CheckPermutations.java

@@ -1,34 +1,38 @@
 package _1_2_Check_Permutations;
 
-// Should ask interviewer if String is ASCII or Unicode (We assume ASCII)
+import java.util.HashMap;
 
-// Algorithm:
-// Count the different characters using an array (as shown below) or a HashMap.
-// For each String, we can save the count of each character in an array, then compare these 2 arrays.
-// However, instead of using 2 arrays, we can do it with 1, as shown below.
+// Should ask interviewer if String is ASCII or Unicode (We assume ASCII)
 
+// Algorithm
+//
+// Do a quick check on string lengths. If the lengths differ, the strings can't be anagrams
+// Save `String s` as `HashMap` of character counts
+// For `String t`, see if it can be made up of the characters of the previous `HashMap`
 
 public class CheckPermutations {
-    private static final int NUM_ASCII_CHARS = 256; // number of ASCII characters
-    public static boolean isPermutation(String s1, String s2) {
-        if (s1.length() != s2.length()) {
+
+    private static final int NUM_ASCII_CHARS = 256;
+
+    public static boolean isPermutation(String s, String t) {
+        if (s.length() != t.length()) {
             return false;
         }
-        int[] letters = new int[NUM_ASCII_CHARS];
-        for (int i = 0; i < s1.length(); i++) {
-            char ch = s1.charAt(i);
-            letters[ch]++;
+        HashMap<Character, Integer> map = new HashMap<>(NUM_ASCII_CHARS);
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            map.merge(ch, 1, Integer::sum);
         }
-        for (int i = 0; i < s2.length(); i++) {
-            char ch = s2.charAt(i);
-            if (--letters[ch] < 0) {
+        for (int i = 0; i < t.length(); i++) {
+            char ch = t.charAt(i);
+            if (!map.containsKey(ch) || map.get(ch) == 0) {
                 return false;
             }
+            map.merge(ch, -1, Integer::sum);
         }
         return true;
     }
 }
 
-
 //  Time Complexity: O(n)
 // Space Complexity: O(1)

Chp. 05 - Bit Manipulation/_5_5_Debugger/Debugger

@@ -1 +1,2 @@
-The code is an efficient way to check to see if n is a power of 2
+Assuming n is positive, the code is an efficient way to check to see if n is a power of 2
+

Chp. 08 - Recursion and Dynamic Programming/_8_04_Power_Set/PowerSet.java

@@ -1,20 +1,20 @@
 package _8_04_Power_Set;
 
-import java.util.ArrayList;
+import java.util.*;
 
 public class PowerSet {
-    public static ArrayList<ArrayList<Integer>> getSubsets(ArrayList<Integer> set) {
-        ArrayList<ArrayList<Integer>> powerSet = new ArrayList<>();
+    public static List<List<Integer>> getSubsets(List<Integer> set) {
+        List<List<Integer>> powerSet = new ArrayList<>();
         int max = (int) Math.pow(2, set.size());
         for (int i = 0; i < max; i++) { // this is the main trick
-            ArrayList<Integer> subset = createSubset(set, i);
+            List<Integer> subset = createSubset(set, i);
             powerSet.add(subset);
         }
         return powerSet;
     }
 
-    private static ArrayList<Integer> createSubset(ArrayList<Integer> set, int num) {
-        ArrayList<Integer> subset = new ArrayList<>();
+    private static List<Integer> createSubset(List<Integer> set, int num) {
+        List<Integer> subset = new ArrayList<>();
         int indexInSet = 0;
         while (num != 0) {
             if ((num & 1) == 1) {

Chp. 08 - Recursion and Dynamic Programming/_8_04_Power_Set/Tester.java

@@ -1,11 +1,11 @@
 package _8_04_Power_Set;
 
-import java.util.ArrayList;
+import java.util.*;
 
 public class Tester {
     public static void main(String[] args) {
         System.out.println("*** Test 8.4: Power Set\n");
-        ArrayList<Integer> set = new ArrayList<>();
+        List<Integer> set = new ArrayList<>();
         set.add(3);
         test(set);
         set.add(4);
@@ -14,8 +14,8 @@ public static void main(String[] args) {
         test(set);
     }
 
-    private static void test(ArrayList<Integer> set) {
-        ArrayList<ArrayList<Integer>> subsets = PowerSet.getSubsets(set);
+    private static void test(List<Integer> set) {
+        List<List<Integer>> subsets = PowerSet.getSubsets(set);
         System.out.println("Original set: " + set);
         System.out.println("Subsets: " + subsets + "\n");
     }

Chp. 08 - Recursion and Dynamic Programming/_8_08_Permutations_with_Dups/Tester.java

@@ -1,6 +1,6 @@
 package _8_08_Permutations_with_Dups;
 
-import java.util.ArrayList;
+import java.util.*;
 
 public class Tester {
     public static void main(String[] args) {
@@ -10,7 +10,7 @@ public static void main(String[] args) {
     }
 
     private static void test(String str) {
-        ArrayList<String> permutations = PermutationsWithDups.getPermutations(str);
+        List<String> permutations = PermutationsWithDups.getPermutations(str);
         System.out.println("Original string: " + str);
         System.out.println("Permutations: " + permutations + "\n");
     }

Chp. 10 - Sorting and Searching/_10_09_Sorted_Matrix_Search/SortedMatrixSearch.java

@@ -13,6 +13,9 @@ public class SortedMatrixSearch {
     // - Always either move down (eliminating current row), or move left (eliminating current col)
     // - Alternate solution: start in bottom left and move to top right
     public static boolean findElement(int[][] grid, int elem) {
+        if (grid == null || grid.length == 0 || grid[0].length == 0) {
+            return false;
+        }
         int rows = grid.length;
         int cols = grid[0].length;
 

Common/common/ListFunctions.java

@@ -39,14 +39,11 @@ public static Node deleteNode(Node head, int d) { // "d" is the node we want to
 
     /* Returns size of linked list */
     public static int calculateSize(Node head) {
-        if (head == null) {
-            return 0;
-        }
-        int size = 1;
         Node n = head;
-        while (n.next != null) {
-            n = n.next;
+        int size = 0;
+        while (n != null) {
             size++;
+            n = n.next;
         }
         return size;
     }