feat(book/sorting): add questions and solutions

Author: amejiarosario

book/D-interview-questions-solutions.asc

@@ -843,6 +843,101 @@ This algorithm only works with DFS.
 
 //
 
+:leveloffset: +1
+
+=== Solutions for Sorting Questions
+(((Interview Questions Solutions, sorting)))
+
+:leveloffset: -1
+
+
+[#sorting-q-merge-intervals]
+include::content/part04/sorting-algorithms.asc[tag=sorting-q-merge-intervals]
+
+The first thing we need to understand is all the different possibilities for overlaps:
+
+// image::merge-intervals-cases.png[merge intervals cases] // blurry
+// image::intervals-overlap-cases.jpg[merge intervals cases] // too big
+// image::intervals-overlap-cases.svg[merge intervals cases] // errors
 
+// my own image
+image::intervals-overlap-cases-owned.png[merge intervals cases]
 
+One way to solve this problem, is sorting by start time. That will eliminate half of the cases!
 
+Since A will always start before B, only 3 cases apply:
+- No overlap: `[[1, 3], [4, 6]]`.
+- Overlap at the end: `[[1, 3], [2, 4]]`.
+- Eclipse: `[[1, 9], [3, 7]]`.
+
+*Algorithm*:
+
+* Sort intervals by start time
+* If the `curr`ent interval's start time is _equal_ or less than the `last` interval's end time, then we have an overlap.
+** Overlaps has two cases: 1) `curr`'s end is larger 2) `last`'s end is larger. For both cases `Math.max` works.
+* If there's no overlap, we add the interval to the solution.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/merge-intervals.js[tags=description;solution]
+----
+
+For the first interval, it will be added straight to the solution array. For all others, we will do the comparison.
+
+*Complexity Analysis*:
+
+- Time: `O(n log n)`. Standard libraries has a sorting time of `O(n log n)`, then we visit each interval in `O(n)`.
+- Space: `O(n)`. In the worst-case is when there's no overlapping intervals. The size of the solution array would be `n`.
+
+
+
+
+
+
+
+//
+
+[#sorting-q-sort-colors]
+include::content/part04/sorting-algorithms.asc[tag=sorting-q-sort-colors]
+
+We are asked to sort an array with 3 possible values. If we use the standard sorting method `Array.sort`, that will be `O(n log n)`. However, we are asked to solve in linear time and constant space complexity.
+
+The concept on quicksort can help here. We can choose 1 as a pivot and move everything less than 1 to the left and everything bigger than 1 to the right.
+
+*Algorithm*:
+
+* Initialize 3 pointers: `left = 0`, `right = len - 1` and `current = 0`.
+* While the `current` pointer is less than `right`
+** If `current` element is less than pivot 1, swap it to the left and increase the `left` and `current` pointer.
+*** We can safely increase the current pointer
+** If `current` element is bigger than pivot 1, swap it to the right and decrease `right` pointer.
+*** Here, we don't increase the `current` pointer because the number that we swapped with could be another 2 and we might need to keep swapping while decreasing `right`.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/sort-colors.js[tags=description;solution]
+----
+
+We are using the destructive assigment to swap the elements. Here's another version a little bit more compact.
+
+[source, javascript]
+----
+include::interview-questions/sort-colors.js[tags=compact]
+----
+
+*Complexity Analysis*:
+
+- Time: `O(n)`. We only visit each number once.
+- Space: `O(1)`. Operations are in-place. Only O(1) space variables were used.
+
+
+
+
+
+
+
+//

book/content/part04/sorting-algorithms.asc

@@ -139,3 +139,78 @@ We explored many algorithms some of them simple and other more performant. Also,
 // | Tim sort       | O(n log n) | O(log n)    | Yes    | No       | No     | Yes
 |===
 // end::table[]
+
+
+
+
+
+
+
+
+
+==== Practice Questions
+(((Interview Questions, sorting)))
+
+
+
+
+
+// tag::sorting-q-merge-intervals[]
+===== Merge Intervals
+
+*so-1*) _Given an array of intervals `[start, end]`, merge all overlapping intervals._
+
+// end::sorting-q-merge-intervals[]
+
+// _Seen in interviews at: X._
+
+*Starter code*:
+
+[source, javascript]
+----
+include::../../interview-questions/merge-intervals.js[tags=description;placeholder]
+----
+
+*Examples*:
+
+[source, javascript]
+----
+merge([[0, 2], [2, 4]]); // [[0, 4]] (0-2 overlaps with 2-4)
+merge([[2, 2], [3, 4]]); // [[2, 2], [3, 4]] (no overlap)
+merge([[1, 10], [3, 4]]); // [[1, 10]] (1-10 covers the other)
+----
+
+
+_Solution: <>_
+
+
+
+
+
+
+// tag::sorting-q-sort-colors[]
+===== Sort Colors (The Dutch flag problem)
+
+*so-2*) _Given an array with 3 possible values (0, 1, 2), sort them in linear time and in-place. Hint: similar to quicksort, where the pivot is 1._
+
+// end::sorting-q-sort-colors[]
+
+// _Seen in interviews at: Amazon, Microsoft, Facebook._
+
+*Starter code*:
+
+[source, javascript]
+----
+include::../../interview-questions/sort-colors.js[tags=description;placeholder]
+----
+
+*Examples*:
+
+[source, javascript]
+----
+sortColors([0, 2, 1]); // [0, 1, 2]
+sortColors([2, 0, 2, 1, 0, 1, 0]); // [0, 0, 0, 1, 1, 2, 2]
+sortColors([1, 1, 1]); // [1, 1, 1]
+----
+
+_Solution: <>_

book/images/course-schedule-examples.png

@@ -0,0 +1,32 @@
+// const {  } = require('../../src/index');
+
+// tag::description[]
+/**
+ * Merge overlapping intervals.
+ * @param {[numer, number][]} intervals - Array with pairs [start, end]
+ * @returns {[numer, number][]} - Array of merged pairs [start, end]
+ */
+function merge(intervals) {
+  // end::description[]
+  // tag::placeholder[]
+  // write your code here...
+  // end::placeholder[]
+  // tag::solution[]
+  const ans = [];
+
+  intervals.sort((a, b) => a[0] - b[0]); // sort by start time
+
+  for (let i = 0; i < intervals.length; i++) {
+    const last = ans[ans.length - 1];
+    const curr = intervals[i];
+    if (last && last[1] >= curr[0]) { // check for overlaps
+      last[1] = Math.max(last[1], curr[1]);
+    } else ans.push(curr);
+  }
+  return ans;
+  // end::solution[]
+  // tag::description[]
+}
+// end::description[]
+
+module.exports = { merge };