Merge pull request amejiarosario#91 from amejiarosario/feat/hashmap

feat(book/hashmap): add code examples and patterns

Author: amejiarosario

book/D-interview-questions-solutions.asc

@@ -437,7 +437,8 @@ The complexity of any of the BFS methods or DFS is similar.
 :leveloffset: -1
 
 [#hashmap-q-two-sum]
-include::content/part03/hashmap.asc[tag=hashmap-q-two-sum]
+include::content/part02/hash-map.asc[tag=hashmap-q-two-sum]
+// include::content/part03/hashmap.asc[tag=hashmap-q-two-sum]
 
 This simple problem can have many solutions; let's explore some.
 
@@ -480,7 +481,8 @@ include::interview-questions/two-sum.js[tags=description;solution]
 
 
 [#hashmap-q-subarray-sum-equals-k]
-include::content/part03/hashmap.asc[tag=hashmap-q-subarray-sum-equals-k]
+include::content/part02/hash-map.asc[tag=hashmap-q-subarray-sum-equals-k]
+// include::content/part03/hashmap.asc[tag=hashmap-q-subarray-sum-equals-k]
 
 This problem has multiple ways to solve it. Let's explore some.
 

book/content/part02/array.asc

@@ -3,10 +3,11 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
+(((Array))) (((Data Structures, Linear, Array)))
 [[array]]
-=== Array [[array-chap]]
-(((Array)))
-(((Data Structures, Linear, Array)))
+[[array-chap]]
+=== Array
+
 Arrays are one of the most used data structures. You probably have used it a lot already. But, are you aware of the runtimes of `push`, `splice`, `shift`, `indexOf`, and other operations? In this chapter, we are going deeper into the most common operations and their runtimes.
 
 ==== Array  Basics
@@ -300,9 +301,7 @@ To sum up, the time complexity of an array is:
 
 Many programming problems involve manipulating arrays. Here are some patterns that can help you improve your problem-solving skills.
 
-(((Patterns, Two Pointers)))
-
-===== Two Pointers Pattern
+===== Two Pointers Pattern (((Patterns, Two Pointers)))
 
 Usually, we use one pointer to navigate each element in an array. However, there are times when having two pointers (left/right, low/high) comes in handy. Let's do some examples.
 
@@ -371,9 +370,7 @@ These two pointers have a runtime of `O(n)`.
 
 WARNING: This technique only works for sorted arrays. If the array was not sorted, you would have to sort it first or choose another approach.
 
-(((Patterns, Sliding Window Pointers)))
-
-===== Sliding Window Pattern
+===== Sliding Window Pattern (((Patterns, Sliding Window))) [[sliding-window-array]]
 
 The sliding window pattern is similar to the two pointers. The difference is that the distance between the left and right pointer is always the same. Also, the numbers don't need to be sorted. Let's do an example!
 

book/content/part02/hash-map.asc

@@ -3,10 +3,9 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
+(((Set))) (((Data Structures, Non-Linear, Set)))
 [[set]]
 === Set
-(((Set)))
-(((Data Structures, Non-Linear, Set)))
 A set is a data structure where duplicated entries are not allowed. A Set is like an array with only unique values.
 
 NOTE: JavaScript already has a built-in Set data structure.

book/content/part03/map.asc

@@ -3,14 +3,20 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
-[[treemap]]
-==== TreeMap
-(((TreeMap)))
-(((Data Structures, Non-Linear, TreeMap)))
-A TreeMap is a Map implementation using Binary Search Trees.
-(((Binary Search Tree)))
-(((BST)))
+(((TreeMap))) (((Data Structures, Non-Linear, TreeMap))) (((Binary Search Tree))) (((BST)))
+[[treemap-chap]]
+=== TreeMap
 
+A Map is an abstract data structure to store pairs of data: *key* and *value*. It also has a fast key lookup of `O(1)` for <<hashmap-chap>> or `O(log n)` for <<treemap-chap>>.
+
+We can implement a Map using two different underlying data structures:
+
+* *HashMap*: it’s a map implementation using an *array* and a *hash function*. The job of the hash function is to convert the `key` into an index that maps to the `value`. Optimized HashMap can have an average runtime of *O(1)*.
+* *TreeMap*: it’s a map implementation that uses a self-balanced Binary Search Tree (like <<c-avl-tree>> or Red-Black Tree). The BST nodes store the key, and the value and nodes are sorted by key guaranteeing an *O(log n)* look up.
+
+We already covered <<hashmap-chap>>, so this chapter we are going to focus on TreeMap.
+
+A TreeMap is a Map implementation using a Balanced Binary Search Trees.
 Implementing a Map with a tree, TreeMap, has a couple of advantages over a HashMap:
 
 * Keys are always sorted.
@@ -36,7 +42,7 @@ class TreeMap {
 }
 ----
 
-===== Inserting values into a TreeMap
+==== Inserting values into a TreeMap
 
 For inserting a value on a TreeMap, we first need to inialize the tree:
 
@@ -58,7 +64,7 @@ include::{codedir}/data-structures/maps/tree-maps/tree-map.js[tag=set, indent=0]
 
 Adding values is very easy (once we have the underlying tree implementation).
 
-===== Getting values out of a TreeMap
+==== Getting values out of a TreeMap
 
 When We search by key in a tree map, it takes *O(log n)*. This is the implementation:
 
@@ -82,7 +88,7 @@ include::{codedir}/data-structures/maps/tree-maps/tree-map.js[tag=iterators, ind
 Generators are useful for producing values that can you can iterate in a `for...of` loop. Generators use the `function*` syntax which expects to have a `yield` with a value.
 ****
 
-===== Deleting values from a TreeMap
+==== Deleting values from a TreeMap
 
 Removing elements from TreeMap is simple.
 
@@ -95,3 +101,36 @@ include::{codedir}/data-structures/maps/tree-maps/tree-map.js[tag=delete, indent
 The BST implementation does all the heavy lifting.
 
 That’s it! To see the full file in context, click here: https://github.com/amejiarosario/dsa.js/blob/f69b744a1bddd3d99243ca64b3ad46f3f2dd7342/src/data-structures/maps/tree-maps/tree-map.js#L22[here]
+
+
+<<<
+==== HashMap vs TreeMap
+
+.A map can be implemented using hash functions or binary search tree:
+- *HashMap*: it’s a map implementation using an *array* and *hash function*. The job of the hash function is to convert the key into an index that contains the matching data. Optimized HashMap can have an average runtime of *O(1)*.
+- *TreeMap*: it’s a map implementation that uses a self-balanced Binary Search Tree (red-black tree). The BST nodes store the key, and the value and nodes are sorted by key guaranteeing an *O(log n)* look up.
+
+
+.When to use a TreeMap vs. HashMap?
+* `HashMap` is more time-efficient. A `TreeMap` is more space-efficient.
+* `TreeMap` search complexity is *O(log n)*, while an optimized `HashMap` is *O(1)* on average.
+* `HashMap`’s keys are in insertion order (or random depending in the implementation). `TreeMap`’s keys are always sorted.
+* `TreeMap` offers some statistical data for free such as: get minimum, get maximum, median, find ranges of keys. `HashMap` doesn’t.
+* `TreeMap` has a guarantee always an *O(log n)*, while `HashMap`s has an amortized time of *O(1)* but in the rare case of a rehash, it would take an *O(n)*.
+
+==== TreeMap Time complexity vs HashMap
+
+As we discussed so far, there is a trade-off between the implementations.
+(((Tables, Non-Linear DS, HashMap/TreeMap complexities))) (((Linear))) (((Runtime, Linear))) (((Logarithmic))) (((Runtime, Logarithmic)))
+
+// also on: book/content/part03/time-complexity-graph-data-structures.asc
+// tag::table[]
+.Time complexity for different Maps implementations
+|===
+.2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
+^|_Index/Key_ ^|_Value_
+| <<hashmap-chap, Hash Map>> ^|O(1) ^|O(n) ^|O(1)* ^|O(1) ^|O(n)
+| <<treemap-chap, Tree Map (Red-Black Tree)>> ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)
+|===
+{empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
+// end::table[]

book/content/part03/set.asc

@@ -3,7 +3,7 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
-[[hashmap]]
+[[hashmap-advanced]]
 ==== HashMap
 (((HashMap)))
 (((HashTable)))
@@ -308,73 +308,3 @@ Hash Map is optimal for searching values by key in constant time *O(1)*. However
 
 indexterm:[Runtime, Linear]
 As you can notice, we have amortized times since it will take O(n) while it resizes in the unfortunate case of a rehash. After that, it will be *O(1)*.
-
-
-==== Practice Questions
-(((Interview Questions, Hash Map)))
-
-
-
-// tag::hashmap-q-two-sum[]
-===== Fit 2 movies in a flight
-
-*HM-1*) _You are working in an entertainment recommendation system for an airline. Given a flight duration (target) and an array of movies length, you need to recommend two movies that fit exactly the length of the flight. Return an array with the indices of the two numbers that add up to the target. No duplicates are allowed. If it's not possible to return empty `[]`._
-
-// end::hashmap-q-two-sum[]
-
-// _Seen in interviews at: Amazon, Google, Apple._
-
-Examples:
-
-[source, javascript]
-----
-twoSum([113, 248, 80, 200, 91, 201, 68], 316); // [1, 6] (248 + 68 = 316)
-twoSum([150, 100, 200], 300); // [2, 3] (100 + 200 = 300)
-twoSum([150, 100, 200], 150); // [] (No two numbers add up to 150)
-----
-
-Starter code:
-
-[source, javascript]
-----
-include::../../interview-questions/two-sum.js[tags=description;placeholder]
-----
-
-
-_Solution: <<hashmap-q-two-sum>>_
-
-
-
-
-
-// tag::hashmap-q-subarray-sum-equals-k[]
-===== Subarray Sum that Equals K
-
-*HM-2*) _Given an array of integers, find all the possible subarrays to add up to k. Return the count._
-
-// end::hashmap-q-subarray-sum-equals-k[]
-
-// _Seen in interviews at: Facebook, Google, Amazon_
-
-Examples:
-
-[source, javascript]
-----
-subarraySum([1], 1); // 1 (1 equals to 1 :)
-subarraySum([1, 1, 1], 1); // 3 ([1], [1], [1] equals 1)
-subarraySum([1, -1, 1], 0); // 2 (sum([1, -1]), sum([-1, 1]) equals 0)
-subaraySum([1, 2, 3, 0, 1, 4, 0, 5], 5) // 8
-// All of these 8 sub arrays add up to 5:
-// [2, 30], [2,3,0], [0,1,4], [0,1,4,0], [1,4], [1,4,0], [0,5], [5]
-----
-
-Starter code:
-
-[source, javascript]
-----
-include::../../interview-questions/subarray-sum-equals-k.js[tags=description;placeholder]
-----
-
-
-_Solution: <<hashmap-q-subarray-sum-equals-k>>_
-

book/content/part03/treemap.asc

@@ -0,0 +1,47 @@
+/**
+ * Given text and banned words,
+ * return the most common words in descending order.
+ * @param {string} text - The text to parse.
+ * @param {number} n - The number of results.
+ * @return {string[]}
+ */
+// tag::map[]
+function mostCommonWords(text, n = 1) {
+  const words = text.toLowerCase().split(/\W+/);
+
+  const map = words
+    .reduce((m, w) => m.set(w, 1 + (m.get(w) || 0)), new Map());
+
+  return Array.from(map.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, n)
+    .map((w) => w[0]);
+}
+// end::map[]
+
+// tag::brute[]
+function mostCommonWordsBrute(text, n = 1) {
+  const words = text.toLowerCase().split(/\W+/);
+  const entries = []; // array of [word, count] pairs
+
+  for (let i = 0; i < words.length; i++) {
+    if (!words[i]) continue;
+    let count = 1;
+    for (let j = i + 1; j < words.length; j++) {
+      if (words[i] === words[j]) {
+        count++;
+        words[j] = null; // removed letter once it's counted.
+      }
+    }
+    entries.push([words[i], count]);
+  }
+
+  return entries
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, n)
+    .map((w) => w[0]);
+}
+// end::brute[]
+
+
+module.exports = { mostCommonWords, mostCommonWordsBrute };

book/content/part03/hashmap.asc renamed to book/deprecated/old-hashmap.asc

@@ -0,0 +1,26 @@
+const { mostCommonWords, mostCommonWordsBrute } = require('./most-common-words-ii');
+
+[mostCommonWordsBrute, mostCommonWords].forEach((fn) => {
+  describe(`Most Common words: ${fn.name}`, () => {
+    it('should work', () => {
+      expect(fn(
+        'The map, maps keys to values; Keys can be anything.',
+        1,
+      )).toEqual(['keys']);
+    });
+
+    it('should work', () => {
+      expect(fn(
+        'Look at it! What is it? It does look like my code from 1 year ago',
+        2,
+      )).toEqual(['it', 'look']);
+    });
+
+    it('should work', () => {
+      expect(fn(
+        'a; a,b, a\'s c a!; b,b, c.',
+        4,
+      )).toEqual(['a', 'b', 'c', 's']);
+    });
+  });
+});

book/images/sliding-window-map.png

@@ -9,6 +9,7 @@ When you are aware of the data structures implementations, you spot when to use
 
 .In this part we are going to learn about the following linear data structures:
 - <<array-chap>>
+- <<hashmap-chap>>
 - <<part02-linear-data-structures#linked-list>>
 - <<part02-linear-data-structures#stack>>
 - <<part02-linear-data-structures#queue>>
@@ -27,6 +28,9 @@ endif::[]
 <<<
 include::content/part02/array.asc[]
 
+<<<
+include::content/part02/hash-map.asc[]
+
 <<<
 include::content/part02/linked-list.asc[]
 

book/interview-questions/most-common-words-ii.js

@@ -21,8 +21,11 @@ include::content/part03/tree-search-traversal.asc[]
 <<<
 include::content/part03/binary-search-tree-traversal.asc[]
 
-<<<
-include::content/part03/map.asc[]
+// <<<
+// include::content/part03/map.asc[]
+
+<<
+include::content/part03/treemap.asc[]
 
 <<<
 include::content/part03/set.asc[]
@@ -35,4 +38,3 @@ include::content/part03/graph-search.asc[]
 
 <<<
 include::content/part03/time-complexity-graph-data-structures.asc[]
-

book/interview-questions/most-common-words-ii.spec.js

@@ -36,4 +36,3 @@ include::content/part04/backtracking.asc[]
 
 <<<
 include::content/part04/algorithmic-toolbox.asc[]
-

book/part02-linear-data-structures.asc

@@ -11,7 +11,7 @@ Adrian Mejia
 :revdate: {docdate}
 :docinfo:
 :toc:
-:toclevels: 2
+:toclevels: 4
 :pagenums:
 :front-cover-image: image:cover.png[width=1050,height=1600]
 :icons: font

book/part03-graph-data-structures.asc

@@ -1,47 +1,45 @@
 /**
  * Least Recently Used (LRU) cache.
- * (ordered) Map: O(1)
- * @param {number} capacity - Number of items to hold.
+ * Key/Value storage with fixed max number of items.
+ * Least recently used items are discarded once the limit is reached.
+ * Reading and updating the values mark the items as recently used.
+ * @author Adrian Mejia <adrianmejia.com>
  */
-class LRUCache {
+class LRUCache extends Map {
+  /**
+   * @param {number} capacity - The max number of items on the cache
+   */
   constructor(capacity) {
-    this.map = new Map();
+    super();
     this.capacity = capacity;
   }
 
+  /**
+   * Get value associated with the key. Mark keys as recently used.
+   * @param {number} key
+   * @returns {number} value or if not found -1
+   */
   get(key) {
-    const value = this.map.get(key);
-    if (value) {
-      this.moveToTop(key);
-      return value;
-    }
-    return -1;
+    if (!super.has(key)) return -1;
+    const value = super.get(key);
+    this.put(key, value); // re-insert at the top (most recent).
+    return value;
   }
 
+  /**
+   * Upsert key/value pair. Updates mark keys are recently used.
+   * @param {number} key
+   * @param {number} value
+   * @returns {void}
+   */
   put(key, value) {
-    this.map.set(key, value);
-    this.rotate(key);
-  }
-
-  rotate(key) {
-    this.moveToTop(key);
-    while (this.map.size > this.capacity) {
-      const it = this.map.keys(); // keys are in insertion order.
-      this.map.delete(it.next().value);
-    }
-  }
-
-  moveToTop(key) {
-    if (this.map.has(key)) {
-      const value = this.map.get(key);
-      this.map.delete(key);
-      this.map.set(key, value);
+    if (super.has(key)) super.delete(key);
+    super.set(key, value);
+    if (super.size > this.capacity) {
+      const oldestKey = super.keys().next().value;
+      super.delete(oldestKey);
     }
   }
-
-  get size() {
-    return this.map.size;
-  }
 }
 
 module.exports = LRUCache;

book/part04-algorithmic-toolbox.asc

@@ -75,6 +75,18 @@ describe('LRU Cache', () => {
       });
     });
 
+    it('should work with updates', () => {
+      // ["LRUCache","put","put","put","put","get","get"]
+      // [[2],[2,1],[1,1],[2,3],[4,1],[1],[2]]
+      c = new LRUCache(2);
+      c.put(2, 1);
+      c.put(1, 1);
+      c.put(2, 3);
+      c.put(4, 1);
+      c.get(1);
+      c.get(2);
+    });
+
     it('should work with size 10', () => {
       c = new LRUCache(10);