Solution 1 - Brute Force

Iterate through every pair of numbers using two nested loops. For each pair, check if they sum to the target. Return the indices when a match is found.

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Brute Force Approach """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Brute Force using `enumerate()`

Same brute force logic, but uses Python's enumerate() for cleaner index tracking instead of range(len(...)).

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Using Enumerate """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for key1, num1 in enumerate(nums):
            for key2, num2 in enumerate(nums[key1 + 1 :], key1 + 1):
	              # enumerate(iterable, start=1) -> start value determines starting index
                # Printing value and key will output 1 i , 2 j, 3 k, 4 l 
                if num1 + num2 == target:
                    return [key1, key2]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 1 - Brute Force

For each element in the array, check every other element to see if one is double the other. This uses two nested loops to compare all pairs.

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 1346.1 - Check If N and Its Double Exist - Solution 1 - Brute Force """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def checkIfExist(self, arr: List[int]) -> bool:
        """Check If N and Its Double Exist Function"""
        for i in range(len(arr)):
            for j in range(len(arr)):
                if i != j and arr[i] == 2 * arr[j]:
                    return True
        return False


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().checkIfExist([10, 2, 5, 3]))       # True
    print(Solution().checkIfExist([3, 1, 7, 11]))        # False
    print(Solution().checkIfExist([7, 1, 14, 11]))       # True
    print(Solution().checkIfExist([0, 0]))                # True
    print(Solution().checkIfExist([-2, 0, 10, -19, 4, 6, -8]))  # False


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Hash Set (One Pass)

As we iterate through the array, for each number we check if its double or its half (when even) already exists in the set. If found, return True. Otherwise, add the current number to the set and continue.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 1346.2 - Check If N and Its Double Exist - Solution 2 - Hash Set (One Pass) """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def checkIfExist(self, arr: List[int]) -> bool:
        """Check If N and Its Double Exist Function"""
        seen = set()
        for num in arr:
            if 2 * num in seen or (num % 2 == 0 and num // 2 in seen):
                return True
            seen.add(num)
        return False


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().checkIfExist([10, 2, 5, 3]))       # True
    print(Solution().checkIfExist([3, 1, 7, 11]))        # False
    print(Solution().checkIfExist([7, 1, 14, 11]))       # True
    print(Solution().checkIfExist([0, 0]))                # True
    print(Solution().checkIfExist([-2, 0, 10, -19, 4, 6, -8]))  # False


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 3 - Sorting + Binary Search

Sort the array first, then for each element, use binary search to look for its double. Special care is needed to avoid matching the element with itself (e.g., when the value is 0).

TimeComplexity: O(n \log n)

SpaceComplexity: O(1)

""" 1346.3 - Check If N and Its Double Exist - Solution 3 - Sorting + Binary Search """

#####################################################################################
# Imports
#####################################################################################
from typing import List
import bisect

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def checkIfExist(self, arr: List[int]) -> bool:
        """Check If N and Its Double Exist Function"""
        arr.sort()
        for i, num in enumerate(arr):
            target = 2 * num
            j = bisect.bisect_left(arr, target)
            if j < len(arr) and arr[j] == target and j != i:
                return True
        return False


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().checkIfExist([10, 2, 5, 3]))       # True
    print(Solution().checkIfExist([3, 1, 7, 11]))        # False
    print(Solution().checkIfExist([7, 1, 14, 11]))       # True
    print(Solution().checkIfExist([0, 0]))                # True
    print(Solution().checkIfExist([-2, 0, 10, -19, 4, 6, -8]))  # False


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

1346 - Check If N and Its Double Exist

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Brute Force

Solution 2 - Hash Set (One Pass)

Solution 3 - Sorting + Binary Search

Solution 2 - Brute Force using `enumerate()`