Arrays Pattern Guide for LeetCode

1. Core Array Patterns

Template 1: Two Pointers

def two_pointers_template(arr):
    left, right = 0, len(arr) - 1

    while left < right:
        # Process array elements
        if CONDITION:
            left += 1
        else:
            right -= 1
    return result

# Variation: Fast and Slow Pointers
def fast_slow_template(arr):
    slow = fast = 0
    while fast < len(arr):
        # Process array elements
        slow += 1
        fast += 2

Template 2: Sliding Window

def sliding_window_template(arr):
    window = {}  # or other data structure
    left, right = 0, 0
    result = 0

    while right < len(arr):
        # Add element to window
        window[arr[right]] = window.get(arr[right], 0) + 1

        while WINDOW_CONDITION_BROKEN:
            # Remove element from window
            window[arr[left]] -= 1
            if window[arr[left]] == 0:
                del window[arr[left]]
            left += 1

        # Update result
        result = max(result, right - left + 1)
        right += 1

    return result

Template 3: Prefix Sum

def prefix_sum_template(arr):
    prefix = [0] * (len(arr) + 1)

    # Build prefix sum array
    for i in range(len(arr)):
        prefix[i + 1] = prefix[i] + arr[i]

    # Query range sum: sum of arr[i:j]
    def range_sum(i, j):
        return prefix[j] - prefix[i]

2. LeetCode Problem Categories

Category 1: Two Sum Type Problems

1. LeetCode 1: Two Sum

def twoSum(nums: List[int], target: int) -> List[int]:
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

1. LeetCode 15: 3Sum

def threeSum(nums: List[int]) -> List[List[int]]:
    nums.sort()
    result = []

    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i-1]:
            continue

        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < 0:
                left += 1
            elif total > 0:
                right -= 1
            else:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1

    return result

Category 2: Sliding Window Problems

1. LeetCode 3: Longest Substring Without Repeating Characters

def lengthOfLongestSubstring(s: str) -> int:
    chars = {}
    left = right = 0
    result = 0

    while right < len(s):
        if s[right] in chars:
            left = max(left, chars[s[right]] + 1)
        chars[s[right]] = right
        result = max(result, right - left + 1)
        right += 1

    return result

Category 3: Kadane's Algorithm Problems

1. LeetCode 53: Maximum Subarray

def maxSubArray(nums: List[int]) -> int:
    current_sum = max_sum = nums[0]

    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)

    return max_sum