hassam7

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class DDeque {
  constructor(items = []) {
    this.front = null;

hassam7

class Node {
  constructor(value = null) {
    this.value = value;
    this.prev = null;
    this.next = null;
  }
}

class Deque {
  constructor() {

hassam7

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class Queue {
    constructor() {
        this.front = null;

hassam7

function mapPromises(args, callback, concurrency = 3) {
    const { promise, resolve } = Promise.withResolvers();
    const results = [];
    let cursor = 0;

    function next() {
        if (cursor < args.length) {
            const index = cursor++;

            void callback(...args[index]).then(value => {

hassam7

/**
 * @param {number[]} temperatures
 * @return {number[]}
 */
var dailyTemperatures = function (temp) {
    const result = new Array(temp.length).fill(0);
    let stack = [];
    for (let i = temp.length - 1; i >= 0; i--) {
        while (stack.length && temp[stack[stack.length - 1]] <= temp[i]) stack.pop();
        if (stack.length === 0) result[i] = 0;

hassam7

var nextGreaterElements = function (nums) {
    let result = new Array(nums.length);
    let stack = [];
    const n = nums.length;
    for (let i = 2 * n - 1; i >= 0; i--) {
        const idx = i % n;
        while (stack.length && stack.at(-1) <= nums[idx]) stack.pop();


        if (!stack.length) result[idx] = -1;

hassam7

function upperBound(arr, x) {
  let low = 0, high = arr.length - 1;
  let ans = arr.length;

  while (low <= high) {
    let mid = Math.floor((low + high) / 2);
    // maybe an answer
    if (arr[mid] > x) {
      ans = mid;
      //look for smaller index on the left

hassam7

class UnionFind {
  constructor(n) {
    this.parent = [];
    this.size = [];
    this.rank = [];
    for (let i = 0; i < n; i++) {
      this.parent.push(i);
      this.size.push(1);
      this.rank.push(0);
    }

hassam7

GROKKING NOTES

I liked the way Grokking the coding interview organized problems into learnable patterns. However, the course is expensive and the majority of the time the problems are copy-pasted from leetcode. As the explanations on leetcode are usually just as good, the course really boils down to being a glorified curated list of leetcode problems.

So below I made a list of leetcode problems that are as close to grokking problems as possible.

Pattern: Sliding Window

• https://leetcode.com/problems/maximum-subarray/ # Close enough
• https://leetcode.com/problems/minimum-size-subarray-sum/

hassam7

const nArray = (rows, cols, defaultValue = undefined) => {
  if (rows == 1) return new Array(cols).fill(defaultValue);
  else {
    let result = new Array(cols);
    for (let i = 0; i < cols; i++) {
      result[i] = nArray(rows - 1, cols);
    }
    return result
  }
}