🗺️ Array Patterns - The Complete Study Guide

Welcome

This is a structured, beginner-friendly study guide for mastering array and string patterns - the building blocks of coding interviews. Each pattern has a dedicated deep-dive document with theory, intuition, templates, and 10 LeetCode problems solved step by step.

Who is this for?

• You’re preparing for coding interviews and want a systematic approach
• You can solve easy problems but struggle to recognize which technique to apply
• You want to understand why an approach works, not just memorize solutions

How to use this guide:

1. Follow the patterns in order - they build on each other
2. Read the theory and templates first
3. Try each problem yourself for 15-20 minutes before reading the solution
4. If stuck, read only the approach section (not the code) and try again
5. After solving, read the dry run and edge cases to solidify understanding

The Patterns

Total: 90 problems across 9 patterns when complete.

How the Patterns Connect

These patterns don’t exist in isolation. Understanding how they relate helps you pick the right tool.

                        ┌──────────────┐
                        │  Two Pointers │
                        └──────┬───────┘
                               │
               ┌───────────────┼───────────────┐
               │               │               │
               ▼               ▼               ▼
      ┌────────────┐   ┌─────────────┐   ┌──────────────┐
      │  Binary     │   │  Sliding    │   │   Sorting    │
      │  Search     │   │  Window     │   │   Based      │
      └────────────┘   └──────┬──────┘   └──────┬───────┘
                               │                 │
                               │                 ▼
                               │          ┌──────────────┐
                               │          │  Intervals   │
                               │          └──────────────┘
                               ▼
                        ┌─────────────┐
                        │  Prefix Sum │
                        └──────┬──────┘
                               │
                               ▼
                        ┌─────────────┐
                        │  HashMap /  │
                        │  Frequency  │
                        └─────────────┘

         ┌──────────────┐          ┌─────────────────┐
         │   Kadane's   │          │  Monotonic Stack │
         │  Algorithm   │          │                  │
         └──────────────┘          └─────────────────┘
         (builds on prefix sum      (often combined with
          and sliding window)        sliding window)

Key relationships:

• Two Pointers → Binary Search: Binary search uses two pointers (low, high) that converge on an answer by halving the search space. It’s the “sorted array” specialization of two pointers.
• Two Pointers → Sliding Window: Sliding window is two same-direction pointers with a “window state” tracked between them.
• Sliding Window → Prefix Sum: Both avoid recomputation over ranges. Sliding window updates incrementally; prefix sum precomputes everything upfront.
• Prefix Sum → HashMap: Many prefix sum problems use a hashmap to store and look up previous prefix values (e.g., “subarray sum equals k”).
• Sorting → Intervals: Nearly all interval problems start by sorting by start time.
• Kadane’s: Combines ideas from prefix sum (running sum) and sliding window (expand/reset decision).
• Monotonic Stack: Often paired with sliding window for problems like “sliding window maximum.”

Pattern Selection Cheat Sheet

When you see a new problem, use these signals to narrow down the pattern:

Is the input SORTED (or should you sort it)?
│
├── YES, and looking for a TARGET value or boundary
│   └── Binary Search
│
├── YES, and looking for PAIRS or comparing ends
│   └── Two Pointers (opposite direction)
│
├── SORT FIRST, then process
│   ├── Intervals / overlaps → Merge Intervals
│   ├── Pairs / triplets → Sort + Two Pointers
│   └── Greedy decisions → Sorting-Based
│
└── NO (unsorted), what are you looking for?
    │
    ├── CONTIGUOUS subarray / substring with some property?
    │   ├── Fixed size or longest/shortest → Sliding Window
    │   ├── Range sum queries → Prefix Sum
    │   ├── Count subarrays with sum = k → Prefix Sum + HashMap
    │   └── Maximum sum subarray → Kadane's Algorithm
    │
    ├── Finding PAIRS, complements, or duplicates?
    │   └── HashMap
    │
    ├── Rearranging IN-PLACE?
    │   └── Two Pointers (same direction / partitioning)
    │
    ├── "Next greater / smaller element"?
    │   └── Monotonic Stack
    │
    └── Grouping or frequency analysis?
        └── HashMap / Frequency Counting

Difficulty Progression Across All Patterns

If you’re just starting out, here’s a suggested order of problems across all patterns, grouped by difficulty:

Phase 1: Foundations (Easy)

Phase 2: Core Patterns (Easy-Medium)

Phase 3: Pattern Mastery (Medium)

Phase 4: Advanced (Medium-Hard)

Each Document Follows This Structure

Every pattern document is organized the same way so you always know what to expect:

1. What is [Pattern]? - Concept explained from scratch with a concrete example
2. When to Use It? - Signals and triggers to recognize in problem statements
3. Types / Variations - Sub-patterns within the main technique
4. Template Code - Reusable Python templates with comments
5. Problem Set (10 problems) - Each with:
   • Problem statement & LeetCode link
   • Clarifying questions & constraints
   • Multiple approaches (brute force → optimal) with complexity analysis
   • Well-documented Python code
   • Edge case discussion
   • Step-by-step dry run
6. Key Takeaways & Summary - Tables, decision trees, and cheat sheets

Getting Started

Open Two Pointer Guide and begin. Good luck, and remember that the struggle is where the learning happens. Don’t rush to the solutions.

This guide is a work in progress. Patterns 6-9 are coming soon.