Given an array of integers `nums`

and an integer `target`

, return *indices of the two numbers such that they add up to target*.

You may assume that each input would have ** exactly one solution**, and you may not use the

You can return the answer in any order.

**Example 1:**

Input:nums = [2,7,11,15], target = 9Output:[0,1]Output:Because nums[0] + nums[1] == 9, we return [0, 1].

**Example 2:**

Input:nums = [3,2,4], target = 6Output:[1,2]

**Example 3:**

Input:nums = [3,3], target = 6Output:[0,1]

**Constraints:**

`2 <= nums.length <= 10`

^{4}`-10`

^{9}<= nums[i] <= 10^{9}`-10`

^{9}<= target <= 10^{9}**Only one valid answer exists.**

**Follow-up: **Can you come up with an algorithm that is less than `O(n`

time complexity?^{2})

vector<int> twoSum(vector<int> &numbers, int target)
{
//Key is the number and value is its index in the vector.
unordered_map<int, int> hash;
vector<int> result;
for (int i = 0; i < numbers.size(); i++) {
int numberToFind = target - numbers[i];
//if numberToFind is found in map, return them
if (hash.find(numberToFind) != hash.end()) {
//+1 because indices are NOT zero based
result.push_back(hash[numberToFind] + 1);
result.push_back(i + 1);
return result;
}
//number was not found. Put it in the map.
hash[numbers[i]] = i;
}
return result;
}

An efficient way to solve this question would be to use a HashMap (Extra Space) and Keep iterating through each item of the list and check if the desired number ( difference of target and current number ) is already visited in the array, If it is already visited then we have got the answer, just return it. Otherwise, if no such combination is found then return an empty array.

Time Complexity: O(n) // To traverse through each element in the array.

Space Complexity: O(n) //To keep visited items of the array in Map, in the worst case we will end up adding all elements of the array in the Map.