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

Use a stack to iterate through the string. For each character, if the stack is non-empty and the top element equals the current character, pop the top (removing the adjacent duplicate). Otherwise, push the current character. At the end, join the stack into the result string.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 1047.1 - Remove All Adjacent Duplicates In String - Solution 1 - Stack Approach """

#####################################################################################
# Imports
#####################################################################################


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

    def removeDuplicates(self, s: str) -> str:
        """Remove All Adjacent Duplicates Function"""
        stack = []
        for char in s:
            if stack and stack[-1] == char:
                stack.pop()
            else:
                stack.append(char)
        return "".join(stack)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().removeDuplicates("abbaca"))    # Expected: "ca"
    print(Solution().removeDuplicates("azxxzy"))    # Expected: "ay"
    print(Solution().removeDuplicates("aababaab"))  # Expected: "ba"


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

Solution 2 - String as Stack Approach

Instead of using a list as a stack, build the result string directly. For each character, check if it matches the last character of the current result. If so, slice off the last character. Otherwise, append the current character. This avoids the final join step.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 1047.2 - Remove All Adjacent Duplicates In String - Solution 2 - String as Stack """

#####################################################################################
# Imports
#####################################################################################


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

    def removeDuplicates(self, s: str) -> str:
        """Remove All Adjacent Duplicates Function"""
        result = ""
        for char in s:
            if result and result[-1] == char:
                result = result[:-1]
            else:
                result += char
        return result


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().removeDuplicates("abbaca"))    # Expected: "ca"
    print(Solution().removeDuplicates("azxxzy"))    # Expected: "ay"
    print(Solution().removeDuplicates("aababaab"))  # Expected: "ba"


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

1047 - Remove All Adjacent Duplicates In String

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Stack Approach

Solution 2 - String as Stack Approach

Solution 2 - Brute Force using `enumerate()`