Leetcode Problem Statement: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

All the solutions provided below use the same approach. We initialize an empty dictionary or hash map to store the indices of the numbers we have seen so far.

We loop through the array and for each number, we calculate its complement (target – number) and check if the complement exists in our dictionary.

If it does, we return the indices of the current number and its complement. If not, we add the current number and its index to our dictionary and continue with the loop.

The time complexity of this algorithm is O(n) because we loop through the array only once. The space complexity is also O(n) because we need to store the indices of the numbers in the dictionary.Leetcode 463 Island Perimeter

Two sum Python solution

def twoSum(nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    dict = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in dict:
            return [dict[complement], i]
        dict[num] = i

The solution uses a dictionary (Python’s implementation of a hash map) to store the indices of the numbers we have seen so far. We initialize an empty dictionary with dict = {}.

We loop through the array nums using the enumerate function, which returns a tuple containing the index and value of each element in the array. The loop variable num contains the value of the current element, and i contains its index.

For each num, we calculate its complement complement = target - num. The complement is the value that we need to add to num to get the target sum.

See also  Longest Substring Without Repeating Characters

We check if the complement exists in our dictionary using the in keyword. If it does, we return the indices of the complement and the current element as a list.

If the complement does not exist in the dictionary, we add the current element and its index to the dictionary using dict[num] = i. This allows us to look up the index of a complement in constant time.

If we reach the end of the loop without finding a solution, we raise an exception with raise ValueError("No two sum solution").

The time complexity of this solution is O(n) because we loop through the array once, and each dictionary lookup takes constant time on average. The space complexity is also O(n) because we need to store the indices of the numbers in the dictionary.

Two sum Ruby solution

def two_sum(nums, target)
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    dict = {}
    nums.each_with_index do |num, i|
        complement = target - num
        if dict.key?(complement)
            return [dict[complement], i]
        dict[num] = i
    end
end

The Ruby solution is similar to the Python solution, but it uses the each_with_index method to loop through the array. This method calls the given block with two arguments: the element and its index.

Inside the loop, we calculate the complement complement = target - num and check if it exists in our dictionary using the key? method. If it does, we return the indices of the complement and the current element as an array.

If the complement does not exist in the dictionary, we add the current element and its index to the dictionary using dict[num] = i.

The time complexity of this solution is O(n) because we loop through the array once, and each dictionary lookup takes constant time on average. The space complexity is also O(n) because we need to store the indices of the numbers in the dictionary.

See also  String to Integer (atoi)

Two sum Java solution

class Solution {
    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 Java solution is similar to the Python and Ruby solutions, but it uses a Map (Java’s implementation of a hash map) instead of a dictionary. We initialize a Map using Map<Integer, Integer> map = new HashMap<>().

We loop through the array using a for loop and calculate the complement complement = target - nums[i]. We check if the complement exists in our Map using the containsKey method. If it does, we return the indices of the complement and the current element as an array.

If the complement does not exist in the Map, we add the current element and its index to the Map using map.put(nums[i], i).

If we reach the end of the loop without finding a solution, we raise an exception with throw new IllegalArgumentException("No two sum solution").

The time complexity of this solution is O(n) because we loop through the array once, and each Map lookup takes constant time on average. The space complexity is also O(n) because we need to store the indices of the numbers in the Map.

Two sum JavaScript solution

function twoSum(nums, target) {
    const map = new Map();
    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (map.has(complement)) {
            return [map.get(complement), i];
        }
        map.set(nums[i], i);
    }
    throw new Error('No two sum solution');
}

The JavaScript solution is similar to the Python, Ruby, and Java solutions, but it uses a Map instead of a dictionary or hash map. We initialize a Map using const map = new Map().

We loop through the array using a for loop and calculate the complement const complement = target - nums[i]. We check if the complement exists in our Map using the has method. If it does, we return the indices of the complement and the current element as an array.

See also  How to combine two column matrices in Python

If the complement does not exist in the Map, we add the current element and its index to the Map using map.set(nums[i], i).

If we reach the end of the loop without finding a solution, we raise an exception with throw new Error("No two sum solution").

The time complexity of this solution is O(n) because we loop through the array once, and each Map lookup takes constant time on average. The space complexity is also O(n) because we need to store the indices of the numbers in the Map.

Written by

With 10+ years in software engineering, I specialize in blogging and web development. My skills span front-end, back-end, database design, web security, and SEO. Passionate about crafting helpful digital experiences.