refactor: js - intervals (neetcode-gh#449)

Author: aakhtar3

javascript/252-Meeting-Rooms.js

@@ -1,14 +1,30 @@
 /**
- * @param {number[]} intervals
+ * https://leetcode.com/problems/meeting-rooms/
+ * Time O(N * logN) | Space O(1)
+ * @param {number[][]} intervals
  * @return {boolean}
  */
-var canAttendMeetings = function (intervals) {
-    intervals.sort((a, b) => a[0] - b[0]);
+ var canAttendMeetings = function(intervals) {
+    intervals.sort(([ aStart, aEnd ], [ bStart, bEnd ]) => aStart !== bStart
+        ? aStart - bStart
+        : aEnd - bEnd
+    );
 
-    for (let i = 0; i < intervals.length - 1; i++) {
-        if (intervals[i][1] > intervals[i + 1][0]) {
-            return false;
-        }
-    }
-    return true;
+    return canAttend(intervals)
 };
+
+const canAttend = (intervals) => {
+    let prev = intervals.shift();
+
+    for (const curr of intervals) {
+        const [ prevStart, prevEnd ] = prev;
+        const [ currStart, currEnd ] = curr;
+
+        const hasOverlap  = currStart < prevEnd;
+        if (hasOverlap) return false;
+
+        prev = curr;
+    }
+
+  return true;
+}

javascript/253-Meeting-Rooms-ii.js

@@ -0,0 +1,39 @@
+/**
+ * https://leetcode.com/problems/meeting-rooms-ii/
+ * Time O((N * logN) + (M * logM)) | Space O(1)
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+ var minMeetingRooms = function(intervals) {
+    const { start, end } = splitIntervals(intervals);
+    let [ minRooms, startIndex, endIndex ] = [ 0, 0, 0 ];
+
+    while (startIndex < intervals.length) {
+        const [ currStart, prevEnd ]  = [ start[startIndex], end[endIndex] ];
+
+        const hasGap = prevEnd <= currStart;
+        if (hasGap) {
+            minRooms--;
+            endIndex++;
+        }
+
+        minRooms++;
+        startIndex++;
+    }
+
+    return minRooms;
+};
+
+const splitIntervals = (intervals, start = [], end = []) => {
+    for (const [ startTime, endTime ] of intervals) {
+        start.push(startTime);
+        end.push(endTime);
+    }
+
+    const comparator = ((a, b) => a - b);
+
+    start.sort(comparator);
+    end.sort(comparator);
+
+    return { start, end };
+};

javascript/435-Non-overlapping-Intervals.js

@@ -1,17 +1,31 @@
-let eraseOverlapIntervals = function (intervals) {
-    intervals = intervals.sort((a, b) => a[0] - b[1]);
+/**
+ * https://leetcode.com/problems/non-overlapping-intervals/
+ * Time O(N * logN) | Space O(1)
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+ var eraseOverlapIntervals = function(intervals) {
+    intervals.sort(([ aStart, aEnd ], [ bStart, bEnd ]) => aEnd !== bEnd
+        ? aEnd - bEnd
+        : aStart - bStart
+    );
 
-    let currentEnd = intervals[0][1];
-    let res = 0;
+    return getGaps(intervals)
+};
+
+const getGaps = (intervals, gaps = 1) => {
+    const prev = intervals.shift();
+
+    for (const curr of intervals) {
+        const [ prevStart, prevEnd ] = prev;
+        const [ currStart, currEnd ] = curr;
 
-    for (let i = 1; i < intervals.length; i++) {
-        if (currentEnd > intervals[i][0]) {
-            res += 1;
-            currentEnd = Math.min(intervals[i][1], currentEnd);
-        } else {
-            currentEnd = intervals[i][1];
-        }
+        const hasGap = prevEnd <= currStart;
+        if (!hasGap) continue;
+
+        prev[1] = curr[1];
+        gaps++;
     }
 
-    return res;
-};
+    return (intervals.length + 1) - gaps;
+}

javascript/56-Merge-Intervals.js

@@ -1,16 +1,34 @@
-var merge = function (intervals) {
-    intervals.sort((a, b) => a[0] - b[0]);
+/**
+ * https://leetcode.com/problems/merge-intervals/
+ * Time O(N * logN) | Space O(N)
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+ var merge = function(intervals) {
+    intervals.sort(([ aStart, aEnd ], [ bStart, bEnd ]) => aStart !== bStart
+        ? aStart - bStart
+        : aEnd - bEnd
+    );
 
-    let res = [intervals[0]];
+    return mergerInterval(intervals)
+};
+
+const mergerInterval = (intervals, merged = []) => {
+    let prev = intervals.shift();
 
-    for (let i = 1; i < intervals.length; i++) {
-        let prev = res[res.length - 1];
+    for (const curr of intervals) {
+        const [ prevStart, prevEnd ] = prev;
+        const [ currStart, currEnd ] = curr;
 
-        if (prev[1] >= intervals[i][0]) {
-            prev[1] = Math.max(prev[1], intervals[i][1]);
-        } else {
-            res.push(intervals[i]);
+        const hasOverlap = currStart <= prevEnd;
+        if (hasOverlap) {
+            prev[1] = Math.max(prev[1], curr[1]);
+            continue;
         }
+
+        merged.push(prev);
+        prev = curr;
     }
-    return res;
-};
+
+    return [ ...merged, prev ];
+}

javascript/57-Insert-Interval.js

@@ -1,26 +1,43 @@
-let insert = function (intervals, newInterval) {
-    let res = [];
-    let isAdded = false;
-
-    intervals.forEach((int) => {
-        if (int[0] > newInterval[1]) {
-            if (!isAdded) {
-                res.push(newInterval);
-                isAdded = true;
-            }
-
-            res.push(int);
-        } else if (int[1] < newInterval[0]) {
-            res.push(int);
-        } else {
-            newInterval[0] = Math.min(newInterval[0], int[0]);
-            newInterval[1] = Math.max(newInterval[1], int[1]);
-        }
-    });
-
-    if (!isAdded) {
-        res.push(newInterval);
-    }
+/**
+ * https://leetcode.com/problems/insert-interval/
+ * Time O(N) | Space O(N)
+ * @param {number[][]} intervals
+ * @param {number[]} newInterval
+ * @return {number[][]}
+ */
+ var insert = function(intervals, newInterval) {
+    const { beforeIndex, before } = getBefore(intervals, newInterval);
+    const afterIndex = mergeIntervals(intervals, newInterval, beforeIndex);
+    const after = intervals.slice(afterIndex);
 
-    return res;
+    return [ ...before, newInterval, ...after ];
 };
+
+const getBefore = (intervals, newInterval, index = 0, before = []) => {
+    const hasGap = ([ prevStart, prevEnd ], [ currStart, currEnd ]) =>
+        prevEnd < currStart;
+
+    while (index < intervals.length && hasGap(intervals[index], newInterval)) {
+        const current = intervals[index];
+        
+        before.push(current);
+        index++;
+    }
+
+    return { beforeIndex: index, before };
+}
+
+const mergeIntervals = (intervals, newInterval, index) => {
+    const hasOverlap = ([ prevStart, prevEnd ], [ currStart, currEnd ]) =>
+        currStart <= prevEnd;
+
+    while (index < intervals.length && hasOverlap(newInterval, intervals[index])) {
+        const current = intervals[index];
+
+        newInterval[0] = Math.min(newInterval[0], current[0]);
+        newInterval[1] = Math.max(newInterval[1], current[1]);
+        index++;
+    }
+
+    return index;
+}