Update

Author: MaiDeveloper

count-binary-substrings.js

@@ -0,0 +1,80 @@
+/**
+ * Count Binary Substring
+ *
+ * Give a string s, count the number of non-empty (contiguous) substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.
+ *
+ * Substrings that occur multiple times are counted the number of times they occur.
+ *
+ * Example 1:
+ *
+ * Input: "00110011"
+ * Output: 6
+ * Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+ *
+ * Notice that some of these substrings repeat and are counted the number of times they occur.
+ *
+ * Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.
+ *
+ * Example 2:
+ *
+ * Input: "10101"
+ * Output: 4
+ * Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.
+ *
+ * Note:
+ * s.length will be between 1 and 50,000.
+ * s will only consist of "0" or "1" characters.
+ */
+
+/**
+ * Count Binary Substring
+ * @param {string} s
+ * @return {number}
+ * @time complexity: O(n^2) where n is the length of s, in each iteration it might do O(n) work
+ * @space complexity: O(1)
+ */
+var countBinarySubstrings = function(s) {
+  let res = 0;
+  let expandFromCenter = (s, left, right) => {
+    let i = 1;
+
+    while (s.charAt(left - i) === s.charAt(left) && s.charAt(right + i) === s.charAt(right)) {
+      i++;
+    }
+
+    return i - 1;
+  };
+
+  for (let i = 1; i < s.length; i++) {
+    if (s.charAt(i - 1) !== s.charAt(i)) {
+      res++; // 01 or 10
+      res += expandFromCenter(s, i - 1, i);
+    }
+  }
+
+  return res;
+};
+
+
+const assert = require('chai').assert;
+
+describe('Count Binary Substrings', () => {
+
+  it('should return 6 when \'00110011\' is given', () => {
+    assert.strictEqual(countBinarySubstrings('00110011'), 6);
+  });
+
+  it('should return 4 when \'10101\' is given', () => {
+    assert.strictEqual(countBinarySubstrings('10101'), 4);
+  });
+
+  it('should return 1 when \'0001\' is given', () => {
+    assert.strictEqual(countBinarySubstrings('0001'), 1);
+  });
+
+  it('should return 0 when \'1\' is given', () => {
+    assert.strictEqual(countBinarySubstrings('1'), 0);
+  });
+
+});
+

diagonal-traverse.js

@@ -0,0 +1,137 @@
+/**
+ * Diagonal Traverse
+ *
+ * Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image.
+ *
+ * Example:
+ *
+ * Input:
+ * [
+ *  [ 1, 2, 3 ],
+ *  [ 4, 5, 6 ],
+ *  [ 7, 8, 9 ]
+ * ]
+ *
+ * Output:  [1,2,4,7,5,3,6,8,9]
+ */
+
+/**
+ * Diagonal Order
+ * @param {number[][]} matrix
+ * @return {number[]}
+ * @time complexity: O(n)
+ * @space complexity: O(n)
+ */
+const findDiagonalOrder = (matrix) => {
+  if (matrix.length === 0) {
+    return [];
+  }
+
+  const result = [];
+  const rowCount = matrix.length;
+  const colCount = matrix[0].length;
+  const total = rowCount * colCount;
+
+  let row = 0;
+  let col = 0;
+  let rowMove = -1;
+  let colMove = 1;
+
+  const reverse = () => {
+    rowMove = -rowMove;
+    colMove = -colMove;
+  };
+
+  while (result.length < total) {
+    result.push(matrix[row][col]);
+
+    row += rowMove;
+    col += colMove;
+
+    if (row > rowCount - 1) { // Bottom outbound
+      reverse();
+      row -= 1;
+      col += 2;
+    } else if (col > colCount - 1) { // Right outbound
+      reverse();
+      row += 2;
+      col -= 1;
+    } else if (row < 0) { // Top outbound
+      reverse();
+      row = 0;
+    } else if (col < 0) { // Left outbound
+      reverse();
+      col = 0;
+    }
+  }
+
+  return result;
+}
+
+
+/**
+ * Diagonal Order
+ * @param {number[][]} matrix
+ * @return {number[]}
+ * @time complexity: O(n)
+ * @space complexity: O(n)
+ */
+const findDiagonalOrderAlternative = (matrix) => {
+  if (matrix.length === 0) {
+    return [];
+  }
+
+  const result = [];
+  const rowCount = matrix.length;
+  const colCount = matrix[0].length;
+  const total = rowCount * colCount;
+  let row = 0;
+  let col = 0;
+
+  while (result.length < total) {
+    result.push(matrix[row][col]);
+
+    if ((row + col) % 2 === 0) { // Move up diagonally
+      if (col === colCount - 1) {
+        row++;
+      } else if (row === 0) {
+        col++;
+      } else {
+        row--;
+        col++;
+      }
+    } else { // Move down diagonally
+      if (row === rowCount - 1) {
+        col++;
+      } else if (col === 0) {
+        row++;
+      } else {
+        row++;
+        col--;
+      }
+    }
+  }
+
+  return result;
+};
+
+
+const assert = require('chai').assert;
+
+describe('Diagonal Traverse', () => {
+
+  it('should return numbers in diagonal order', () => {
+    const matrix = [
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ];
+    const expected = [1,2,4,7,5,3,6,8,9];
+    assert.deepEqual(findDiagonalOrder(matrix), expected);
+  });
+
+  it('should return empty array', () => {
+    assert.deepEqual(findDiagonalOrder([]), []);
+  });
+
+});

euclidean-distance.js

@@ -0,0 +1,36 @@
+
+/**
+ * Calculate the distance between two points in one dimensional space
+ * @param {number} a first point
+ * @param {number} b second point
+ * @return {number}
+ * @time complexity: O(1)
+ * @space complexity: O(1)
+ */
+function oneDimensional(a, b) {
+  let dist = a - b;
+
+  if (dist < 0) {
+    dist = Math.sqrt(Math.pow(dist, 2));
+  }
+
+  return dist;
+
+  // Or
+  // return Math.abs(a - b);
+};
+
+/**
+ * Calculate the distance between two points in two dimensional space
+ * @param {number[]} a first point, Ex. [2, 4]
+ * @param {number[]} b second point, Ex. [-3, 8]
+ * @return {number}
+ * @time complexity: O(1)
+ * @space complexity: O(1)
+ */
+function twoDimensional(a, b) {
+  return Math.sqrt(Math.pow(b[0] - a[0], 2) + Math.pow(b[1] - a[1], 2));
+}
+
+console.log(oneDimensional(8, -3));
+console.log(twoDimensional([2, 4], [-3, 8]));

largest-rectangle-in-histogram.js

@@ -0,0 +1,83 @@
+/**
+ * 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:
+ *
+ *       ___
+ *     __| |
+ *     | | |
+ *     | | |__
+ * ___ | | | |
+ * | |_| | | |
+ * | | | | | |
+ * ----------------
+ *       ___
+ *     __| |
+ *     |x|x|
+ *     |x|x|__
+ * ___ |x|x| |
+ * | |_|x|x| |
+ * | | |x|x| |
+ * ----------------
+ *
+ * Input: [2,1,5,6,2,3]
+ * Output: 10
+ *
+ */
+
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const largestRectangleArea = heights => {
+
+  const n = heights.length,
+        stack = [];
+
+  let maxArea = 0;
+
+  for (let i = 0; i < n; i++) {
+
+    while (stack.length && heights[i] <= heights[stack[stack.length-1]]) {
+      maxArea = Math.max(maxArea, getArea(i, heights, stack));
+    }
+
+    stack.push(i);
+  }
+
+  while (stack.length) {
+    maxArea = Math.max(maxArea, getArea(n, heights, stack));
+  }
+
+  return maxArea;
+};
+
+const getArea = (i, heights, stack) => {
+  const h = heights[stack.pop()],
+        w = stack.length ? i - stack[stack.length-1] - 1 : i;
+
+  return h * w;
+};
+
+
+const assert = require('chai').assert;
+
+describe('Largest Rectangle in Histogram', () => {
+
+  it('should find the longest path', () => {
+    const input = [2,1,5,6,2,3],
+          output = 10;
+
+    assert.strictEqual(largestRectangleArea(input), output);
+  });
+
+  it('should return 2 for [1, 1]', () => {
+    const input = [1, 1],
+          output = 2;
+
+    assert.strictEqual(largestRectangleArea(input), output);
+  })
+
+});