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 - Direct Comparison

The tree has exactly 3 nodes: the root, its left child, and its right child. We simply check whether the root's value equals the sum of its two children's values. This is a straightforward one-line comparison.

TimeComplexity: O(1)

SpaceComplexity: O(1)

""" 2236.1 - Root Equals Sum of Children - Solution 1 - Direct Comparison """

#####################################################################################
# Imports
#####################################################################################
from typing import Optional

#####################################################################################
# Classes
#####################################################################################
class TreeNode:
    """Definition for a binary tree node."""
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """Solution Class"""

    def checkTree(self, root: Optional[TreeNode]) -> bool:
        """Check if root value equals the sum of its two children."""
        return root.val == root.left.val + root.right.val


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    # Example 1: root = [10, 4, 6] -> True
    root1 = TreeNode(10, TreeNode(4), TreeNode(6))
    print(Solution().checkTree(root1))  # True

    # Example 2: root = [5, 3, 1] -> False
    root2 = TreeNode(5, TreeNode(3), TreeNode(1))
    print(Solution().checkTree(root2))  # False


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

Solution 2 - Using Subtraction

Instead of checking equality of the sum, we subtract both children from the root and check if the result is zero. Logically equivalent but demonstrates an alternative way to frame the comparison.

TimeComplexity: O(1)

SpaceComplexity: O(1)

""" 2236.2 - Root Equals Sum of Children - Solution 2 - Using Subtraction """

#####################################################################################
# Imports
#####################################################################################
from typing import Optional

#####################################################################################
# Classes
#####################################################################################
class TreeNode:
    """Definition for a binary tree node."""
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """Solution Class"""

    def checkTree(self, root: Optional[TreeNode]) -> bool:
        """Check if root value equals the sum of its two children using subtraction."""
        return root.val - root.left.val - root.right.val == 0


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    # Example 1: root = [10, 4, 6] -> True
    root1 = TreeNode(10, TreeNode(4), TreeNode(6))
    print(Solution().checkTree(root1))  # True

    # Example 2: root = [5, 3, 1] -> False
    root2 = TreeNode(5, TreeNode(3), TreeNode(1))
    print(Solution().checkTree(root2))  # False


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

2236 - Root Equals Sum of Children

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Direct Comparison

Solution 2 - Using Subtraction

Solution 2 - Brute Force using `enumerate()`