Two Sum

Start dumb: try every pair

Two indices whose values sum to target — the honest first idea is the double loop: for every i, scan every j > i and test the sum. That’s O(n²), and on LeetCode’s 10⁴ elements it’s fifty million useless comparisons for one pair.

Find the bottleneck

Watch what the inner loop actually does: given nums[i], it searches for one specific value. Because the pair must sum to target, the second number is fully determined the moment you see the first — it must be target − nums[i]. The brute force spends O(n) hunting for a value it could have looked up by name.

The optimal shape

1. Compute the complement target − nums[i].
2. Look it up in the map — a hit means the pair is complete; return the remembered index and the current one.
3. Miss → record nums[i] → i and move on.

The lookup happens before the insert on every iteration — that ordering is load-bearing (see the trap below). In the player, the map in the state pane grows left to right; the hit lights up both partners.

Watch it think

Run the default, then the traps: the self-pair case (3,2,4 | 6), duplicates that legitimately pair (3,3 | 6), negatives (-3,4,90 | 1), and a target no pair can reach (1,2,3 | 7).

1fun twoSum(nums: IntArray, target: Int): IntArray {
2    val seen = HashMap<Int, Int>()
3    for (i in nums.indices) {
4        val complement = target - nums[i]
5        val j = seen[complement]
6        if (j != null) return intArrayOf(j, i)
7        seen[nums[i]] = i
8    }
9    return intArrayOf()
10}