Ultimate Node.js Backend Interview DSA Guide – 2026

• `map`: Returns new array with transformed elements.
• `forEach`: Iterates only, returns `undefined`.
• `filter`: Returns new array with elements passing a condition.
• `reduce`: Accumulates array to a single value.

const arr = [1, 2, 2, 3];
const unique = [...new Set(arr)];

function flatten(arr) {
  return arr.reduce((acc, val) => 
    Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), []
  );
}

const intersection = arr1.filter(x => arr2.includes(x));
// Optimized: use Set for O(1) lookup
const set2 = new Set(arr2);
const intersection = arr1.filter(x => set2.has(x));

users.sort((a, b) => a.age - b.age); // Ascending
users.sort((a, b) => b.age - a.age); // Descending

function reverseString(str) {
  return str.split('').reverse().join('');
  // Manual: Loop backwards
}

function isPalindrome(str) {
  const clean = str.toLowerCase().replace(/[^a-z0-9]/g, '');
  return clean === clean.split('').reverse().join('');
}

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

const max = Math.max(...arr);
// Or reduce: arr.reduce((a, b) => a > b ? a : b);

function fibonacci(n) {
  const seq = [0, 1];
  for (let i = 2; i < n; i++) {
    seq[i] = seq[i-1] + seq[i-2];
  }
  return seq;
}

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

function isAnagram(s, t) {
  if (s.length !== t.length) return false;
  const map = {};
  for (let c of s) map[c] = (map[c] || 0) + 1;
  for (let c of t) {
    if (!map[c]) return false;
    map[c]--;
  }
  return true;
}

function groupAnagrams(strs) {
  const map = {};
  for (let s of strs) {
    const key = s.split('').sort().join('');
    if (!map[key]) map[key] = [];
    map[key].push(s);
  }
  return Object.values(map);
}

function maxSubArray(nums) {
  let currentMax = nums[0];
  let globalMax = nums[0];
  for (let i = 1; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    globalMax = Math.max(globalMax, currentMax);
  }
  return globalMax;
}

function reverseList(head) {
  let prev = null;
  let curr = head;
  while(curr) {
    let next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }
  return prev;
}

function levelOrder(root) {
  if (!root) return [];
  const queue = [root];
  const result = [];
  while (queue.length) {
    const levelSize = queue.length;
    const currentLevel = [];
    for (let i=0; i < levelSize; i++) {
      const node = queue.shift();
      currentLevel.push(node.val);
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
    result.push(currentLevel);
  }
  return result;
}

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

intervals.sort((a, b) => a[0] - b[0]);
const res = [intervals[0]];
for (let curr of intervals) {
  let prev = res[res.length - 1];
  if (curr[0] <= prev[1]) {
    prev[1] = Math.max(prev[1], curr[1]);
  } else {
    res.push(curr);
  }
}