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 - Simple Math Approach

Given an array of unique integers representing salaries, calculate the average after excluding the minimum and maximum values. Sum all salaries, subtract the min and max, then divide by n - 2.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1491.1 - Average Salary Excluding the Minimum and Maximum Salary - Solution 1 - Simple Math """

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

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

    def average(self, salary: List[int]) -> float:
        """Average Salary Function"""
        return (sum(salary) - min(salary) - max(salary)) / (len(salary) - 2)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().average([4000, 3000, 1000, 2000]))       # Expected: 2500.0
    print(Solution().average([1000, 2000, 3000]))              # Expected: 2000.0
    print(Solution().average([6000, 5000, 4000, 3000, 2000, 1000]))  # Expected: 3500.0
    print(Solution().average([8000, 9000, 2000, 3000, 6000, 1000]))  # Expected: 4750.0


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

Solution 2 - Single Pass with Tracking

Traverse the array once, keeping track of the running sum, minimum, and maximum. After the loop, subtract the min and max from the total sum and divide by n - 2. This avoids multiple passes over the array.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 1491.2 - Average Salary Excluding the Minimum and Maximum Salary - Solution 2 - Single Pass """

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

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

    def average(self, salary: List[int]) -> float:
        """Average Salary Function"""
        min_salary = float('inf')
        max_salary = float('-inf')
        total = 0

        for s in salary:
            total += s
            if s < min_salary:
                min_salary = s
            if s > max_salary:
                max_salary = s

        return (total - min_salary - max_salary) / (len(salary) - 2)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().average([4000, 3000, 1000, 2000]))       # Expected: 2500.0
    print(Solution().average([1000, 2000, 3000]))              # Expected: 2000.0
    print(Solution().average([6000, 5000, 4000, 3000, 2000, 1000]))  # Expected: 3500.0
    print(Solution().average([8000, 9000, 2000, 3000, 6000, 1000]))  # Expected: 4750.0


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

Solution 3 - Sort and Slice

Sort the array, then take the average of all elements except the first and last. This approach is simple and readable, though sorting adds an O(n log n) overhead.

TimeComplexity: O(n \log n)

SpaceComplexity: O(n)

""" 1491.3 - Average Salary Excluding the Minimum and Maximum Salary - Solution 3 - Sort and Slice """

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

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

    def average(self, salary: List[int]) -> float:
        """Average Salary Function"""
        salary.sort()
        trimmed = salary[1:-1]
        return sum(trimmed) / len(trimmed)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().average([4000, 3000, 1000, 2000]))       # Expected: 2500.0
    print(Solution().average([1000, 2000, 3000]))              # Expected: 2000.0
    print(Solution().average([6000, 5000, 4000, 3000, 2000, 1000]))  # Expected: 3500.0
    print(Solution().average([8000, 9000, 2000, 3000, 6000, 1000]))  # Expected: 4750.0


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

1491 - Average Salary Excluding the Minimum and Maximum Salary

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Simple Math Approach

Solution 2 - Single Pass with Tracking

Solution 3 - Sort and Slice

Solution 2 - Brute Force using `enumerate()`