Refactored solutions

Author: RodneyShag

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

@@ -1,21 +1,20 @@
 package _1_2_Check_Permutations;
 
+// Should ask interviewer if String is ASCII or Unicode (We assume ASCII)
+
 // 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.
 
-//  Time Complexity: O(n)
-// Space Complexity: O(1)
 
 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()) {
             return false;
         }
-        int[] letters = new int[256]; // we assume it's an ASCII string. Should
-                                      // ask interviewer if String is ASCII or
-                                      // Unicode
+        int[] letters = new int[NUM_ASCII_CHARS];
         for (int i = 0; i < s1.length(); i++) {
             char ch = s1.charAt(i);
             letters[ch]++;
@@ -29,3 +28,7 @@ public static boolean isPermutation(String s1, String s2) {
         return true;
     }
 }
+
+
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 02 - Linked Lists/_2_2_Return_Kth_to_Last/ReturnKthToLast.java

@@ -3,10 +3,7 @@
 import common.Node;
 import common.ListFunctions;
 
-// Algorithm: Just calculate the size of SLL, then walk "size - k" elements into list
-
-//  Time Complexity: O(n)
-// Space Complexity: O(1)
+// Algorithm: Just calculate the size of the SLL, then walk "size - k" elements into list
 
 public class ReturnKthToLast {
     public static Node kthLast(Node n, int k) {
@@ -20,3 +17,6 @@ public static Node kthLast(Node n, int k) {
         return n;
     }
 }
+
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 02 - Linked Lists/_2_3_Delete_Middle_Node/DeleteMiddleNode.java

@@ -2,8 +2,6 @@
 
 import common.Node;
 
-// Time Complexity: O(1) - Simply move the data
-
 public class DeleteMiddleNode {
     public static boolean deleteMid(Node n) {
         if (n == null || n.next == null) { // this algorithm only works if we are deleting an element that's not the last element.
@@ -14,3 +12,5 @@ public static boolean deleteMid(Node n) {
         return true;
     }
 }
+
+// Time Complexity: O(1) - simply move the data

Chp. 02 - Linked Lists/_2_5_Sum_Lists/SumLists.java

@@ -3,9 +3,6 @@
 import common.Node;
 import common.ListFunctions;
 
-//  Time Complexity: O(n + m)
-// Space Complexity: O(n + m)
-
 public class SumLists {
     /* Reverse Order: Iterative solution */
     public static Node addReverseOrder(Node n, Node m) {
@@ -88,3 +85,8 @@ private static Pair addForwardOrderHelper(Node n, Node m) {
         return new Pair(head, carry);
     }
 }
+
+// Time/Space Complexity for both solutions
+//
+//  Time Complexity: O(n + m)
+// Space Complexity: O(n + m)

Chp. 03 - Stacks and Queues/_3_1_Three_in_One/ThreeInOne.java

@@ -55,12 +55,8 @@ public void print() {
         }
     }
 
-    // If we want variable stack sizes, these 3 things (from book's complicated
-    // code) are relevant
-    // 1) If, for example, stack 1 gets too big, they shift stack 2 over (by
-    // copying over elements 1 by 1 starting from the end of the stack)
-    // 2) The array is allowed to wrap around on itself (so will need to use %
-    // operator)
-    // 3) They made a new class called "StackData" to keep track of a bunch of
-    // information about each stack instead of just "head"
+    // If we want variable stack sizes, these 3 things (from book's complicated code) are relevant
+    // 1) If, for example, stack 1 gets too big, they shift stack 2 over (by copying over elements 1 by 1 starting from the end of the stack)
+    // 2) The array is allowed to wrap around on itself (so will need to use % operator)
+    // 3) They made a new class called "StackData" to keep track of a bunch of information about each stack instead of just "head"
 }

Chp. 04 - Trees and Graphs/_4_10_Check_Subtree/CheckSubtree.java

@@ -4,25 +4,25 @@
 
 // Tests if one tree is subtree of another
 //
-// Solutions               Runtime                   Preference
+// Solution               Runtime                   Preference
 // ------------------------------------------------------------------
 // 1) Preorder Traversal   See analysis at bottom    Worth mentioning
 // 2) Recursive search     See analysis at bottom    Favorite
 
 public class CheckSubtree {
     /* Solution 1
-     * - Book says if T1's preorder traversal is substring of T2's preorder traversal, and same 
-     *   is true for inorder traversals, then T2 is substring of T1
-     * - During implementation, we can  insert dummy "0" for nulls. This is necessary 
+     * - Book says if T1's preorder traversal is substring of T2's preorder traversal, 
+     *   and same is true for inorder traversals, then T2 is substring of T1
+     * - During implementation, we can insert dummy "0" for nulls. This is necessary 
      *   to distinguish the 2 trees in book with duplicate values.
      */
 
     /**************/
     /* Solution 2 */
     /**************/
     public static boolean containsTree(TreeNode t1, TreeNode t2) {
-        if (t2 == null) { // the empty tree is always a subtree. We do this check here to avoid doing it
-                          // every time in subTree
+        if (t2 == null) { // the empty tree is always a subtree. We do this 
+                          // check here to avoid doing it every time in subTree.
             return true;
         }
         return subTree(t1, t2);
@@ -62,8 +62,8 @@ public static boolean matchTree(TreeNode p, TreeNode q) {
 //
 // ---------- Solution 2
 // Time Complexity: 
-// - O(nm) worst case, but average case is much better since matchTree() usually returns false immediately, 
-// so it's O(n + km) where k is number of occurrences of T2's root in T1
+// - O(nm) worst case, but average case is much better since matchTree() usually returns 
+//   false immediately, so it's O(n + km) where k is number of occurrences of T2's root in T1
 // - Also, even when we do call matchTree, it is likely to not match very soon in its search
 //
 // Space Complexity: O(log(n) + log(m)). Which is great.

Chp. 05 - Bit Manipulation/_5_3_Flip_Bit_to_Win/FlipBitToWin.java

@@ -1,8 +1,5 @@
 package _5_3_Flip_Bit_to_Win;
 
-//  Time Complexity: O(b) where b is number of bits in int
-// Space Complexity: O(1)
-
 public class FlipBitToWin {
     public static int flipBit(int n) {
         int numBits = Integer.BYTES * 8;
@@ -34,7 +31,10 @@ public static int flipBit(int n) {
         return maxLength;
     }
 
-    public static boolean getBit(int num, int bit) {
+    private static boolean getBit(int num, int bit) {
         return (num & (1 << bit)) != 0;
     }
 }
+
+//  Time Complexity: O(b) where b is number of bits in int.
+// Space Complexity: O(1)

Chp. 09 - System Design and Scalability/9_4_Duplicate_URLs

@@ -1,11 +1,11 @@
 9.4 - Duplicate URLs
 
-    - Simple Answer: Use HashMap to detect duplicates
-        - 10 billion URLS at 100 characters each at 4 bytes each = 4 terabytes of information. Can't save this all in 1 file.
-        - Create 4000 1GB files called <x>.txt where <x> is hash(url) % 4000. 
-            - (Although mostly uniformly distributed, some files may be bigger or smaller
-               than 1GB since it's very unlikely we can create a perfect hash function)
-        - Now all URLs with same hash value are in same file
-             - (this ensures that 2 of the same key are not in different files, so our next step will successfully remove all duplicates)
-        - Do a 2nd pass (through each of the 4000 files) and create a HashMap<URL, Boolean> to detect duplicates
-            - This 2nd pass can be done in parallel on 4000 Machines (Pro: Faster, Con: if 1 machine crashes it affects our final result)
+- Simple Answer: Use HashMap to detect duplicates
+    - 10 billion URLS at 100 characters each at 4 bytes each = 4 terabytes of information. Can't save this all in 1 file.
+    - Create 4000 1GB files called <x>.txt where <x> is hash(url) % 4000. 
+        - (Although mostly uniformly distributed, some files may be bigger or smaller
+           than 1GB since it's very unlikely we can create a perfect hash function)
+    - Now all URLs with same hash value are in same file
+         - (this ensures that 2 of the same key are not in different files, so our next step will successfully remove all duplicates)
+    - Do a 2nd pass (through each of the 4000 files) and create a HashMap<URL, Boolean> to detect duplicates
+        - This 2nd pass can be done in parallel on 4000 Machines (Pro: Faster, Con: if 1 machine crashes it affects our final result)

Chp. 09 - System Design and Scalability/9_5_Cache

@@ -1,14 +1,14 @@
 9.5 - Cache
 
-    - We basically design an LRU cache
-    - Main idea: Use linked list to keep track of popular pages. Use a HashMap<String, Node> (in parallel w/ the LinkedList) 
-                 for fast access to LinkedList nodes (key = the url string, value = node in LinkedList) 
-    - "A linked list would allow easy purging of old data, by moving "fresh" items to the front. We could implement it to remove the 
-       last element of the linked list when the list exceeds a certain size."
-    - Options for storing the cache
-        0) Each machine has it's own cache of just it's searches (lame)
-        1) Each machine has it's own cache of ALL machine's searches 
-              - Pro: Efficient Lookup
-              - Con: takes up a ton of memory. Updating cache means updating it on every machine)
-        2) Cache is shared across machines (by hashing keys, which are queries)
-        3) Rodney method: Each machine has most popular searches cached. Less popular searches are shared among machines
+- We basically design an LRU cache
+- Main idea: Use linked list to keep track of popular pages. Use a HashMap<String, Node> (in parallel w/ the LinkedList) 
+             for fast access to LinkedList nodes (key = the url string, value = node in LinkedList) 
+- "A linked list would allow easy purging of old data, by moving "fresh" items to the front. We could implement it to remove the 
+   last element of the linked list when the list exceeds a certain size."
+- Options for storing the cache
+    0) Each machine has it's own cache of just it's searches (lame)
+    1) Each machine has it's own cache of ALL machine's searches 
+          - Pro: Efficient Lookup
+          - Con: takes up a ton of memory. Updating cache means updating it on every machine)
+    2) Cache is shared across machines (by hashing keys, which are queries)
+    3) Rodney method: Each machine has most popular searches cached. Less popular searches are shared among machines

Chp. 09 - System Design and Scalability/_Intro_4_ways_to_divide_data

@@ -0,0 +1,5 @@
+4 ways to divide data (Read book's explanation for great tips)
+    - by order of appearance (Benefit: won't ever need more machines than necessary)
+    - by hashing it mod number of machines (Benefit: Every machine knows exactly where data is)
+    - by using what the actual values represent. Can group similar things together, like all people in Mexico.
+    - arbitrarily (Benefit: better load balancing)

Chp. 09 - System Design and Scalability/_Intro_Find_words_in_millions_of_documents

@@ -0,0 +1,2 @@
+- preprocess the data with a HashMap<String, ArrayList<Document>>
+- Somehow divide the HashMap across machines. Can do it alphabetically by keywords.

Chp. 09 - System Design and Scalability/_Intro_Notes

@@ -2,6 +2,7 @@
 
 // Same concept as "merge" from MergeSort.
 // Additional Trick: copy to end of array since that's where our empty buffer is.
+
 public class SortedMerge {
     public static void merge(int[] a, int[] b, int lastA, int lastB) { // lastA is index of last element in array. Same with lastB
         int curr = lastA + lastB + 1;

Chp. 10 - Sorting and Searching/_10_01_Sorted_Merge/SortedMerge.java

@@ -1 +1,16 @@
-Read book's short answer.
+From "Cracking the Coding Interview" book solutions:
+
+Processes and threads are related to each other but are fundamentally different.
+
+A process can be thought of as an instance of a program in execution. A process is an independent entity to
+which system resources (e.g., CPU time and memory) are allocated. Each process is executed in a separate
+address space, and one process cannot access the variables and data structures of another process. If a
+process wishes to access another process' resources, inter-process communications have to be used. These
+include pipes, files, sockets, and other forms.
+
+A thread exists within a process and shares the process' resources (including its heap space). Multiple
+threads within the same process will share the same heap space. This is very different from processes, which
+cannot directly access the memory of another process. Each thread still has its own registers and its own
+stack, but other threads can read and write the heap memory.
+A thread is a particular execution path of a process. When one thread modifies a process resource, the
+change is immediately visible to sibling threads.

Chp. 15 - Threads and Locks/_15_1_Thread_vs_Process/ThreadVsProcess

@@ -1,3 +1,3 @@
 Implement a directed graph and use DFS/BFS to detect a cycle. 
 
-A deadlock can occur if and only if we find a cycle.
+A deadlock can occur if and only if we find a cycle.

Chp. 15 - Threads and Locks/_15_4_Deadlock_Free_Class/DeadlockFreeClass

@@ -0,0 +1,21 @@
+From "Cracking the Coding Interview" book solutions:
+
+By applying the word synchronized to a method, we ensure that two threads cannot execute
+synchronized methods on the same object instance at the same time.
+
+So, the answer to the first part really depends. If the two threads have the same instance of the object, then
+no, they cannot simultaneously execute method A. However, if they have different instances of the object,
+then they can.
+
+Conceptually, you can see this by considering locks. A synchronized method applies a "lock" on all 
+synchronized methods in that instance of the object. This blocks other threads from executing synchronized
+methods within that instance.
+
+In the second part, we're asked if threadl can execute synchronized method A while thread2 is
+executing non-synchronized method B. Since B is not synchronized, there is nothing to block threadl
+from executing A while thread2 is executing B. This is true regardless of whether threadl and thread2
+have the same instance of the object.
+
+Ultimately, the key concept to remember is that only one synchronized method can be in execution per
+instance of that object. Other threads can execute non-synchronized methods on that instance, or they can
+execute any method on a different instance of the object.

Chp. 15 - Threads and Locks/_15_6_Synchronized_Methods/SynchronizedMethods

@@ -3,7 +3,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 
-// Good question to ask. Given {1,5,1,5}, what does our interview want our output be?
+// Good question to ask. Given { 1, 5, 1, 5 }, what do you want our output be?
 // 1) {1,5}
 // 2) {1,5}, {5,1}
 // 3) {1,5}, {1,5}, {5,1}, {5,1}

Chp. 15 - Threads and Locks/_15_6_Synchronized_Methods/ThreadVsProcess

@@ -3,7 +3,7 @@
 import java.util.LinkedList;
 import java.util.HashMap;
 
-// Rodney: I have to redo this problem to decrease runtime from O(n) to O(1) (like I did in an interview - code is saved)
+// I have to redo this problem to decrease runtime from O(n) to O(1) (like I did in an interview - code is saved)
 
 // To read: http://www.geeksforgeeks.org/implement-lru-cache/
 

Chp. 16 - More Problems (Moderate)/_16_24_Pairs_with_Sum/PairsWithSum.java

@@ -35,7 +35,7 @@ public static int add(int a, int b) {
     public static int add_version2(int a, int b) {
         int anded = a & b;
         int xored = a ^ b;
-        int ored = a | b;
+        int  ored = a | b;
 
         int result = 0;
         boolean carry = false;

Chp. 16 - More Problems (Moderate)/_16_25_LRU_Cache/LRUCache.java

@@ -6,9 +6,9 @@
     an array of size n?
 
     We can first pull a random set of size m from the first n - 1 elements. Then, we just need
-    to decide if array [n] should be inserted into our subset (which would require pulling
+    to decide if array[n] should be inserted into our subset (which would require pulling
     out a random element from it). An easy way to do this is to pick a random number k
-    from 0 through n. If k < m, then insert array [n] into subset [k].This will both "fairly"
+    from 0 through n. If k < m, then insert array[n] into subset [k].This will both "fairly"
     (i.e., with proportional probability) insert array[n] into the subset and "fairly"remove
     a random element from the subset.
 

Chp. 17 - More Problems (Hard)/_17_01_Add_Without_Plus/AddWithoutPlus.java

@@ -4,11 +4,9 @@
 import java.util.HashMap;
 
 // Algorithm:
-//  - Count the "running" differences (between letters and numbers) at each spot in array. Save in int[]
-//  - If 2 indices in our int[] have the same difference, that means there's an equal subarray between them
-//  - To find the max subarray, we find the largest distance between 2 indices with equal differences
-
-// Time Complexity: O(n)
+//  1. Count the "running" differences (between letters and numbers) at each spot in array. Save in int[]
+//  2. If 2 indices in our int[] have the same difference, that means there's an equal subarray between them
+//  3. To find the max subarray, we find the largest distance between 2 indices with equal differences
 
 public class LettersAndNumbers {
     public static char[] maxSubarray(char[] array) {
@@ -51,3 +49,5 @@ private static Pair findLongestMatch(int[] deltas) {
         return maxPair;
     }
 }
+
+// Time Complexity: O(n)

Chp. 17 - More Problems (Hard)/_17_03_Random_Set/RandomSet.java

@@ -17,5 +17,5 @@ Solution 1:
 Solution 2 (preferred):
 
 - Represent this as a Graph. Names are Nodes. Pairs of names are Edges.
-- Generating the desired output is simply doing a BFS/DFS on each connected
+- Generating the desired output is simply doing a BFS or DFS on each connected
   component, while summing the values at each node.

Chp. 17 - More Problems (Hard)/_17_05_Letters_and_Numbers/LettersAndNumbers.java

@@ -2,9 +2,6 @@
 
 import java.util.ArrayDeque;
 
-//  Time Complexity: O(n)
-// Space Complexity: O(n)
-
 public class KthMultiple {
     public static int getKthMagicNumber(int k) { // assuming "k" counts from 1...
         if (k < 1) {
@@ -42,3 +39,6 @@ public static int getKthMagicNumber(int k) { // assuming "k" counts from 1...
         return val;
     }
 }
+
+//  Time Complexity: O(n)
+// Space Complexity: O(n)

Chp. 17 - More Problems (Hard)/_17_07_Baby_Names/BabyNames

@@ -25,7 +25,7 @@ private static Integer getCandidate(int[] array) {
     }
 
     private static boolean isMajorityValid(int[] array, int majority) {
-        long count = Arrays.stream(array).filter(a -> (a == majority)).count(); // here for practice
+        long count = Arrays.stream(array).filter(a -> (a == majority)).count();
         return count * 2 > array.length;
     }
 }