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 - Sorted Merge (Built-in)

Replace the placeholder zeros in nums1 with elements from nums2, then sort the entire array. This is the simplest approach but doesn't take advantage of the fact that both arrays are already sorted.

TimeComplexity: O((m+n) \log(m+n))

SpaceComplexity: O(1)

""" 0088.1 - Merge Sorted Array - Solution 1 - Sorted Merge (Built-in) """

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

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

    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """Merge Sorted Array Function"""
        for i in range(n):
            nums1[m + i] = nums2[i]
        nums1.sort()


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    nums1 = [1, 2, 3, 0, 0, 0]
    Solution().merge(nums1, 3, [2, 5, 6], 3)
    print(nums1)  # [1, 2, 2, 3, 5, 6]

    nums1 = [1]
    Solution().merge(nums1, 1, [], 0)
    print(nums1)  # [1]

    nums1 = [0]
    Solution().merge(nums1, 0, [1], 1)
    print(nums1)  # [1]


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

Solution 2 - Three Pointers (Merge from the End)

Use three pointers starting from the end of both arrays and the end of nums1. Compare elements from the back of nums1 and nums2, placing the larger one at the current position in nums1. This merges in-place without needing extra space, taking advantage of the extra room at the end of nums1.

TimeComplexity: O(m+n)

SpaceComplexity: O(1)

""" 0088.2 - Merge Sorted Array - Solution 2 - Three Pointers (Merge from End) """

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

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

    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """Merge Sorted Array Function"""
        i = m - 1      # Pointer for nums1's valid elements
        j = n - 1      # Pointer for nums2
        k = m + n - 1  # Pointer for the end of nums1

        while j >= 0:
            if i >= 0 and nums1[i] > nums2[j]:
                nums1[k] = nums1[i]
                i -= 1
            else:
                nums1[k] = nums2[j]
                j -= 1
            k -= 1


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    nums1 = [1, 2, 3, 0, 0, 0]
    Solution().merge(nums1, 3, [2, 5, 6], 3)
    print(nums1)  # [1, 2, 2, 3, 5, 6]

    nums1 = [1]
    Solution().merge(nums1, 1, [], 0)
    print(nums1)  # [1]

    nums1 = [0]
    Solution().merge(nums1, 0, [1], 1)
    print(nums1)  # [1]


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

0088 - Merge Sorted Array

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Sorted Merge (Built-in)

Solution 2 - Three Pointers (Merge from the End)

Solution 2 - Brute Force using `enumerate()`