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 (Compute Actual Product)

Multiply all elements together to get the actual product, then check its sign. Simple but risks integer overflow for large arrays (not an issue in Python due to arbitrary precision integers).

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1822.1 - Solution 1 - Brute Force (Compute Actual Product) """

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

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

    def arraySign(self, nums: List[int]) -> int:
        """Array Sign Function"""
        product = 1
        for num in nums:
            product *= num
        if product > 0:
            return 1
        elif product < 0:
            return -1
        else:
            return 0


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().arraySign([-1, -2, -3, -4, 3, 2, 1]))  # 1
    print(Solution().arraySign([1, 5, 0, 2, -3]))            # 0
    print(Solution().arraySign([-1, 1, -1, 1, -1]))          # -1


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

Solution 2 - Count Negatives (Optimal)

Instead of computing the actual product, just track the sign. If any element is zero, return 0 immediately. Otherwise, count the number of negative numbers — if the count is odd the product is negative, if even the product is positive.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1822.2 - Solution 2 - Count Negatives """

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

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

    def arraySign(self, nums: List[int]) -> int:
        """Array Sign Function"""
        negative_count = 0
        for num in nums:
            if num == 0:
                return 0
            if num < 0:
                negative_count += 1
        return -1 if negative_count % 2 == 1 else 1


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().arraySign([-1, -2, -3, -4, 3, 2, 1]))  # 1
    print(Solution().arraySign([1, 5, 0, 2, -3]))            # 0
    print(Solution().arraySign([-1, 1, -1, 1, -1]))          # -1


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

Solution 3 - Sign Flip (Optimal, Concise)

Track the sign directly by flipping it each time a negative number is encountered. Return 0 immediately if a zero is found. This avoids both the actual product computation and the modulo check.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1822.3 - Solution 3 - Sign Flip """

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

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

    def arraySign(self, nums: List[int]) -> int:
        """Array Sign Function"""
        sign = 1
        for num in nums:
            if num == 0:
                return 0
            if num < 0:
                sign *= -1
        return sign


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().arraySign([-1, -2, -3, -4, 3, 2, 1]))  # 1
    print(Solution().arraySign([1, 5, 0, 2, -3]))            # 0
    print(Solution().arraySign([-1, 1, -1, 1, -1]))          # -1


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

1822 - Sign of the Product of an Array

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Brute Force (Compute Actual Product)

Solution 2 - Count Negatives (Optimal)

Solution 3 - Sign Flip (Optimal, Concise)

Solution 2 - Brute Force using `enumerate()`