refactor: js | linkedlist (#770)

Author: aakhtar3

javascript/138-Copy-List-with-Random-Pointer.js

@@ -1,20 +1,65 @@
 /**
+ * https://leetcode.com/problems/copy-list-with-random-pointer/
+ * Time O(N) | Space O(N)
  * @param {Node} head
  * @return {Node}
  */
-var copyRandomList = function (head) {
-    let map = new Map();
-    let ptr = head;
-
-    while (ptr) {
-        // map old - new
-        map.set(ptr, new Node(ptr.val, null, null));
-        ptr = ptr.next;
+var copyRandomList = function(head, map = new Map()) {
+    if (!head) return null;
+    if (map.has(head)) return map.get(head);
+
+    const clone = new Node(head.val);
+
+    map.set(head, clone);                           /*           | Space O(N) */
+    clone.next = copyRandomList(head.next, map);    /* Time O(N) | Space O(N) */
+    clone.random = copyRandomList(head.random, map);/* Time O(N) | Space O(N) */
+
+    return clone;
+}
+
+/**
+ * https://leetcode.com/problems/copy-list-with-random-pointer/
+ * Time O(N) | Space O(1)
+ * @param {Node} head
+ * @return {Node}
+ */
+var copyRandomList = function(head) {
+    if (!head) return null;
+
+    cloneNode(head);         /* Time O(N) */
+    connectRandomNode(head); /* Time O(N) */
+
+    return connectNode(head);/* Time O(N) */
+};
+
+const cloneNode = (curr) => {
+    while (curr) {          /* Time O(N) */
+        const node = new Node(curr.val);
+
+        node.next = curr.next;
+        curr.next = node;
+        curr = node.next;
     }
 
-    for (const [oldptr, newptr] of map) {
-        newptr.next = oldptr.next && map.get(oldptr.next);
-        newptr.random = oldptr.random && map.get(oldptr.random);
+    return curr;
+}
+
+const connectRandomNode = (curr) => {
+    while (curr) {         /* Time O(N) */
+        curr.next.random = curr.random?.next || null;
+        curr = curr.next.next;
     }
-    return map.get(head);
-};
+}
+
+const connectNode = (head) => {
+    let [ prev, curr, next ] = [ head, head.next, head.next ];
+
+    while (prev) {        /* Time O(N) */
+        prev.next = prev.next.next;
+        curr.next = curr?.next?.next || null;
+        prev = prev.next;
+        curr = curr.next;
+    }
+
+    return next
+}

javascript/141-Linked-List-Cycle.js

@@ -1,25 +1,36 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
- * }
+ * https://leetcode.com/problems/linked-list-cycle/
+ * Time O(N) | Space O(N)
+ * @param {ListNode} head
+ * @return {boolean}
  */
+var hasCycle = function(head, seen = new Set()) {
+    while (head) {/* Time O(N) */
+        if (seen.has(head)) return true;
+
+        seen.add(head);/* Space O(N) */
+        head = head.next;
+    }
+
+    return false;
+}
 
 /**
+ * https://leetcode.com/problems/linked-list-cycle/
+ * Time O(N) | Space O(1)
  * @param {ListNode} head
  * @return {boolean}
  */
-var hasCycle = function (head) {
-    let set = new Set();
-    while (head) {
-        if (set.has(head)) {
-            return true;
-        } else {
-            set.add(head);
-            head = head.next;
-        }
+var hasCycle = function(head) {
+    let [ slow, fast ] = [ head, head];
+
+    while (fast && fast.next) {/* Time O(N) */
+        slow = slow.next;
+        fast = fast.next.next;
+
+        const hasCycle = slow === fast;
+        if (hasCycle) return true;
     }
 
     return false;
-};
+};

javascript/143-Reorder-List.js

@@ -1,49 +1,51 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val, next) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.next = (next===undefined ? null : next)
- * }
- */
-/**
+ * https://leetcode.com/problems/reorder-list/
+ * Time O(N) | Space O(1)
  * @param {ListNode} head
  * @return {void} Do not return anything, modify head in-place instead.
  */
-var reorderList = function (head) {
-    if (!head) {
-        return;
-    }
+var reorderList = function(head) {
+    const mid = getMid(head);           /* Time O(N) */
+    const reveredFromMid = reverse(mid);/* Time O(N) */
 
-    let slow = head;
-    let fast = head;
+    reorder(head, reveredFromMid);      /* Time O(N) */
+};
+
+const getMid = (head) => {
+    let [ slow, fast ] = [ head, head ];
 
-    // finding the middle of the linked list using 2 pters
-    while (fast && fast.next) {
+    while (fast && fast.next) {         /* Time O(N) */
         slow = slow.next;
         fast = fast.next.next;
     }
 
-    // reverse the second part of the list starting at slow
-    let prev = null;
-    let curr = slow;
-    while (curr) {
-        let next = curr.next;
+    return slow;
+}
+
+const reverse = (head) => {
+    let [ prev, curr, next ] = [ null, head, null ];
+
+    while (curr) {                      /* Time O(N) */
+        next = curr.next;
         curr.next = prev;
+
         prev = curr;
         curr = next;
-    } // here prev is the head
+    }
 
-    // merge two sorted lists (first one starts at head, second at prev)
-    let first = head;
-    let second = prev;
+    return prev;
+}
 
-    while (second.next) {
-        temp = first.next;
+const reorder = (l1, l2) => {
+    let [ first, next, second ] = [ l1, null, l2 ];
+
+    while (second.next) {              /* Time O(N) */
+        next = first.next;
         first.next = second;
-        first = temp;
+        first = next;
 
-        temp = second.next;
+        next = second.next;
         second.next = first;
-        second = temp;
+        second = next;
     }
-};
+}

javascript/146-LRU-Cache.js

@@ -1,155 +1,70 @@
-//////////////////////////////////////////////////////////////////////////////
-// JavaScript Map Class Implementation
-// This solution produces a lot less code, but is exposed to poor performance
-// due to Map's internal maintenance of the order of properties. Constantly
-// deleting and resetting properties upon each retrieval is costly.
-//////////////////////////////////////////////////////////////////////////////
-
-/**
- * @param {number} capacity
+/** 
+ * https://leetcode.com/problems/lru-cache/
+ * Time O(1) | Space O(N)
+ * Your LRUCache object will be instantiated and called as such:
+ * var obj = new LRUCache(capacity)
+ * var param_1 = obj.get(key)
+ * obj.put(key,value)
  */
-function LRUCache(capacity) {
-    this.capacity = capacity;
-    this.cacheMap = new Map();
-}
+ class LRUCache {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.map = new Map();
 
-/**
- * @param {number} key
- * @return {number}
- */
-LRUCache.prototype.get = function (key) {
-    if (!this.cacheMap.has(key)) {
-        return -1;
-    }
-    const value = this.cacheMap.get(key);
-    this.cacheMap.delete(key);
-    this.cacheMap.set(key, value);
-    return value;
-};
+        this.head = {};
+        this.tail = {};
 
-/**
- * @param {number} key
- * @param {number} value
- * @return {void}
- */
-LRUCache.prototype.put = function (key, value) {
-    if (this.cacheMap.has(key)) {
-        this.cacheMap.delete(key);
-    } else if (this.cacheMap.size === this.capacity) {
-        const leastRecentlyUsedKey = this.cacheMap.keys().next().value;
-        this.cacheMap.delete(leastRecentlyUsedKey);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
     }
-    this.cacheMap.set(key, value);
-};
 
-//////////////////////////////////////////////////////////////////////////////
-// JavaScript Object Class Implementation
-// This solution requires more code and space due to the need to separately
-// define a doubly linked list and a hash map, but has better performance due
-// to strictly maintaining constant time lookups and additions.
-//////////////////////////////////////////////////////////////////////////////
+    removeLastUsed () {
+        const [ key, next, prev ]  = [ this.head.next.key, this.head.next.next, this.head ];
 
-class LRUNode {
-    /**
-     * @param {number} key
-     * @param {number} val
-     * @param {LRUNode=} next = `null`
-     * @constructor
-     */
-    constructor(key, val, next = null) {
-        this.key = key;
-        this.val = val;
-        this.prev = null;
-        this.next = next;
+        this.map.delete(key);
+        this.head.next = next;
+        this.head.next.prev = prev;
     }
-}
 
-class LRUCache {
-    /**
-     * @param {number} capacity
-     * @constructor
-     */
-    constructor(capacity) {
-        this.head = null;
-        this.tail = null;
-        this.map = Object.create(null);
-        this.length = 0;
-        this.capacity = capacity;
-    }
+    put (key, value) {
+        const hasKey = this.get(key) !== -1;
+        const isAtCapacity = this.map.size === this.capacity;
+        
+        if (hasKey) return (this.tail.prev.value = value);
+        if (isAtCapacity) this.removeLastUsed();
 
-    /**
-     * @param {number} key
-     * @return {number}
-     */
-    get(key) {
-        if (!(key in this.map)) {
-            return -1;
-        }
-        this.makeMostRecent(key);
-        return this.map[key].val;
+        const node = { key, value };
+        this.map.set(key, node);
+        this.moveToFront(node);
     }
 
-    /**
-     * @param {number} key
-     * @param {number} val
-     * @return {void}
-     */
-    put(key, val) {
-        if (key in this.map) {
-            this.map[key].val = val;
-            this.makeMostRecent(key);
-            return;
-        }
-
-        if (this.length === this.capacity) {
-            delete this.map[this.tail.key];
-            if (this.head === this.tail) {
-                this.head = null;
-                this.tail = null;
-            } else {
-                this.tail = this.tail.prev;
-                this.tail.next = null;
-            }
-        } else {
-            ++this.length;
-        }
+    moveToFront (node) {
+        const [ prev, next ] = [ this.tail.prev, this.tail ];
 
-        const node = new LRUNode(key, val, this.head);
-
-        if (this.head) {
-            this.head.prev = node;
-        } else {
-            this.tail = node;
-        }
-        this.head = node;
+        this.tail.prev.next = node;
+        this.connectNode(node, { prev, next });
+        this.tail.prev = node;
+    }
 
-        this.map[key] = node;
+    connectNode (node, top) {
+        node.prev = top.prev;
+        node.next = top.next;
     }
 
-    /**
-     * @param {number} key
-     * @return {void}
-     */
-    makeMostRecent(key) {
-        const node = this.map[key];
+    get (key) {
+        const hasKey = this.map.has(key);
+        if (!hasKey) return -1;
 
-        if (node === this.head) {
-            return node.val;
-        }
+        const node = this.map.get(key);
+        
+        this.disconnectNode(node);
+        this.moveToFront(node);
 
-        if (node.prev) {
-            node.prev.next = node.next;
-        }
-        if (node.next) {
-            node.next.prev = node.prev;
-        }
-        if (node === this.tail) {
-            this.tail = node.prev;
-        }
+        return node.value;
+    }
 
-        node.prev = null;
-        node.next = this.head;
-        this.head.prev = node;
-        this.head = node;
+    disconnectNode (node) {
+        node.next.prev = node.prev;
+        node.prev.next = node.next;
     }
 }

javascript/19-Remove-Nth-Node-From-End-of-List.js

@@ -1,33 +1,74 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val, next) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.next = (next===undefined ? null : next)
- * }
- */
-/**
+ * https://leetcode.com/problems/merge-two-sorted-lists/
+ * Time O(N) | Space O(N)
  * @param {ListNode} head
  * @param {number} n
  * @return {ListNode}
  */
-var removeNthFromEnd = function (head, n) {
-    let currNode = head;
-    let nodeBeforeN = head;
+ var removeNthFromEnd = function(head, n) {
+    const sentinel = new ListNode();
 
-    for (let i = 0; i < n; i++) {
-        currNode = currNode.next;
-    }
+    sentinel.next = head;
+
+    const fast = moveFast(sentinel, n);   /* Time O(N) */
+    const slow = moveSlow(sentinel, fast);/* Time O(N) */
+
+    slow.next = slow.next.next || null;
+
+    return sentinel.next;
+};
 
-    if (!currNode) {
-        return head.next;
+const moveFast = (fast, n) => {
+    for (let i = 1; i <= (n + 1); i++) {/* Time O(N) */
+        fast = fast.next;
     }
 
-    while (currNode.next) {
-        nodeBeforeN = nodeBeforeN.next;
-        currNode = currNode.next;
+    return fast;
+}
+
+const moveSlow = (slow, fast) => {
+    while (fast) {                     /* Time O(N) */
+        slow = slow.next;
+        fast = fast.next;
     }
 
-    nodeBeforeN.next = nodeBeforeN.next.next;
+    return slow;
+}
 
-    return head;
+/**
+ * https://leetcode.com/problems/merge-two-sorted-lists/
+ * Time O(N) | Space O(1)
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+ var removeNthFromEnd = function(head, n) {
+    const length = getNthFromEnd(head, n);/* Time O(N) */
+
+    const isHead = length < 0;
+    if (isHead) return head.next;
+
+    const curr = moveNode(head, length);  /* Time O(N) */
+
+    curr.next = curr.next.next;
+
+    return head
 };
+
+const getNthFromEnd = (curr, n, length = 0) => {
+    while (curr) {                       /* Time O(N) */
+        curr = curr.next;
+        length++;
+    }
+
+    return (length - n) - 1;
+}
+
+const moveNode = (curr, length) => {
+    while (length) {                    /* Time O(N) */
+        curr = curr.next;
+        length--;
+    }
+
+    return curr;
+}

javascript/2-Add-Two-Numbers.js

@@ -1,27 +1,60 @@
-function addTwoNumbers(l1, l2) {
-    let temp1 = l1;
-    let temp2 = l2;
+/**
+ * https://leetcode.com/problems/add-two-numbers/
+ * Time O(MAX(N, M)) | Space O(MAX(N, M))
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2) {
+    let sentinel = tail = new ListNode();
 
-    let dummy = new ListNode(0);
-    let merged = dummy;
+    return add(l1, l2, tail, sentinel);       /* Time O(MAX(N, M)) | Space O(MAX(N, M)) */
+}
 
-    let carry = 0;
+const add = (l1, l2, tail, sentinel, carry = 0) => {
+    const isBaseCase = !(l1 || l2 || carry);
+    if (isBaseCase) return sentinel.next;
 
-    while (temp1 || temp2) {
-        let sum = (temp1?.val || 0) + (temp2?.val || 0) + carry;
-        carry = Math.floor(sum / 10);
-        sum = sum % 10;
+    return dfs(l1, l2, tail, sentinel, carry);/* Time O(MAX(N, M)) | Space O(MAX(N, M)) */
+}
 
-        merged.next = new ListNode(sum);
-        merged = merged.next;
+const dfs = (l1, l2, tail, sentinel, carry) => {
+    const sum = (l1?.val || 0) + (l2?.val || 0) + carry;
+    const val = sum % 10;
+    carry = Math.floor(sum / 10);
 
-        if (temp1) temp1 = temp1?.next;
-        if (temp2) temp2 = temp2?.next;
-    }
+    tail.next = new ListNode(val);
+    tail = tail.next;
 
-    if (carry > 0) {
-        merged.next = new ListNode(carry);
-    }
+    l1 = l1?.next || null;
+    l2 = l2?.next || null;
+
+    add(l1, l2, tail, sentinel, carry);     /* Time O(MAX(N, M)) | Space O(MAX(N, M)) */
 
-    return dummy.next;
+    return sentinel.next;
 }
+
+/**
+ * https://leetcode.com/problems/add-two-numbers/
+ * Time O(MAX(N, M)) | Space O(MAX(N, M))
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2, carry = 0) {
+    let sentinel = tail = new ListNode();
+
+    while (l1 || l2 || carry) {/* Time O(MAX(N, M)) */
+        const sum = (l1?.val || 0) + (l2?.val || 0) + carry;
+        const val = sum % 10;
+        carry = Math.floor(sum / 10);
+
+        tail.next = new ListNode(val);
+        tail = tail.next;
+
+        l1 = l1?.next || null;
+        l2 = l2?.next || null;
+    }
+
+    return sentinel.next;
+};

javascript/206-Reverse-Linked-List.js

@@ -1,23 +1,41 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val, next) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.next = (next===undefined ? null : next)
- * }
+ * https://leetcode.com/problems/reverse-linked-list/
+ * Time O(N) | Space O(N)
+ * @param {ListNode} head
+ * @return {ListNode}
  */
+var reverseList = function (head) {
+    const isBaseCase = !head?.next;
+    if (isBaseCase) return head;
+
+    return dfs(head);                   /* Time O(N) | Space O(N) */
+}
+
+const dfs = (curr) => {
+    const prev = reverseList(curr.next);/* Time O(N) | Space O(N) */
+
+    curr.next.next = curr;
+    curr.next = null;
+
+    return prev;
+}
+
 /**
+ * https://leetcode.com/problems/reverse-linked-list/
+ * Time O(N) | Space O(1)
  * @param {ListNode} head
  * @return {ListNode}
  */
-var reverseList = function (head) {
-    let prev = null;
+ var reverseList = function (head) {
+    let [ prev, curr, next ] = [ null, head, null ];
+
+    while (curr) {/* Time O(N) */
+        next = curr.next;
+        curr.next = prev;
 
-    while (head) {
-        let next = head.next;
-        head.next = prev;
-        prev = head;
-        head = next;
+        prev = curr;
+        curr = next;
     }
 
     return prev;
-};
+};

javascript/21-Merge-Two-Sorted-Lists.js

@@ -1,28 +1,60 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val, next) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.next = (next===undefined ? null : next)
- * }
+ * https://leetcode.com/problems/merge-two-sorted-lists/
+ * Time O(N + M) | Space O(N + M)
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
  */
+ var mergeTwoLists = function(list1, list2) {
+    const isBaseCase1 = list1 === null;
+    if (isBaseCase1) return list2;
+
+    const isBaseCase2 = list2 === null;
+    if (isBaseCase2) return list1;
+
+    const isL2Greater = list1.val <= list2.val;
+    if (isL2Greater) {
+        list1.next = mergeTwoLists(list1.next, list2);/* Time O(N + M) | Space O(N + M) */
+
+        return list1;
+    }
+
+    const isL2Less = list2.val <= list1.val;
+    if (isL2Less) {
+        list2.next = mergeTwoLists(list1, list2.next);/* Time O(N + M) | Space O(N + M) */
+
+        return list2;
+    }
+}
+
 /**
+ * https://leetcode.com/problems/merge-two-sorted-lists/
+ * Time O(N + M) | Space O(N + M)
  * @param {ListNode} list1
  * @param {ListNode} list2
  * @return {ListNode}
  */
-var mergeTwoLists = function (l1, l2) {
-    let nullNode = { val: 0, next: null };
-    let prev = nullNode;
-    while (l1 && l2) {
-        if (l1.val >= l2.val) {
-            prev.next = l2;
-            l2 = l2.next;
-        } else {
-            prev.next = l1;
-            l1 = l1.next;
+var mergeTwoLists = function(list1, list2) {
+    let sentinel = tail = new ListNode();
+
+    while (list1 && list2) {/* Time O(N + M) */
+        const isL2Greater = list1.val <= list2.val;
+        const isL2Less = list2.val < list1.val;
+
+        if (isL2Greater) {
+            tail.next = list1;
+            list1 = list1.next;
+        }
+
+        if (isL2Less) {
+            tail.next = list2;
+            list2 = list2.next;
         }
-        prev = prev.next;
+
+        tail = tail.next;
     }
-    prev.next = l1 || l2;
-    return nullNode.next;
-};
+
+    tail.next = list1 || list2;
+
+    return sentinel.next;
+};

javascript/23-Merge-K-Sorted-Lists.js

@@ -1,28 +1,78 @@
-var merge = function (l1, l2) {
-    let tempNode = new ListNode(0);
-    let current = tempNode;
-
-    while (l1 && l2) {
-        if (l1.val < l2.val) {
-            current.next = l1;
-            l1 = l1.next;
+/**
+ * https://leetcode.com/problems/merge-k-sorted-lists/
+ * Time O(N) | Space O(N)
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+ var mergeKLists = function(lists) {
+    let previous = null;
+
+    for (let i = 0; i < lists.length; i++) {
+        previous = mergeTwoLists(previous, lists[i]);
+    }
+
+    return previous;
+};
+
+var mergeTwoLists = function(list1, list2) {
+    let sentinel = tail = new ListNode(0);
+
+    while (list1 && list2) {
+        const canAddL1 = list1.val <= list2.val;
+        if (canAddL1) {
+            tail.next = list1;
+            list1 = list1.next;
         } else {
-            current.next = l2;
-            l2 = l2.next;
+            tail.next = list2;
+            list2 = list2.next;
         }
-        current = current.next;
+
+        tail = tail.next;
     }
-    if (l1) current.next = l1;
-    if (l2) current.next = l2;
 
-    return tempNode.next;
+    tail.next = list1 || list2;
+
+    return sentinel.next;
 };
 
-var mergeKLists = function (lists) {
-    let root = lists[0];
+/**
+ * https://leetcode.com/problems/merge-k-sorted-lists/
+ * Time O(N * log(K)) | Space O(N + K)
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+ var mergeKLists = function(lists) {
+    const minHeap = getMinHeap(lists);
 
-    for (let i = 1; i < lists.length; i++) {
-        root = merge(root, lists[i]);
-    }
-    return root || null;
+    return mergeLists(minHeap)
 };
+
+const getMinHeap = (lists) => {
+    const heap = new MinPriorityQueue({ priority: ({ val }) => val });
+
+    for (const node of lists) {
+        if (!node) continue;
+
+        heap.enqueue(node);
+    }
+
+    return heap;
+}
+
+
+const mergeLists = (minHeap) => {
+    let sentinel = tail = new ListNode();
+
+    while (!minHeap.isEmpty()) {
+        const node = minHeap.dequeue().element;
+
+        tail.next = node;
+        tail = tail.next;
+
+        if (!node.next) continue;
+
+        minHeap.enqueue(node.next);
+    }
+
+    return sentinel.next;
+}

javascript/25-Reverse-Nodes-In-K-Group.js

@@ -0,0 +1,44 @@
+/**
+ * https://leetcode.com/problems/reverse-nodes-in-k-group/
+ * Time O(N) | Space O(N)
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+ var reverseKGroup = function(head, k) {
+    const sentinel = tail = new ListNode(0, head);
+
+    while (true) {
+        let [ start, last ]= moveNode(tail, k);
+        if (!last) break;
+
+        reverse([ start, tail.next, start ])
+
+        const next = tail.next;
+        tail.next = last;
+        tail = next;
+    }
+
+    return sentinel.next;
+};
+
+const moveNode = (curr, k) => {
+    const canMove = () => k && curr;
+    while (canMove()) {
+        curr = curr.next;
+        k--;
+    }
+
+    return [ (curr?.next || null), curr ];
+}
+
+const reverse = ([ prev, curr, start ]) => {
+    const isSame = () => curr === start;
+    while (!isSame()) {
+        const next = curr.next;
+        curr.next = prev;
+
+        prev = curr;
+        curr = next;
+    }
+}

javascript/25-Reverse-Nodes-in-K-Group.js

@@ -1,24 +1,257 @@
-function findDuplicate(nums) {
-    let slow = 0;
-    let fast = 0;
-
-    while (true) {
-        slow = nums[slow];
-        fast = nums[nums[fast]];
-        if (slow == fast) {
-            break;
-        }
-    }
-
-    let slow2 = 0;
-
-    while (true) {
-        slow = nums[slow];
-        slow2 = nums[slow2];
-        if (slow == slow2) {
-            break;
-        }
-    }
-
-    return slow;
-}
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N * log(N)) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    nums.sort((a, b) => a - b);/* Time O(N * log(N)) | HeapSort Space O(1) | QuickSort Space O(log(N)) */
+
+    for (let i = 1; i < nums.length; i++) {/* Time O(N) */
+        const isPrevDuplicate = nums[i - 1] === nums[i]
+        if (isPrevDuplicate) return nums[i];
+    }
+
+    return -1;
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N * log(N)) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    let [ left, right, duplicate ] = [ 1, (nums.length - 1), -1 ];
+
+    while (left <= right) {/* Time O(log(N)) */
+        const mid = (left + right) >> 1;
+        const count = getCount(mid, nums);/* Time O(N) */
+    
+        const isMidGreater = count <= mid
+        if (isMidGreater) left = mid + 1;
+
+        const isMidLess = mid < count
+        if (isMidLess) {
+            duplicate = mid;
+            right = mid - 1;
+        }
+    }
+
+    return duplicate;
+}
+
+const getCount = (mid, nums, count = 0) => {
+    for (const num of nums) {/* Time O(N) */
+        const isMidGreater = num <= mid
+        if (isMidGreater) count++;
+    }
+
+    return count;
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N * log(N)) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums, duplicate = 0) {
+    const mostSignificantBit = calcMaxBit(nums);        /* Time O(N) */
+
+    for (let bit = 0; bit < mostSignificantBit; bit++) {/* Time O(log(N)) */
+        const [ baseCount, numsCount, mask ] = count(nums, bit);/* Time O(N) */
+
+        const isMoreFrequentlySet = baseCount < numsCount
+        if (isMoreFrequentlySet) duplicate |= mask;
+    }
+
+    return duplicate;
+}
+
+const calcMaxBit = (nums, bits = 0) => {
+    let max = Math.max(0, ...nums);/* Time O(N) */
+
+    while (max) {/* Time O(log(MAX)) */
+        max >>= 1;
+        bits++;
+    }
+
+    return bits;
+}
+
+const count = (nums, bit) => {
+    let [ baseCount, numsCount, mask ] = [ 0, 0, (1 << bit) ];
+
+    for (let i = 0; i < nums.length; i++) {/* Time O(N) */
+        const isBaseBitSet = 0 < (i & mask);
+        if (isBaseBitSet) baseCount++;
+
+        const isNumBitSet = 0 < (nums[i] & mask);
+        if (isNumBitSet) numsCount++;
+    }
+
+    return [ baseCount, numsCount, mask ];
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(N)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums, curr = 0) {
+    const isBaseCase = curr === nums[curr]
+    if (isBaseCase) return curr;
+
+    const next = nums[curr];
+
+    nums[curr] = curr;
+
+    return findDuplicate(nums, next);/* Time O(N) | Space O(N) */
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(N)
+ * @param {number[]} nums
+ * @return {number}
+ */
+ var findDuplicate = function(nums, seen = new Set()) {
+    for (const num of nums) {/* Time O(N) */
+        if (seen.has(num)) return num;
+
+        seen.add(num);              /* Space O(N) */
+    }
+
+    return -1;
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    cyclicSort(nums);                                 /* Time O(N) */
+
+    return search(nums);                              /* Time O(N) */
+}
+
+const cyclicSort = (nums, index = 0) => {
+    const swap = (arr, a, b) => [arr[a], arr[b]] = [arr[b], arr[a]];
+
+    while (index < nums.length) {                     /* Time O(N) */
+        const [ num, arrayIndex, arrayNum ] = [ nums[index], (nums[index] - 1), nums[(nums[index] - 1)] ];
+
+        const canSwap = !isSame(num, arrayNum);
+        if (canSwap) {
+            swap(nums, index, arrayIndex);
+
+            continue;
+        }
+
+        index++;
+    }
+}
+const isSame = (a, b) => a === b;
+
+const search = (nums) => {
+    for (let index = 0; index < nums.length; index++) {/* Time O(N) */
+        const [ num, arrayIndex ] = [ nums[index], (index + 1) ];
+
+        if (!isSame(num, arrayIndex)) return num;
+    }
+
+    return nums.length;
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    const duplicate = negativeMarking(nums);/* Time O(N) */
+
+    restoreToPositiveNumbers(nums);         /* Time O(N) */
+
+    return duplicate;
+}
+
+const negativeMarking = (nums) => {
+    for (let i = 0; i < nums.length; i++) {/* Time O(N) */
+        const curr = Math.abs(nums[i]);
+
+        const isNegative = nums[curr] < 0;
+        if (isNegative) return curr;
+
+        nums[curr] *= -1;
+    }
+
+    return -1
+}
+
+const restoreToPositiveNumbers = (nums) => {
+    for (let i = 0; i < nums.length; i++) {/* Time O(N) */
+        nums[i] = Math.abs(nums[i]);
+    }
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+ var findDuplicate = function(nums, start = 0) {
+    const swap = (arr, a, b) => [arr[a], arr[b]] = [arr[b], arr[a]];
+
+    const isSame = () => nums[start] === nums[nums[start]];
+    while (!isSame()) {/* Time O(N) */
+        swap(nums, start, nums[start]);
+    }
+
+    return nums[start];
+}
+
+/**
+ * https://leetcode.com/problems/find-the-duplicate-number/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+ var findDuplicate = function(nums) {
+    if (!nums.length) return -1
+
+    let [ slow, fast ] = moveFast(nums);  /* Time O(N) */
+    [ slow, fast ] = moveSlow(nums, slow, fast);/* Time O(N) */
+
+    return slow;
+};
+
+const moveFast = (nums, start = 0) => {
+    let [ slow, fast ] = [ nums[start], nums[nums[start]] ];
+
+    const isSame = () => slow === fast;
+    while (!isSame()) {                   /* Time O(N) */
+        slow = nums[slow];
+        fast = nums[nums[fast]];
+    }
+
+    fast = start;
+
+    return [ slow, fast ];
+}
+
+const moveSlow = (nums, slow, fast) => {
+    const isSame = () => slow === fast;
+    while (!isSame()) {                 /* Time O(N) */
+        slow = nums[slow];
+        fast = nums[fast];
+    }
+
+    return [ slow, fast ];
+}