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 - One-Pass Scan

Traverse the array while tracking the length of the current continuous increasing subsequence. If the current element is greater than the previous one, increment the counter. Otherwise, reset it to 1. Track the maximum length seen so far.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 0674.1 - Longest Continuous Increasing Subsequence - Solution 1 - One-Pass Scan """

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

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

    def findLengthOfLCIS(self, nums: List[int]) -> int:
        """Find Length of Longest Continuous Increasing Subsequence"""
        if not nums:
            return 0

        ans = 1
        cnt = 1

        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:
                cnt += 1
                ans = max(ans, cnt)
            else:
                cnt = 1

        return ans


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


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

Solution 2 - Sliding Window / Two Pointer

Use a left pointer to mark the start of the current increasing window. Move the right pointer forward. When the sequence breaks, update the left pointer to the current position. Track the maximum window size.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 0674.2 - Longest Continuous Increasing Subsequence - Solution 2 - Sliding Window """

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

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

    def findLengthOfLCIS(self, nums: List[int]) -> int:
        """Find Length of Longest Continuous Increasing Subsequence"""
        if not nums:
            return 0

        ans = 1
        left = 0

        for right in range(1, len(nums)):
            if nums[right] <= nums[right - 1]:
                left = right
            ans = max(ans, right - left + 1)

        return ans


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


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

0674 - Longest Continuous Increasing Subsequence

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - One-Pass Scan

Solution 2 - Sliding Window / Two Pointer

Solution 2 - Brute Force using `enumerate()`