# GeetCode Hub

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 same element twice.

You can return the answer in any order.

Example 1:

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

Example 2:

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

Example 3:

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

Constraints:

• `2 <= nums.length <= 104`
• `-109 <= nums[i] <= 109`
• `-109 <= target <= 109`
• Only one valid answer exists.

Follow-up: Can you come up with an algorithm that is less than `O(n2) `time complexity?

public int[] twoSum(int[] nums, int target) { Map<Integer, Integer> map = new HashMap<Integer, Integer>(); int len = nums.length; for(int i=0;i<len; i++){ int diff = target - nums[i]; if(map.containsKey(diff)){ return new int[]{map.get(diff), i}; } map.put(nums[i],i); } return new int[]{}; }

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.