Quick Patterns Reference

let lo = 0, ans = 0;
for (let hi = 0; hi < n; hi++) {
  // expand window with nums[hi]
  while (/* window invalid */) {
    // shrink from left
    lo++;
  }
  ans = Math.max(ans, hi - lo + 1);
}

let lo = 0, hi = arr.length - 1;
while (lo < hi) {
  if (condition) {
    // found answer
  } else if (arr[lo] + arr[hi] < target) {
    lo++;
  } else {
    hi--;
  }
}

let lo = 0, hi = n - 1;
while (lo < hi) {
  const mid = (lo + hi) >> 1;
  if (check(mid)) hi = mid;   // mid is valid, try smaller
  else lo = mid + 1;           // mid is invalid, try larger
}
return lo; // first valid

// Top-down (memo)
const memo = new Map();
function dp(i) {
  if (base_case) return base_value;
  if (memo.has(i)) return memo.get(i);
  const result = Math.max(dp(i-1) + ..., dp(i-2) + ...);
  memo.set(i, result);
  return result;
}

// Bottom-up (tabulation)
const dp = new Array(n+1).fill(0);
dp[0] = base;
for (let i = 1; i <= n; i++)
  dp[i] = Math.max(dp[i-1] + ..., ...);

const visited = new Set([start]);
let queue = [start], level = 0;
while (queue.length) {
  const next = [];
  for (const node of queue) {
    if (node === target) return level;
    for (const nb of graph[node])
      if (!visited.has(nb)) { visited.add(nb); next.push(nb); }
  }
  queue = next;
  level++;
}

// Recursive DFS with 3-color cycle detection
const color = new Array(n).fill(0); // 0=unvisited, 1=visiting, 2=done
function dfs(u) {
  color[u] = 1;
  for (const v of graph[u]) {
    if (color[v] === 1) return false; // cycle!
    if (color[v] === 0 && !dfs(v)) return false;
  }
  color[u] = 2;
  return true;
}

let globalAns = -Infinity;
function dfs(node) {
  if (!node) return 0;
  const left  = Math.max(0, dfs(node.left));
  const right = Math.max(0, dfs(node.right));
  // update answer: path THROUGH this node (uses both branches)
  globalAns = Math.max(globalAns, left + node.val + right);
  // return to parent: single branch only
  return node.val + Math.max(left, right);
}

function backtrack(start, current) {
  if (/* is valid complete solution */) {
    result.push([...current]);
    return;
  }
  for (let i = start; i < candidates.length; i++) {
    if (/* pruning: skip invalid */) continue;
    current.push(candidates[i]);     // choose
    backtrack(i + 1, current);       // explore (i+1 for combos, i for repeats)
    current.pop();                    // unchoose
  }
}

// Activity selection: max non-overlapping intervals
intervals.sort((a, b) => a[1] - b[1]); // sort by END
let count = 0, lastEnd = -Infinity;
for (const [start, end] of intervals) {
  if (start >= lastEnd) {
    count++;        // take this interval
    lastEnd = end;
  }
}

// Top-k smallest: max-heap of size k
const heap = new MaxHeap();
for (const num of nums) {
  heap.push(num);
  if (heap.size() > k) heap.pop(); // remove largest
}
return heap.top(); // kth smallest

// k-way merge: min-heap with source index
const pq = new MinHeap(); // [val, listIdx, elemIdx]
for (let i = 0; i < lists.length; i++)
  if (lists[i]) pq.push([lists[i].val, i, lists[i]]);

const stack = []; // indices, in decreasing value order
const result = new Array(n).fill(-1);
for (let i = 0; i < n; i++) {
  // pop elements that are smaller (for next greater)
  while (stack.length && nums[stack.at(-1)] < nums[i]) {
    result[stack.pop()] = i; // current i is "next greater"
  }
  stack.push(i);
}

// Common bit tricks:
x & (x-1)     // clear lowest set bit (check power of 2: x & (x-1) === 0)
x & (-x)      // isolate lowest set bit
x ^ x === 0  // XOR of same number = 0
a ^ b ^ a === b // XOR is its own inverse

// Enumerate all subsets of mask
for (let sub = mask; sub > 0; sub = (sub-1) & mask) {
  // process sub
}

class TrieNode { constructor() { this.children = {}; this.isEnd = false; } }
class Trie {
  constructor() { this.root = new TrieNode(); }
  insert(word) {
    let node = this.root;
    for (const c of word) {
      if (!node.children[c]) node.children[c] = new TrieNode();
      node = node.children[c];
    }
    node.isEnd = true;
  }
  search(word) { /* walk and check isEnd */ }
  startsWith(prefix) { /* walk, return any node found */ }
}