#1 - Two Sum

EasyArray / String

Given an array of integers nums and a target integer target, return the indices of two numbers in the array that add up to target. You may assume each input has exactly one solution, and you cannot use the same element twice.

Input	Output
nums = [2,7,11,15], target = 9	[0,1]
nums = [3,2,4], target = 6	[1,2]
nums = [3,3], target = 6	[0,1]

Solution Space

Try it

/**
 * Returns indices of two numbers that add up to target.
 *
 * @param nums   Array of integers (may contain duplicates)
 * @param target Target sum
 * @returns      Two indices i, j such that nums[i] + nums[j] === target
 */
export function twoSum(nums: number[], target: number): [number, number] {
  // Map from value to its index in the array
  const seen = new Map<number, number>();

  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];

    // If we already saw the complement, we have a solution.
    if (seen.has(complement)) {
      return [seen.get(complement)!, i];
    }

    // Store it for future look-ups
    seen.set(nums[i], i);
  }

  // Problem guarantees exactly one solution; this line is just for type safety.
  throw new Error("No two sum solution found");
}

Approach: hash-map – store the complement of each element in a map and check if it exists in the map.

Time: O(n) – one pass through the array.

Space: O(n) – worst-case we store every element in the map.

Alternative approaches:

Approach	Idea	Time	Space
Brute force	Check all pairs i < j	O(n²)	O(1)
Two-pointer after sorting	Sort a copy, then use two indices moving inward	O(n log n)	O(n) for original indices

Why the hash-map method is preferred:

• It uses linear time, which is optimal for this problem.
• It preserves original indices without needing a sorted copy.

No previous problem

#3 Longest Substring Without Repeating Characters