Question Bank for Final Hunt

function twoSum(nums, target) {
  const seen = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (seen.has(target - nums[i])) return [seen.get(target - nums[i]), i];
    seen.set(nums[i], i);
  }
}

function hasCycle(head) {
  let slow = head, fast = head;
  while (fast && fast.next) {
    slow = slow.next; fast = fast.next.next;
    if (slow === fast) return true;
  }
  return false;
}

function lengthOfLongestSubstring(s) {
  const seen = new Set();
  let left = 0, max = 0;
  for (let right = 0; right < s.length; right++) {
    while (seen.has(s[right])) { seen.delete(s[left]); left++; }
    seen.add(s[right]);
    max = Math.max(max, right - left + 1);
  }
  return max;
}

function isValidBST(node, min = -Infinity, max = Infinity) {
  if (!node) return true;
  if (node.val <= min || node.val >= max) return false;
  return isValidBST(node.left, min, node.val) && isValidBST(node.right, node.val, max);
}

function numIslands(grid) {
  let count = 0;
  function dfs(r, c) {
    if (r<0||c<0||r>=grid.length||c>=grid[0].length||grid[r][c]!=='1') return;
    grid[r][c] = '0'; // mark visited
    dfs(r+1,c); dfs(r-1,c); dfs(r,c+1); dfs(r,c-1);
  }
  for (let r=0;rfor (let c=0;c0].length;c++)
      if (grid[r][c]==='1') { count++; dfs(r,c); }
  return count;
}

function climbStairs(n) {
  if (n <= 2) return n;
  let a = 1, b = 2;
  for (let i = 3; i <= n; i++) { [a, b] = [b, a + b]; }
  return b;
}

// Simplified using sort (mention heap/quickselect as optimal in interview)
function findKthLargest(nums, k) {
  return nums.sort((a,b)=>b-a)[k-1];
}
// Optimal: Min-Heap size k → O(n log k), or Quickselect → O(n) average

function merge(intervals) {
  intervals.sort((a,b) => a[0] - b[0]);
  const result = [intervals[0]];
  for (let i = 1; i < intervals.length; i++) {
    const last = result[result.length - 1];
    if (intervals[i][0] <= last[1]) last[1] = Math.max(last[1], intervals[i][1]);
    else result.push(intervals[i]);
  }
  return result;
}

• Promise.all: wait for all, reject immediately if ANY one reject.
• Promise.allSettled: wait for all, never reject — return array of {status, value/reason} for each.
• Promise.race: resolve/reject as soon as FIRST promise settle (win or lose).
• Promise.any: resolve as soon as FIRST promise fulfill; only reject if ALL reject.

app.use((req, res, next) => {
  console.log(req.method, req.url);
  next(); // must call, or request stuck
});

const asyncHandler = fn => (req, res, next) => 
  Promise.resolve(fn(req, res, next)).catch(next);

app.get('/user', asyncHandler(async (req, res) => {
  const user = await getUser();
  res.json(user);
}));