Possible Two Sum - Java

Possible Two Sum is a common interview question where we are given an array of integers and a target sum. The task is to find any two integers in the array that sum up to the target value. In this tutorial, we will discuss different approaches to solve this problem in Java.

Brute Force Approach

The naïve approach to solve this problem is to use two nested loops to compare all possible combinations of integers in the array. The time complexity of this approach is O(n^2), which is not efficient for large-sized arrays.

public int[] twoSum(int[] nums, int target) {
    int[] result = new int[2];
    for(int i=0; i<nums.length; i++){
        for(int j=i+1; j<nums.length; j++){
            if(nums[i]+nums[j]==target){
                result[0] = i;
                result[1] = j;
            }
        }
    }
    return result;
}

HashMap Approach

We can optimize the brute force approach by using a HashMap to store the indices of the integers in the array. The idea is to traverse the array and check if the complement of the current element exists in the HashMap. If it exists, then we have found the two integers that sum up to the target value.

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for(int i=0; i<nums.length; i++){
        int complement = target - nums[i];
        if(map.containsKey(complement)){
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

The time complexity of the HashMap approach is O(n) because we are using a single loop to traverse the array, and constant time to check the existence of the complement in the HashMap.

Conclusion

In this tutorial, we have discussed two approaches to solve the Possible Two Sum problem in Java. The HashMap approach is more efficient than the brute force approach in terms of time complexity. However, both approaches have their own advantages and limitations, and the choice depends upon the specific problem requirements and constraints.