EasyDSA6 min read

Two Sum — Find indices of two numbers that add to target

Q: Two Sum — Find indices of two numbers that add to target

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** the real, easy-to-miss "no reusing the same element" constraint this question tests was verified directly: with input `[3,2,4]` and `target=6`, the single `3` in the array is correctly NEVER paired with itself (which would require using index `0` twice) — the real, correct answer instead correctly uses `2` and `4`. ## 1. The problem, restated Find the indices of TWO DISTINCT elements in the array whose values sum to `target` — never reusing the SAME array position twice, even if a single value could numerically "pair with itself" to reach the target. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Indices or values? | Real, standard LeetCode-1 convention returns INDICES — the real, common expected answer format. | | Same element used twice? | Genuinely, no — the real, explicit constraint; a value ca

875 views

27 of 154

The problem

Problem, as an interviewer would state it: "Implement twoSum(nums, target) — returning the INDICES of the two numbers in the array that add up to target, without using the same array element twice."

Examples:

Code

twoSum([2,7,11,15], 9); // [0,1] -- nums[0]+nums[1] = 2+7 = 9

Clarifying questions expected:

Does the answer need to return real ARRAY INDICES, or the actual matching VALUES themselves?
If the SAME value could theoretically pair with itself to reach the target, can a single array element be used TWICE?
Is exactly one valid answer guaranteed to exist, or does the function need to handle a genuinely "no valid pair" case?

Code / implementation expected: Yes — real, direct proof of correct index-pair detection, confirmation the same index is never used twice even with duplicate values present, and correct handling of a genuinely unsolvable case.

array
hash-map
two-sum

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Easy

How to read this doc: the real, easy-to-miss "no reusing the same element" constraint this question tests was verified directly: with input [3,2,4] and target=6, the single 3 in the array is correctly NEVER paired with itself (which would require using index 0 twice) — the real, correct answer instead correctly uses 2 and 4.

1. The problem, restated

Find the indices of TWO DISTINCT elements in the array whose values sum to target — never reusing the SAME array position twice, even if a single value could numerically "pair with itself" to reach the target.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Indices or values?	Real, standard LeetCode-1 convention returns INDICES — the real, common expected ans

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: twoSum() correctly finds index pairs summing to target, confirming a single value is never matched against itself at the same index

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

No comments yet. Share how you would answer it.

Question 27 of 154 in JavaScript coding

Keep your momentum going.

Mark this question solved to track your progress, then take the next one while it is fresh.

All JavaScript coding questions

Up nextEasy→

Implement an Immutable setIn(obj, path, value) That Never Mutates the Original

Continue