# Target Two Sum

**Given an array of unsorted unique integers, write a function getTargetIndexes that returns an array of arrays of the index pairs for each of the two numbers that add up to the target.**

- Prioritize run time complexity over memory
- An item can not match with itself
- The same pair of indexes should only be included once
- The order of the returned array and its items does not matter

` `

## Breakdown

Table of Contents

### Validate My Answer

You can do this brute force, but it will be the worse solution at

*O(n*time.^{2})Keep the constraints in mind. You don't have to worry about duplicate values in the array.

By adding another data structure, you can do this in

*O(n)*time and*O(n)*space.Remember you can't add a number to itself (ie. the solution is the same index twice). However, you can add a number to zero. For example,

`array = [4,8,0]`

,`target = 8`

: You can't say`[0,0]`

for`4+4`

, but you can say`[1,2]`

for`8+0`

.Does your solution handle negative numbers?

Does your solution handle an empty array input?

Make sure your solution doesn't include repeated indexes. For example, if you already have

`[1,4]`

in your results, you shouldn't also have`[4,1]`

. However, having either one of those is acceptable based on the constraints.

Table of Contents

Test Results

Run your code and see results here...

### Target Two Sum

**Given an array of unsorted unique integers, write a function getTargetIndexes that returns an array of arrays of the index pairs for each of the two numbers that add up to the target.**

- Prioritize run time complexity over memory
- An item can not match with itself
- The same pair of indexes should only be included once
- The order of the returned array and its items does not matter

` `