JavaScript fundamentals, field-manual style

Given an array of integers nums and an integer target, return the indices of the two numbers that add up to target. Exactly one valid answer exists.

• Brute force: check every pair — O(n²). Works, but there's a faster way.
• For each number, what you actually need is its complement (target - num) — and whether you've already seen it.
• A hashmap lets you check "have I seen this complement?" in O(1), so one pass is enough: for each number, look up its complement before adding the current number to the map.

function twoSum(nums, target) {
  const seen = new Map(); // value -> index
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (seen.has(complement)) return [seen.get(complement), i];
    seen.set(nums[i], i);
  }
  return [];
}
twoSum([2,7,11,15], 9); // [0, 1] — nums[0]+nums[1] = 9

The map is built as you go, so by the time you check for a complement, the map only contains numbers seen before the current index — this naturally prevents using the same element twice.

Given two strings s and t, return true if t is an anagram of s (same letters, same frequency, any order).

• Different lengths ⇒ can't be anagrams, bail out immediately.
• Anagram = same character frequency. Count characters in s, then subtract while walking t — if any count goes negative (or missing), it's not an anagram.

function isAnagram(s, t) {
  if (s.length !== t.length) return false;
  const count = {};
  for (const ch of s) count[ch] = (count[ch] || 0) + 1;
  for (const ch of t) {
    if (!count[ch]) return false;  // missing, or already used up
    count[ch]--;
  }
  return true;
}
isAnagram('listen', 'silent'); // true

Building then draining one frequency map avoids the O(n log n) cost of sorting both strings. !count[ch] catches both "never seen" (undefined) and "count hit zero" in one check.

Given a character array, reverse it in-place (constant extra space).

• "In-place" is the constraint that rules out building a new reversed array — think two pointers instead.
• One pointer starts at the front, one at the back. Swap them, then step inward. Stop when they meet or cross.

function reverseString(arr) {
  let left = 0, right = arr.length - 1;
  while (left < right) {
    [arr[left], arr[right]] = [arr[right], arr[left]]; // swap via destructuring
    left++;
    right--;
  }
  return arr;
}
reverseString(['h','e','l','l','o']); // ['o','l','l','e','h']

The two-pointer pattern is worth internalizing on its own — it shows up again almost verbatim in Valid Palindrome (E4) below.

Given a string, determine if it's a palindrome after ignoring non-alphanumeric characters and case — e.g. "A man, a plan, a canal: Panama" → true.

• Same two-pointer idea as E3, but this time comparing instead of swapping, and skipping characters that don't count.
• At each step, advance left past non-alphanumeric characters, advance right past non-alphanumeric characters, then compare the two (lower-cased). Mismatch ⇒ not a palindrome.

function isPalindrome(s) {
  const isAlnum = c => /[a-z0-9]/i.test(c);
  let left = 0, right = s.length - 1;
  while (left < right) {
    while (left < right && !isAlnum(s[left])) left++;
    while (left < right && !isAlnum(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

Doing the skip-and-compare in one pass avoids the naive approach of first building a cleaned string (an extra O(n) allocation) before checking it.

Print numbers 1 to n; for multiples of 3 print "Fizz", multiples of 5 print "Buzz", multiples of both print "FizzBuzz".

• The only trap: check "divisible by both" before checking 3 and 5 individually, or use a single % 15 check — otherwise "FizzBuzz" cases wrongly print just "Fizz".

function fizzBuzz(n) {
  const result = [];
  for (let i = 1; i <= n; i++) {
    if (i % 15 === 0) result.push('FizzBuzz');
    else if (i % 3 === 0) result.push('Fizz');
    else if (i % 5 === 0) result.push('Buzz');
    else result.push(String(i));
  }
  return result;
}

Trivial algorithmically — its real purpose in an interview is to see whether you write clean, correct code under mild pressure without overthinking a simple problem.

Given an array containing n distinct numbers from 0 to n, find the one number missing from the range.

• What should be there: numbers 0..n sum to a known value via Gauss's formula, n*(n+1)/2.
• What is there: sum the actual array.
• The missing number is simply the difference — no sorting, no extra data structure needed.

function missingNumber(nums) {
  const n = nums.length;
  const expectedSum = (n * (n + 1)) / 2;
  const actualSum = nums.reduce((sum, x) => sum + x, 0);
  return expectedSum - actualSum;
}
missingNumber([3,0,1]); // 2

An alternative worth mentioning out loud: XOR every index and every value together — every number that appears in both cancels to 0 (x ^ x = 0), leaving only the missing number. Same O(n)/O(1), avoids any risk of numeric overflow in languages with fixed-size integers (less of a concern in JS, but interviewers like hearing you know it).

Given an array, return true if any value appears at least twice.

• Track what you've already seen in a Set (O(1) lookup). The moment you see something already in the set, you can stop immediately.

function containsDuplicate(nums) {
  const seen = new Set();
  for (const n of nums) {
    if (seen.has(n)) return true;
    seen.add(n);
  }
  return false;
}

A one-liner like new Set(nums).size !== nums.length also works, but it always scans the whole array first to build the set — the loop version above can exit early on the very first duplicate, which matters on large inputs.

Given an array that may contain arrays nested to any depth, return a single flat array of all the values, in order.

• This is naturally recursive: for each item, if it's an array, flatten it and splice the results in; if it's a plain value, keep it as-is.
• reduce (§4.1) is a clean way to express "build up one flat array from many items."

function flatten(arr) {
  return arr.reduce((flat, item) =>
    flat.concat(Array.isArray(item) ? flatten(item) : item), []);
}
flatten([1, [2, [3, [4]], 5]]); // [1, 2, 3, 4, 5]

// the built-in equivalent, worth knowing exists:
[1, [2, [3]]].flat(Infinity); // [1, 2, 3]

The recursion depth matches the nesting depth, not the element count — a very deeply nested (thousands of levels) array could theoretically hit a stack limit, worth mentioning as an edge case if asked.

Implement a debounce(fn, wait) that returns a new function which only invokes fn after wait ms have passed without another call — a favorite "write it live" question, and pure application of §2.1 (closures) and §6.1 (the event loop).

• You need to remember one thing between calls — the current pending timer's ID. A closure is exactly the tool for "state that persists between calls to a returned function."
• Every new call should cancel whatever timer is currently pending and start a fresh one — that's the entire behavior.

function debounce(fn, wait) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn.apply(this, args), wait);
  };
}

// usage
const logSearch = debounce(q => console.log('searching:', q), 300);
logSearch('a'); logSearch('ap'); logSearch('app');
// only "searching: app" ever logs — the first two calls got cancelled

timeoutId lives in the closure created by debounce's single invocation, so every call to the returned function shares and updates the same variable — that's what lets each new call cancel the previous pending one via clearTimeout.

Implement reduce from scratch, matching the native method's signature and behavior — the strongest possible proof you actually understand §4.1.

• Core loop: keep an accumulator, call the callback with (accumulator, currentValue, index, array), update the accumulator with the return value, repeat.
• The one real subtlety: an optional initial value. If it's not given, the native method uses the array's first element as the starting accumulator and begins iterating from index 1 instead of 0.

Array.prototype.myReduce = function(callback, initialValue) {
  let acc = initialValue;
  let startIndex = 0;
  if (acc === undefined) {
    acc = this[0];   // no initial value → seed with first element
    startIndex = 1;    // ...and start the loop one element later
  }
  for (let i = startIndex; i < this.length; i++) {
    acc = callback(acc, this[i], i, this);
  }
  return acc;
};

[1,2,3,4].myReduce((sum, x) => sum + x, 0); // 10

Attaching it to Array.prototype (§5.1) is what makes this inside the function refer to the array it's called on — the same prototype mechanism that makes every built-in array method work.

Given an array of strings, group the ones that are anagrams of each other.

• Direct extension of E2: two strings are anagrams exactly when some canonical form of them is identical.
• Sorting a string's characters gives a canonical form: "eat" and "tea" both sort to "aet".
• Use that sorted string as a hashmap key, and push each original string into the bucket for its key.

function groupAnagrams(strs) {
  const groups = new Map();
  for (const s of strs) {
    const key = s.split('').sort().join('');
    if (!groups.has(key)) groups.set(key, []);
    groups.get(key).push(s);
  }
  return Array.from(groups.values());
}
groupAnagrams(['eat','tea','tan','ate','nat','bat']);
// [['eat','tea','ate'], ['tan','nat'], ['bat']]

Sorting each string costs O(k log k) for a string of length k. For large alphabets-only inputs, a 26-length character-count array joined into a key (rather than sorting) drops this to O(k) per string — worth mentioning as the optimization if asked to go faster.

Given a string, find the length of the longest substring with no repeated characters.

• Brute force checks every substring — O(n²) or worse. The key insight: as you scan left to right, you only ever need to know the most recent position of each character.
• This is a sliding window: keep a window [left, right] with no repeats. Expand right each step; if you hit a character already in the window, jump left to just past its last occurrence instead of resetting to zero.

function lengthOfLongestSubstring(s) {
  const lastSeen = new Map(); // char -> most recent index
  let left = 0, maxLen = 0;
  for (let right = 0; right < s.length; right++) {
    const ch = s[right];
    if (lastSeen.has(ch) && lastSeen.get(ch) >= left) {
      left = lastSeen.get(ch) + 1; // jump window start past the earlier duplicate
    }
    lastSeen.set(ch, right);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}
lengthOfLongestSubstring('abcabcbb'); // 3 — "abc"

Because left only ever moves forward (never resets to 0), each character is visited by right once and by left at most once — giving linear time despite looking like a nested-loop problem at first glance.

Given an array of intervals [start, end], merge all overlapping intervals and return the result.

• Overlaps are only obvious once intervals are in order — so sort by start time first. This turns an all-pairs comparison problem into a single linear scan.
• Walk through sorted intervals keeping a "current merged interval." If the next interval's start is ≤ the current one's end, they overlap — extend the end. Otherwise, close out the current merged interval and start a new one.

function merge(intervals) {
  if (intervals.length <= 1) return intervals;
  intervals.sort((a, b) => a[0] - b[0]);   // sort by start

  const result = [intervals[0]];
  for (let i = 1; i < intervals.length; i++) {
    const last = result[result.length - 1];
    const curr = intervals[i];
    if (curr[0] <= last[1]) {
      last[1] = Math.max(last[1], curr[1]);  // overlap — extend in place
    } else {
      result.push(curr);                        // no overlap — new group
    }
  }
  return result;
}
merge([[1,3],[2,6],[8,10],[15,18]]);
// [[1,6],[8,10],[15,18]]

Math.max(last[1], curr[1]) matters — a later interval can be fully contained inside the current merged one (e.g. [1,10] then [2,4]), and blindly overwriting the end would incorrectly shrink the merged interval.

Design a Least-Recently-Used cache with a fixed capacity, supporting get(key) and put(key, value) in O(1), evicting the least-recently-used entry when full.

• The classic textbook answer is a hashmap + a manually-built doubly linked list (hashmap for O(1) lookup, linked list to track recency order in O(1)).
• JavaScript shortcut worth knowing: a Map's keys iterate in insertion order, by spec — so re-inserting a key (delete then set) moves it to the "most recent" end for free, and the first key in iteration order is always the least recently used one.

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity;
    this.map = new Map();
  }
  get(key) {
    if (!this.map.has(key)) return -1;
    const value = this.map.get(key);
    this.map.delete(key);
    this.map.set(key, value);   // re-insert → now the most-recently-used
    return value;
  }
  put(key, value) {
    if (this.map.has(key)) {
      this.map.delete(key);
    } else if (this.map.size >= this.capacity) {
      const lruKey = this.map.keys().next().value; // first = least recently used
      this.map.delete(lruKey);
    }
    this.map.set(key, value);
  }
}

Every operation here — Map.has, .get, .set, .delete, and reading the first key — is O(1), so the whole cache stays O(1) per operation without hand-rolling a linked list. In a language without an insertion-ordered map, you'd need the manual doubly-linked-list approach instead — good to say out loud so it's clear this is a JS-specific shortcut, not a universal trick.

Implement myPromiseAll(promises) that mirrors Promise.all: resolves with an array of all results (in the original order) once every promise fulfills, or rejects immediately with the reason of the first one that rejects.

• The function itself must return a Promise (§6.4) — everything happens inside a new Promise((resolve, reject) => ...) executor.
• Promises can settle in any order, but the result array must preserve the original order — so store each result at its own index i, not by push order.
• Keep a counter of how many have completed. Resolve the outer promise only when that counter reaches promises.length.
• Any single rejection should reject the whole thing immediately — don't wait for the others.
• Edge case: an empty input array should resolve immediately with [].

function myPromiseAll(promises) {
  return new Promise((resolve, reject) => {
    const results = new Array(promises.length);
    let completed = 0;

    if (promises.length === 0) return resolve(results);

    promises.forEach((p, i) => {
      Promise.resolve(p)               // handles plain (non-promise) values too
        .then(value => {
          results[i] = value;          // store at ORIGINAL index, not arrival order
          completed++;
          if (completed === promises.length) resolve(results);
        })
        .catch(reject);                // first rejection wins, immediately
    });
  });
}

The whole problem is really a state-machine over one shared completed counter and one shared results array, both captured in the executor's closure (§2.1) — every one of the promises.length parallel .then() callbacks writes into the same array and reads/increments the same counter. This is also a genuinely great way to cement §6.6: reimplementing all makes the difference from allSettled completely concrete — notice this version has no equivalent of "wait for every one to settle even on failure," which is exactly what allSettled would add.