**Output**:`[0,1]`

**Explanation**: Because nums[0] + nums[1] == 9, we return[0, 1].

**Explanation**:

Because nums[0] + nums[1] == 9, we return[0, 1].

Hint 1

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations.

<details>

<summary>Hint 1</summary>

A really brute force way would be to search for all possible pairs of numbers but that would be too slow. Again, it's best to try out brute force solutions for just for completeness. It is from these brute force solutions that you can come up with optimizations.

Hint 2

</details>

So, if we fix one of the numbers, say`x`, we have to scan the entire array to find the next number`y` which is`value - x` where value is the input parameter. Can we change our array somehow so that this search becomes faster?

<details>

<summary>Hint 2</summary>

So, if we fix one of the numbers, say`x`, we have to scan the entire array to find the next number`y` which is`value - x` where value is the input parameter. Can we change our array somehow so that this search becomes faster?

</details>

Hint 3

<details>

<summary>Hint 3</summary>

The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

The second train of thought is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?

</details>

1. The time complexity of the brute force solution is`O(n**2)`. To improve efficiency, you can sort the array, and then use**two pointers**, one pointing to the head of the array and the other pointing to the tail of the array, and decide`left += 1` or`right -= 1` according to the comparison of`sum` and`target`.

2. After sorting an array of numbers, if you want to know the original`index` corresponding to a certain value, there are two solutions:

- Solution 1: Bring the`index` when sorting, that is, the object to be sorted is an array of tuples of`(num, index)`. This technique**must be mastered**, as it will be used in many questions.

- Solution 2: Use`index()` method to find it. I have discussed this in another solution.

<details><summary>Click to view the answer</summary><p>

</p></details>

while left< right:

sum_= num_index_list[left][0]+ num_index_list[right][0]

if sum_== target:

return [num_index_list[left][1], num_index_list[right][1]]

1. In`Map`,`key` is`num`, and`value` is array`index`.

let numToIndex=newMap()

for (let i=0; i<nums.length; i++) {

numToIndex.set(nums[i], i)

}

let numToIndex=newMap()

for (let i=0; i<nums.length; i++) {

numToIndex.set(nums[i], i)

}

```

2. Traverse the array,if`target - num` isin`Map`,returnit.Otherwise, add`num` to`Map`.

let numToIndex=newMap()

for (let i=0; i<nums.length; i++) {

if (numToIndex.has(target- nums[i])) {// 1

return [numToIndex.get(target- nums[i]), i]// 2

}

numToIndex.set(nums[i], i)

}

## Complexity

##C++

## Intuition3

1. The time complexityof the brute force solution is`O(n^2)`.To improve efficiency, you can sort the array, and then use**two pointers**, one pointing to the headof the array and the other pointing to the tailof the array, and decide`left += 1` or`right -= 1` according to the comparisonof`sum` and`target`.

2. After finding the two values which`sum` is`target`, you can use the`index()` method to find the`index` corresponding to the value.

## Complexity