Hotfix/sorting

benchmarks/two-sum-implementations/01-two-sum.js

@@ -0,0 +1,13 @@
+// Brute force: O(n^2) | O(1)
+function twoSum(nums, target) {
+  for (let i = 0; i < nums.length - 1; i++) { // O(n^2)
+    for (let j = i + 1; j < nums.length; j++) { // O(n)
+      if (nums[i] + nums[j] === target) {
+        return [i, j];
+      }
+    }
+  }
+  return [];
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/02-two-sum.js

@@ -0,0 +1,19 @@
+// With a HashMap: O(n) | O(n)
+function twoSum(nums, target) {
+  const map = nums.reduce((m, v, i) => { // O(n)
+    const ids = m.get(v) || [];
+    ids.push(i);
+    return m.set(v, ids);
+  }, new Map());
+
+  for (let i = 0; i < nums.length; i++) { // O(n)
+    const diff = target - nums[i];
+    if (map.has(diff) && i !== map.get(diff)) {
+      return [i, map.get(diff)];
+    }
+  }
+
+  return [];
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/03-two-sum.js

@@ -0,0 +1,18 @@
+// With a HashMap: O(n) | O(n), 1-pass
+function twoSum(nums, target) {
+  const map = new Map();
+
+  for (let i = 0; i < nums.length; i++) { // O(n)
+    const complement = target - nums[i];
+
+    if (map.has(complement)) {
+      return [map.get(complement), i];
+    }
+
+    map.set(nums[i], i);
+  }
+
+  return [];
+}
+
+module.exports = twoSum;

benchmarks/two-sum-implementations/runner.js

@@ -0,0 +1,16 @@
+const assert = require('assert');
+
+const twoSum = require('./01-two-sum');
+
+function test() {
+  assert.deepEqual(twoSum([1, 2, 3], 4), [0, 2]);
+  assert.deepEqual(twoSum([1, 2, 3], 14), []);
+
+  assert.deepEqual(twoSum([2, 2, 2], 4), [0, 1]);
+  assert.deepEqual(twoSum(Array(1e7).fill(2), 4), [0, 1]); //
+  // assert.deepEqual(twoSum(Array(1e8).fill(2), 4), [0, 1]); // FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
+  // assert.deepEqual(twoSum(Array(1e9).fill(2), 4), [0, 1]); // 1e7 - error 137 - OUT OF MEMORY
+  console.log('All tests passed!');
+}
+
+test();

book/content/part04/bubble-sort.asc

@@ -3,6 +3,7 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
+[[bubble-sort]]
 ==== Bubble Sort
 (((Bubble Sort)))
 (((Sorting, Bubble Sort)))

book/content/part04/quick-sort.asc

@@ -83,11 +83,11 @@ With the optimization, Quicksort has an _O(n log n)_ running time. Similar to th
 - <<Online>>: [big]#️❌# No, the pivot element can be choose at random.
 - Recursive: Yes
 - Time Complexity: [big]#✅# <<part01-algorithms-analysis#linearithmic>> _O(n log n)_
-- Space Complexity: [big]#✅# <<part01-algorithms-analysis#constant>> _O(1)_
+- Space Complexity: [big]#✅# <<part01-algorithms-analysis#logarithmic>> _O(log n)_, because of recursion.
 
 (((Linearithmic)))
 (((Runtime, Linearithmic)))
-(((Space complexity, Constant)))
+(((Space complexity, Logarithmic)))
 
 // Resources:
 // https://www.khanacademy.org/computing/computer-science/algorithms/quick-sort/a/linear-time-partitioning

book/content/part04/sorting-algorithms.asc

@@ -9,7 +9,7 @@ Sorting is one of the most common solutions when we want to extract some insight
 We can sort to get the maximum or minimum value and many algorithmic problems involves sorting data first.
 
 .We are going to explore three basic sorting algorithms _O(n^2^)_ which have low overhead:
-- <<part04-algorithmic-toolbox#insertion-sort>>
+- <<part04-algorithmic-toolbox#bubble-sort>>
 - <<part04-algorithmic-toolbox#selection-sort>>
 - <<part04-algorithmic-toolbox#insertion-sort>>
 
@@ -120,7 +120,7 @@ We explored many algorithms some of them simple and other more performant. Also,
 [cols="20,80"]
 |===
 | Algorithms         | Comments
-| <<part04-algorithmic-toolbox#insertion-sort>>    | Swap pairs bubbling up largest numbers to the right
+| <<part04-algorithmic-toolbox#bubble-sort>>    | Swap pairs bubbling up largest numbers to the right
 | <<part04-algorithmic-toolbox#insertion-sort>> | Look for biggest number to the left and swap it with current
 | <<part04-algorithmic-toolbox#selection-sort>> | Iterate array looking for smallest value to the right
 | <<part04-algorithmic-toolbox#merge-sort>>     | Split numbers in pairs, sort pairs and join them in ascending order
@@ -131,12 +131,11 @@ We explored many algorithms some of them simple and other more performant. Also,
 .Sorting algorithms time/space complexity and properties
 |===
 | Algorithms         | Avg        | Best | Worst | Space       | Stable | In-place | Online | Adaptive
-| <<part04-algorithmic-toolbox#insertion-sort>>    | O(n^2^)    | O(n) | O(n^2^) | O(1)      | Yes    | Yes      | Yes    | Yes
+| <<part04-algorithmic-toolbox#bubble-sort>>    | O(n^2^)    | O(n) | O(n^2^) | O(1)      | Yes    | Yes      | Yes    | Yes
 | <<part04-algorithmic-toolbox#insertion-sort>> | O(n^2^)    | O(n) | O(n^2^) | O(1)      | Yes    | Yes      | Yes    | Yes
 | <<part04-algorithmic-toolbox#selection-sort>> | O(n^2^)    | O(n^2^) | O(n^2^) | O(1)        | No     | Yes      | No    | No
 | <<part04-algorithmic-toolbox#merge-sort>>     | O(n log n) | O(n log n) | O(n log n) | O(n)        | Yes     | No       | No     | No
-| <<part04-algorithmic-toolbox#quicksort>>      | O(n log n) | O(n^2^) | O(n log n) | O(log n)    | Yes     | Yes      | No     | No
+| <<part04-algorithmic-toolbox#quicksort>>      | O(n log n) | O(n log n) | O(n^2^) | O(log n) | No     | Yes      | No     | No
 // | Tim sort       | O(n log n) | O(log n)    | Yes    | No       | No     | Yes
 |===
 // end::table[]
-