motss

// Time complexity: O(n ^ 2) where is the number of levels and
//                  another n is for the number of elements in each level.
// Space complexity: O(2n + 1) to hold all elements, which is linear space.
function pascalTriangle(level) {
    if (level === 0) return [];
    if (level === 1) return [1];
    if (level === 2) return [1, 1];

    const d = Array.from(Array(level), () => []);

motss

// Given an integer n, find the minimum number of steps
// to reach integer 1.
// At each step, you can:
// * n - 1
// * n / 2, if it is divisble by 2
// * n / 3, if it is divisble by 3

// n = 0: 0 // base case 0.
// n = 1: 0 // base case 1.
// n = 2: 1 // base case 2.

motss

// i
// j
// 4 2 1 3 6 0

//   i
// j
// 4 2 1 3 6 0
// 2 4 1 3 6 0 # 2 < 4

//     i

motss

{
// Reference: https://bit.ly/2yjWDeY
// Time complexity: O(n log n) on average or O(n^2) for worst-case
// Space complexity: O(n)

function quickSort(list) {
  if (list.length < 2) return list;

  const left = [];
  const right = [];

motss

// http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
// http://es5.github.io/#x11.9.3

// Abstract/ loose equality comparison will do type coercion
// While strict equality comparison will compare the types

null == undefined; // true

motss

function bsr(arr, m) {
  let l = 0;
  let r = arr.length - 1;

  while (l <= r) {
    const mid = (l + (r - l) / 2) | 0;
    const val = arr[mid];

    if (val === m) return mid;
    if (m > val) l = mid + 1;

motss

Attempt to recreate flight search form on Google Flights

Demo URL

motss

function bfs<T>(tree: BSTNode<T>, fn: (n: T) => void) {
  const queue = [tree];
  
  while (queue.length) {
    const cur = queue.shift();
  
    if (cur.left) queue.push(cur.left);
    if (cur.right) queue.push(cur.right);
  
    fn(cur.value);

motss

/**
 * This was intended for checking that an ASCII character is in range.
 * But this turns out to be a function that can be used for checking if a number is in range too.
 * 
 * Assuming, `MIN` and `MAX` are hardcoded to the code point of the character 'a' and
 * the character 'z', respectively, the following equation will always return positive integers
 * in the difference of the `MIN` and the `MAX`:
 *
 *     (MAX - x) and (x - MIN) must always be positive for any of the results.
 *

motss

/** See https://bit.ly/2gvCcqe to learn more about UUID v4 for browsers */
function uuidv4() {
  if (window.crypto && window.crypto.getRandomValues) {
    return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
      (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
  }

  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = Math.random() * 16 | 0;
    const v = c == 'x' ? r : (r & 0x3 | 0x8);