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 timeSeries array. For each consecutive pair of attacks, add the minimum of the gap between attacks and the duration to the total poisoned time. Add duration for the last attack since it always runs its full course.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 0495.1 - Teemo Attacking - Solution 1 - Linear Scan """

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

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

    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
        """Find Poisoned Duration Function"""
        if not timeSeries:
            return 0

        total = 0
        for i in range(len(timeSeries) - 1):
            gap = timeSeries[i + 1] - timeSeries[i]
            total += min(gap, duration)
        total += duration  # last attack always lasts full duration
        return total


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().findPoisonedDuration([1, 4], 2))        # Expected: 4
    print(Solution().findPoisonedDuration([1, 2], 2))        # Expected: 3
    print(Solution().findPoisonedDuration([1, 2, 3, 4, 5], 5))  # Expected: 9


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

Solution 2 - Linear Scan using `zip()`

Same linear scan logic, but uses Python's zip() to pair consecutive attacks for a cleaner iteration pattern. For each pair, the poisoned time contributed is min(next - curr, duration).

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 0495.2 - Teemo Attacking - Solution 2 - Linear Scan using zip() """

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

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

    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
        """Find Poisoned Duration Function"""
        if not timeSeries:
            return 0

        total = 0
        for curr, nxt in zip(timeSeries, timeSeries[1:]):
            total += min(nxt - curr, duration)
        total += duration  # last attack always lasts full duration
        return total


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().findPoisonedDuration([1, 4], 2))        # Expected: 4
    print(Solution().findPoisonedDuration([1, 2], 2))        # Expected: 3
    print(Solution().findPoisonedDuration([1, 2, 3, 4, 5], 5))  # Expected: 9


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

0495 - Teemo Attacking

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Linear Scan

Solution 2 - Linear Scan using zip()

Solution 2 - Brute Force using `enumerate()`

Solution 2 - Linear Scan using `zip()`