update

Author: MaiDeveloper

first-missing-positive.js

@@ -0,0 +1,89 @@
+/**
+ * First Missing Positive
+ *
+ * Given an unsorted integer array, find the smallest missing positive integer.
+ *
+ * Example 1:
+ *
+ * Input: [1,2,0]
+ * Output: 3
+ *
+ * Example 2:
+ *
+ * Input: [3,4,-1,1]
+ * Output: 2
+ *
+ * Example 3:
+ *
+ * Input: [7,8,9,11,12]
+ * Output: 1
+ *
+ * Note:
+ *
+ * Your algorithm should run in O(n) time and uses constant extra space.
+ */
+
+
+/**
+ * First Missing Positive
+ * @param {number[]} nums
+ * @return {number}
+ * @time complexity: O(n)
+ * @space complexity: O(1)
+ */
+function firstMissingPositive(nums) {
+  const contains = new Set();
+  let num = 1;
+
+  for (let n of nums) {
+    contains.add(n);
+  }
+
+  while (true) {
+    if (!contains.has(num)) {
+      return num;
+    }
+    num++;
+  }
+}
+
+/**
+ * First Missing Positive
+ * @param {number[]} nums
+ * @return {number}
+ * @time complexity: O(n)
+ * @space complexity: O(1)
+ */
+function firstMissingPositiveUsingSort(nums) {
+  let num = 1;
+
+  nums.sort((a, b) => a - b);
+
+  for (let n of nums) {
+    if (n === num) {
+      num++;
+    } else if (n > num) {
+      return num;
+    }
+  }
+
+  return num;
+}
+
+const assert = require('chai').assert;
+
+describe('First Missing Positive', () => {
+
+  it('should return 3 when [1,2,0] is given', () => {
+    assert.strictEqual(firstMissingPositive([1,2,0]), 3);
+  });
+
+  it('should return 2 when [3,4,-1,1] is given', () => {
+    assert.strictEqual(firstMissingPositive([3,4,-1,1]), 2);
+  });
+
+  it('should return 1 when [7,8,9,11,12] is given', () => {
+    assert.strictEqual(firstMissingPositive([7,8,9,11,12]), 1);
+  });
+
+});

lowest-common-ancestor-of-a-binary-tree.js

@@ -0,0 +1,103 @@
+/**
+ * Lowest Common Ancestor of a Binary Tree
+ *
+ * Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+ *
+ * According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”
+ *
+ * Given the following binary tree:  root = [3,5,1,6,2,0,8,null,null,7,4]
+ *
+ *            3
+ *          /   \
+ *         5     1
+ *        / \   / \
+ *       6   2 0   8
+ *          / \
+ *         7   4
+ *
+ * Example 1:
+ *
+ * Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+ * Output: 3
+ * Explanation: The LCA of nodes 5 and 1 is 3.
+ *
+ * Example 2:
+ *
+ * Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+ * Output: 5
+ * Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+ *
+ * Note:
+ *
+ *     All of the nodes' values will be unique.
+ *     p and q are different and both values will exist in the binary tree.
+ */
+
+/**
+ * Definition for a binary tree node.
+ */
+ function TreeNode(val) {
+  this.val = val;
+  this.left = this.right = null;
+ }
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ * @time complexity: O(n) where n is the number of nodes
+ * @space complexity: O(n) utilized by recursion stack
+ */
+var lowestCommonAncestor = function(root, p, q) {
+  if (!root || root.val === p.val || root.val === q.val) {
+    return root;
+  }
+
+  const left = lowestCommonAncestor(root.left, p, q);
+  const right = lowestCommonAncestor(root.right, p, q);
+
+  if (!left) {
+    return right;
+  }
+
+  if (!right) {
+    return left;
+  }
+
+  return root;
+};
+
+
+const assert = require('chai').assert;
+
+describe('Lowest Common Ancestor of a Binary Tree', () => {
+  let tree;
+
+  before(() => {
+    tree = arrayToTree([3,5,1,6,2,0,8,null,null,7,4]);
+
+    function arrayToTree(arr, root = null, index = 0) {
+      if (index < arr.length) {
+        root = new TreeNode(arr[index]);
+
+        root.left = arrayToTree(arr, root.left, 2 * index + 1);
+        root.right = arrayToTree(arr, root.right, 2 * index + 2);
+      }
+      return root;
+    }
+  });
+
+  it('should return node with value of 3', () => {
+    const result = lowestCommonAncestor(tree, new TreeNode(5), new TreeNode(1));
+    assert.strictEqual(result.val, 3);
+  });
+
+  it('should return node with value of 5', () => {
+    const result = lowestCommonAncestor(tree, new TreeNode(5), new TreeNode(4));
+    assert.strictEqual(result.val, 5);
+  });
+
+});
+
+

merge-two-sorted-lists.js

@@ -0,0 +1,106 @@
+/**
+ * Merge Two Sorted Lists
+ * Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
+ *
+ * Example:
+ *
+ * Input: 1->2->4, 1->3->4
+ * Output: 1->1->2->3->4->4
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+function ListNode(val) {
+  this.val = val;
+  this.next = null;
+}
+
+/**
+ * Merge Two Sorted Lists
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ * @time complexity: O(n + m)
+ *  where n and m are the size of l1 and l2 respectively
+ * @space complexity: O(1)
+ *  not allocating extra memory space instead reference to existing list node
+ */
+function mergeTwoLists(l1, l2) {
+  if (!l1) {
+    return l2;
+  }
+
+  if (!l2) {
+    return l1;
+  }
+
+  const dummy = new ListNode();
+  let curr = dummy;
+
+  while (l1 || l2) {
+    if (!l1 || (l2 && l2.val < l1.val)) {
+      curr.next = l2;
+      l2 = l2.next;
+    } else {
+      curr.next = l1;
+      l1 = l1.next;
+    }
+    curr = curr.next;
+  }
+
+  return dummy.next;
+};
+
+const assert = require('chai').assert;
+
+
+function toList(arr) {
+  const dummy = new ListNode();
+  let curr = dummy;
+
+  for (let n of arr) {
+    curr.next = new ListNode(n);
+    curr = curr.next;
+  }
+
+  return dummy.next;
+}
+
+function toArray(list) {
+  const arr = [];
+
+  while (list) {
+    arr.push(list.val);
+    list = list.next;
+  }
+
+  return arr;
+}
+
+describe('Merge Two Sorted Lists', () => {
+  it('should return sorted list', () => {
+    const l1 = toList([1, 2, 4]);
+    const l2 = toList([1, 3, 4]);
+    const result = mergeTwoLists(l1, l2);
+    assert.deepEqual(toArray(result), [1, 1, 2, 3, 4, 4]);
+  });
+  it('should return l1 list when l2 is empty', () => {
+    const l1 = toList([1]);
+    const l2 = toList([]);
+    const result = mergeTwoLists(l1, l2);
+    assert.deepEqual(toArray(result), [1]);
+  });
+  it('should return l2 list when l1 is empty', () => {
+    const l1 = toList([]);
+    const l2 = toList([1]);
+    const result = mergeTwoLists(l1, l2);
+    assert.deepEqual(toArray(result), [1]);
+  });
+  it('should return empty list', () => {
+    const l1 = toList([]);
+    const l2 = toList([]);
+    const result = mergeTwoLists(l1, l2);
+    assert.deepEqual(toArray(result), []);
+  });
+});

palindrome-number.js

@@ -0,0 +1,70 @@
+/**
+ * Palindrome Number
+ *
+ * Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.
+ *
+ * Example 1:
+ *
+ * Input: 121
+ * Output: true
+ *
+ * Example 2:
+ *
+ * Input: -121
+ * Output: false
+ * Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+ *
+ * Example 3:
+ *
+ * Input: 10
+ * Output: false
+ * Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
+ *
+ * Follow up:
+ *
+ * Coud you solve it without converting the integer to a string?
+ */
+
+/**
+ * Palindrome Number
+ * @param {number} x
+ * @return {boolean}
+ * @time complexity: O(log x) because we are dividing x by 10 in each iteration
+ * @space complexity: O(1)
+ */
+function isPalindromeNumber(x) {
+  // Negative number and positive number with trailing zero (except zero itself)
+  // are not palindrome number
+  if(x < 0 || (x % 10 == 0 && x != 0)) {
+    return false;
+  }
+
+  let reverted = 0;
+
+  while (x > reverted) {
+    reverted = reverted * 10 + x % 10; // Push digits one position forward and add last digit that pop from x
+    x = Math.floor(x / 10); // Only keep integer, so discards decimal points
+  }
+
+  // When the length of x is an odd number, remove the last digit (reverted / 10)
+  // The middle digit doesn't matter in palindrome
+  return x === reverted || x === Math.floor(reverted / 10);
+};
+
+const assert = require('chai').assert;
+
+describe('Palindrome Number', () => {
+
+  it('should return true', () => {
+    assert.strictEqual(isPalindromeNumber(121), true);
+  });
+
+  it('should return false if it is an nagative number', () => {
+    assert.strictEqual(isPalindromeNumber(-123), false);
+  });
+
+  it('should return false if the number ends with zero', () => {
+    assert.strictEqual(isPalindromeNumber(10), false);
+  });
+
+});