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 - Counter Approach

Given a string text, count how many times we can form the word "balloon". The word "balloon" requires: 1× 'b', 1× 'a', 2× 'l', 2× 'o', 1× 'n'. Count the frequency of each character in the input, then for each character in "balloon", compute how many times its requirement can be satisfied. The answer is the minimum across all characters.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1189.1 - Maximum Number of Balloons - Solution 1 - Counter Approach """

#####################################################################################
# Imports
#####################################################################################
from collections import Counter

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

    def maxNumberOfBalloons(self, text: str) -> int:
        """Maximum Number of Balloons Function"""
        count_text = Counter(text)
        balloon = Counter("balloon")

        res = len(text)
        for c in balloon:
            res = min(res, count_text[c] // balloon[c])
        return res


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().maxNumberOfBalloons("nlaebolko"))       # 1
    print(Solution().maxNumberOfBalloons("loonbalxballpoon")) # 2
    print(Solution().maxNumberOfBalloons("leetcode"))         # 0


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

Solution 2 - Manual Character Count

Instead of using Counter, manually count only the five relevant characters ('b', 'a', 'l', 'o', 'n') as we iterate through the string. Then divide 'l' and 'o' counts by 2 (since "balloon" needs two of each) and return the minimum.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1189.2 - Maximum Number of Balloons - Solution 2 - Manual Character Count """

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

    def maxNumberOfBalloons(self, text: str) -> int:
        """Maximum Number of Balloons Function"""
        count_b = 0
        count_a = 0
        count_l = 0
        count_o = 0
        count_n = 0

        for c in text:
            if c == 'b':
                count_b += 1
            elif c == 'a':
                count_a += 1
            elif c == 'l':
                count_l += 1
            elif c == 'o':
                count_o += 1
            elif c == 'n':
                count_n += 1

        return min(count_b, count_a, count_l // 2, count_o // 2, count_n)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().maxNumberOfBalloons("nlaebolko"))       # 1
    print(Solution().maxNumberOfBalloons("loonbalxballpoon")) # 2
    print(Solution().maxNumberOfBalloons("leetcode"))         # 0


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

1189 - Maximum Number of Balloons

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Counter Approach

Solution 2 - Manual Character Count

Solution 2 - Brute Force using `enumerate()`