Examples
**Example 1:**
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 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]
#### Code
```java
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] result = new int[2];
for (int index = 0; index < nums.length; index++) {
for (int innerIndex = 0; innerIndex < nums.length; innerIndex++) {
if (index != innerIndex && (nums[index] + nums[innerIndex] == target)) {
result[0] = index;
result[1] = innerIndex;
return result;
}
}
}
return result;
}
}
```
* An integer array named `result` is initialized with a size of 2. This array will eventually hold the indices of the two numbers that sum to the target.
* The method uses a nested loop to iterate through the `nums` array:
* The outer loop (`index`) goes through each element of the array.
* The inner loop (`innerIndex`) also goes through the entire array.
* Inside the inner loop, the code checks two conditions:
* `index != innerIndex`: Ensures that the same element is not used twice.
* `(nums[index] + nums[innerIndex] == target)`: Checks if the sum of the two elements at the current indices equals the `target`.
* If a valid pair is found, the indices of these elements are stored in the `result` array. The method then immediately returns the `result` array, exiting the method.
* If the loops complete without finding any valid pairs, the method returns the `result` array, which would contain the default values (both indices as `0`), since it was initialized with no specific values.
{% hint style="info" %}
This approach uses a brute-force method with a nested loop to check every possible pair of elements in the `nums` array to see if they sum to the `target`.
{% endhint %}
The above solution when executed took 119ms of time to be executed. While this is straightforward, it has a time complexity of O(n²), where n is the length of the `nums` array. This means it can be inefficient for large arrays. To enhance efficiency, a more optimal solution can be achieved using a `HashMap`, allowing for a time complexity of O(n). The `HashMap` would store each number and its index, allowing the program to find the complement of the current number (i.e., `target - nums[index]`) in constant time.