Add more FB problems.

Author: Yong Su

README.md

@@ -51,6 +51,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Two Sum](src/array/two-sum.js)
 - [Three Sum](src/array/three-sum.js)
 - [Median of Two Sorted Arrays](src/array/median-of-two-sorted-arrays.js)
+- [Largest Rectangle in Histogram](src/array/largest-rectangle-in-histogram.js)
 - [Plus One](src/array/plus-one.js)
 - [Trapping Rain Water](src/array/trapping-rain-water)
 - [Merge Intervals](src/array/merge-intervals.js)
@@ -94,6 +95,9 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Longest Mountain in Array](src/array/longest-mountain-in-array.js)
 - [Continuous Subarray Sum](src/array/continuous-subarray-sum.js)
 - [Contiguous Array](src/array/contiguous-array.js)
+- [Merge Sorted Array](src/array/merge-sorted-array.js)
+- [Product of Array Except Self](src/array/product-of-array-except-self.js)
+- [Missing Number](src/array/missing-number.js)
 
 ### Matrix
 
@@ -153,6 +157,8 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Longest Substring with At Most Two Distinct Characters](src/string/longest-substring-with-at-most-two-distinct-characters.js)
 - [Longest Substring Without Repeating Characters](src/string/longest-substring-without-repeating-characters.js)
 - [Group Anagrams](src/string/group-anagrams.js)
+- [Palindromic Substrings](src/string/palindromic-substrings.js)
+- [Integer to English Words](src/string/integer-to-english-words.js)
 
 ### Sorting
 
@@ -428,6 +434,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Total Hamming Distance](src/math/total-hamming-distance.js)
 - [Nth Digit](src/math/nth-digit.js)
 - [Roman to Integer](src/math/roman-to-integer.js)
+- [Excel Sheet Column Title](src/math/excel-sheet-column-title.js)
 
 ### Sampling
 

src/array/largest-rectangle-in-histogram.js

@@ -0,0 +1,40 @@
+/**
+ * Largest Rectangle in Histogram
+ *
+ * Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the
+ * area of largest rectangle in the histogram.
+ *
+ * Example:
+ *
+ * Input: [2,1,5,6,2,3]
+ * Output: 10
+ */
+
+import Stack from 'common/stack';
+
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const largestRectangleArea = heights => {
+  const n = heights.length;
+  const stack = new Stack();
+
+  let max = 0;
+
+  for (let i = 0; i <= n; i++) {
+    // If we finished all the elements OR the current element is less than top
+    while (!stack.isEmpty() && (i === n || heights[i] < heights[stack.peek()])) {
+      const height = heights[stack.pop()];
+      const width = stack.isEmpty() ? i : i - 1 - stack.peek();
+
+      max = Math.max(max, width * height);
+    }
+
+    stack.push(i);
+  }
+
+  return max;
+};
+
+export { largestRectangleArea };

src/array/merge-sorted-array.js

@@ -0,0 +1,45 @@
+/**
+ * Merge Sorted Array
+ *
+ * Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
+ *
+ * Note:
+ *
+ * The number of elements initialized in nums1 and nums2 are m and n respectively.
+ * You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from
+ * nums2.
+ * Example:
+ *
+ * Input:
+ * nums1 = [1,2,3,0,0,0], m = 3
+ * nums2 = [2,5,6],       n = 3
+ *
+ * Output: [1,2,2,3,5,6]
+ */
+
+/**
+ * @param {number[]} nums1
+ * @param {number} m
+ * @param {number[]} nums2
+ * @param {number} n
+ * @return {void} Do not return anything, modify nums1 in-place instead.
+ */
+const merge = (nums1, m, nums2, n) => {
+  let i = m - 1;
+  let j = n - 1;
+  let k = m + n - 1;
+
+  while (i >= 0 && j >= 0) {
+    if (nums1[i] > nums2[j]) {
+      nums1[k--] = nums1[i--];
+    } else {
+      nums1[k--] = nums2[j--];
+    }
+  }
+
+  while (j >= 0) {
+    nums1[k--] = nums2[j--];
+  }
+};
+
+export { merge };

src/array/missing-number.js

@@ -0,0 +1,33 @@
+/**
+ * Missing Number
+ *
+ * Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.
+ *
+ * Example 1:
+ *
+ * Input: [3,0,1]
+ * Output: 2
+ * Example 2:
+ *
+ * Input: [9,6,4,2,3,5,7,0,1]
+ * Output: 8
+ * Note:
+ * Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space
+ * complexity?
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const missingNumber = nums => {
+  let res = nums.length;
+
+  for (i = 0; i < nums.length; i++) {
+    res ^= i ^ nums[i]; // a ^ b ^ b = a
+  }
+
+  return res;
+};
+
+export { missingNumber };

src/array/product-of-array-except-self.js

@@ -0,0 +1,42 @@
+/**
+ * Product of Array Except Self
+ *
+ * Given an array nums of n integers where n > 1,  return an array output such that output[i] is equal to the product
+ * of all the elements of nums except nums[i].
+ *
+ * Example:
+ *
+ * Input:  [1,2,3,4]
+ * Output: [24,12,8,6]
+ * Note: Please solve it without division and in O(n).
+ *
+ * Follow up:
+ * Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of
+ * space complexity analysis.)
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const productExceptSelf = nums => {
+  const n = nums.length;
+  const res = Array(n).fill(0);
+
+  // Scan from left to right
+  res[0] = 1;
+  for (let i = 1; i < n; i++) {
+    res[i] = res[i - 1] * nums[i - 1];
+  }
+
+  // Scan from right to left
+  let right = 1;
+  for (let i = n - 1; i >= 0; i--) {
+    res[i] *= right;
+    right *= nums[i];
+  }
+
+  return res;
+};
+
+export { productExceptSelf };

src/math/excel-sheet-column-title.js

@@ -0,0 +1,46 @@
+/**
+ * Excel Sheet Column Title
+ *
+ * Given a positive integer, return its corresponding column title as appear in an Excel sheet.
+ *
+ * For example:
+ *
+ *     1 -> A
+ *     2 -> B
+ *     3 -> C
+ *     ...
+ *     26 -> Z
+ *     27 -> AA
+ *     28 -> AB
+ *     ...
+ * Example 1:
+ *
+ * Input: 1
+ * Output: "A"
+ * Example 2:
+ *
+ * Input: 28
+ * Output: "AB"
+ * Example 3:
+ *
+ * Input: 701
+ * Output: "ZY"
+ */
+
+/**
+ * @param {number} n
+ * @return {string}
+ */
+const convertToTitle = n => {
+  let title = '';
+
+  while (n > 0) {
+    n--;
+    title = String.fromCharCode(65 + (n % 26)) + title;
+    n = Math.floor(n / 26);
+  }
+
+  return title;
+};
+
+export { convertToTitle };

src/string/integer-to-english-words.js

@@ -0,0 +1,76 @@
+/**
+ * Integer to English Words
+ *
+ * Convert a non-negative integer to its english words representation.
+ * Given input is guaranteed to be less than 231 - 1.
+ *
+ * Example 1:
+ *
+ * Input: 123
+ * Output: "One Hundred Twenty Three"
+ * Example 2:
+ *
+ * Input: 12345
+ * Output: "Twelve Thousand Three Hundred Forty Five"
+ * Example 3:
+ *
+ * Input: 1234567
+ * Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
+ * Example 4:
+ *
+ * Input: 1234567891
+ * Output: "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"
+ */
+
+const LESS_THAN_20 = [
+  '',
+  'One',
+  'Two',
+  'Three',
+  'Four',
+  'Five',
+  'Six',
+  'Seven',
+  'Eight',
+  'Nine',
+  'Ten',
+  'Eleven',
+  'Twelve',
+  'Thirteen',
+  'Fourteen',
+  'Fifteen',
+  'Sixteen',
+  'Seventeen',
+  'Eighteen',
+  'Nineteen',
+];
+const TENS = ['', 'Ten', 'Twenty', 'Thirty', 'Forty', 'Fifty', 'Sixty', 'Seventy', 'Eighty', 'Ninety'];
+const THOUSANDS = ['', 'Thousand', 'Million', 'Billion'];
+
+/**
+ * @param {number} num
+ * @return {string}
+ */
+const numberToWords = num => {
+  if (num === 0) return 'Zero';
+
+  let i = 0;
+  let words = '';
+
+  while (num > 0) {
+    if (num % 1000 != 0) words = helper(num % 1000) + THOUSANDS[i] + ' ' + words;
+    num = Math.floor(num / 1000);
+    i++;
+  }
+
+  return words.trim();
+};
+
+const helper = num => {
+  if (num == 0) return '';
+  else if (num < 20) return LESS_THAN_20[num] + ' ';
+  else if (num < 100) return TENS[Math.floor(num / 10)] + ' ' + helper(num % 10);
+  else return LESS_THAN_20[Math.floor(num / 100)] + ' Hundred ' + helper(num % 100);
+};
+
+export { numberToWords };

src/string/palindromic-substrings.js

@@ -0,0 +1,53 @@
+/**
+ * Palindromic Substrings
+ *
+ * Given a string, your task is to count how many palindromic substrings in this string.
+ *
+ * The substrings with different start indexes or end indexes are counted as different substrings even they consist of
+ * same characters.
+ *
+ * Example 1:
+ *
+ * Input: "abc"
+ * Output: 3
+ * Explanation: Three palindromic strings: "a", "b", "c".
+ *
+ * Example 2:
+ *
+ * Input: "aaa"
+ * Output: 6
+ * Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+ *
+ * Note:
+ * The input string length won't exceed 1000.
+ */
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countSubstrings = s => {
+  const extendPalindrome = (s, left, right) => {
+    while (left >= 0 && right < s.length && s[left] === s[right]) {
+      count++;
+      left--;
+      right++;
+    }
+  };
+
+  if (!s || s.length === 0) {
+    return 0;
+  }
+
+  let count = 0;
+
+  for (let i = 0; i < s.length; i++) {
+    // i is the mid point
+    extendPalindrome(s, i, i); // odd length;
+    extendPalindrome(s, i, i + 1); // even length
+  }
+
+  return count;
+};
+
+export { countSubstrings };