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 - Linear Scan

Iterate through the array and count the number of positive and negative integers separately. Return the maximum of the two counts. Zero is neither positive nor negative, so it is skipped.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 2529.1 - Maximum Count of Positive Integer and Negative Integer - Solution 1 - Linear Scan """

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

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

    def maximumCount(self, nums: List[int]) -> int:
        """Maximum Count Function"""
        pos = 0
        neg = 0
        for num in nums:
            if num > 0:
                pos += 1
            elif num < 0:
                neg += 1
        return max(pos, neg)


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


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

Solution 2 - Binary Search

Since the array is sorted in non-decreasing order, use binary search to find the count of negatives (index of first element >= 0) and the count of positives (n minus the index of first element > 0). This leverages bisect_left and bisect_right for efficient boundary detection.

TimeComplexity: O(\log n)

SpaceComplexity: O(1)

""" 2529.2 - Maximum Count of Positive Integer and Negative Integer - Solution 2 - Binary Search """

#####################################################################################
# Imports
#####################################################################################
from typing import List
from bisect import bisect_left, bisect_right

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

    def maximumCount(self, nums: List[int]) -> int:
        """Maximum Count Function"""
        # Number of negatives = index of first element >= 0
        neg = bisect_left(nums, 0)
        # Number of positives = n - index of first element > 0
        pos = len(nums) - bisect_right(nums, 0)
        return max(pos, neg)


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


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

2529 - Maximum Count of Positive Integer and Negative Integer

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Linear Scan

Solution 2 - Binary Search

Solution 2 - Brute Force using `enumerate()`