Problem Solving & Coding Patterns

What you will be able to do

• Analyse time and space complexity
• Apply the common patterns
• Write recursive solutions

What you will learn

1. 5.1How to Approach a Problem6 lessons

   Read a problem and its limits, trace examples, find edge cases, and move from brute force to a faster idea.

   1. Understanding a Problem and Its Constraints16 min
   2. Working Examples by Hand and Finding Edge Cases18 min
   3. From Brute Force to a Better Solution22 min
   4. Reading Input and Writing Output Like a Judge18 min
   5. How to Approach a Problem Checkpoint24 min
   6. Must-do problems: How to Approach a Problem100 min
2. 5.2Time & Space Complexity6 lessons

   Count steps, read growth rates from constraints, and know what Python operations really cost.

   1. What Big-O Means and Counting Steps18 min
   2. Common Growth Rates and Estimating from Constraints20 min
   3. The Real Cost of Python Operations20 min
   4. Space Complexity and Recursion Depth18 min
   5. Time and Space Complexity Checkpoint24 min
   6. Must-do problems: Time and Space Complexity120 min
3. 5.3Testing Your Solutions6 lessons

   Trace code, choose edge cases, check with assert, and stress test a fast solution against a brute force.

   1. Tracing code by hand and with print20 min
   2. Choosing edge cases20 min
   3. Quick checks with assert20 min
   4. Stress testing: brute force against a fast solution25 min
   5. Testing Your Solutions Checkpoint25 min
   6. Must-do problems: Testing Your Solutions120 min
4. 5.4Array & String Techniques7 lessons

   In-place changes, reversal and rotation, merging and partitioning, Kadane, and string building.

   1. In-place Changes and Swaps22 min
   2. Reversal and Rotation24 min
   3. Merging and Partitioning26 min
   4. Kadane's Maximum Subarray26 min
   5. String Building, Palindromes and Counting26 min
   6. Array and String Techniques Checkpoint25 min
   7. Must-do problems: Array and String Techniques120 min
5. 5.5Two Pointers6 lessons

   Close in from both ends, read and write in place, find triples, and use slow and fast pointers.

   1. Two Pointers from Both Ends: Pair Sum, Palindrome and Container24 min
   2. Read and Write Pointers: Remove Duplicates and Move Zeros22 min
   3. Three Sum and Avoiding Duplicates24 min
   4. Fast and Slow Pointers on Sequences24 min
   5. Two Pointers Checkpoint26 min
   6. Must-do problems: Two Pointers120 min
6. 5.6Sliding Window6 lessons

   Find the best block of neighbouring items in one pass with fixed and variable windows, counters and a deque.

   1. Fixed-Size Windows18 min
   2. Variable-Size Windows22 min
   3. Windows with Counts24 min
   4. Sliding Window Maximum with a Deque22 min
   5. Sliding Window Checkpoint25 min
   6. Must-do problems: Sliding Window120 min
7. 5.7Prefix Sums & Hashing7 lessons

   Answer range queries, apply range updates, and solve lookup and subarray problems with sets and dictionaries.

   1. Prefix Sums and Range Queries22 min
   2. Two-Dimensional Prefix Sums24 min
   3. Difference Arrays and Range Updates22 min
   4. Hashing for Lookup: Two Sum, Duplicates and Anagram Groups24 min
   5. Prefix Sums with a Hash Map: Subarray Sum and Balance26 min
   6. Prefix Sums and Hashing Checkpoint24 min
   7. Must-do problems: Prefix Sums and Hashing150 min
8. 5.8Binary Search6 lessons

   Find items, boundaries, rotation points, peaks and best answers with the classic loop, bisect and search on the answer.

   1. The Classic Binary Search Loop and Its Bounds18 min
   2. First and Last Position, Lower and Upper Bound, and bisect20 min
   3. Rotated Sorted Arrays and Finding a Peak20 min
   4. Binary Search on the Answer22 min
   5. Binary Search Checkpoint24 min
   6. Must-do problems: Binary Search150 min
9. 5.9Recursion in Depth7 lessons

   The call stack, the recursion limit, divide and conquer, and memoization with lru_cache.

   1. Base Case, Recursive Case and the Call Stack18 min
   2. Recursion Limit and Going Iterative18 min
   3. Recursion on Lists and Strings20 min
   4. Divide and Conquer: Fast Power and Merge Sort24 min
   5. Memoization with functools.lru_cache22 min
   6. Recursion in Depth Checkpoint25 min
   7. Must-do problems: Recursion in Depth120 min
10. 5.10Backtracking6 lessons

    Build every valid answer one choice at a time and prune: subsets, permutations, N-Queens and grid search.

    1. Backtracking: Choose, Explore, Undo22 min
    2. Subsets and Combinations24 min
    3. Permutations and Handling Duplicates25 min
    4. Constraint Problems and Pruning28 min
    5. Backtracking Checkpoint24 min
    6. Must-do problems: Backtracking120 min
11. 5.11Bit Manipulation & Math7 lessons

    Bit tricks, subsets with bitmasks, primes, the sieve, GCD and modular arithmetic for coding rounds.

    1. Binary Numbers and Bitwise Operators18 min
    2. Bit Tricks: XOR, Power of Two and Counting Set Bits20 min
    3. Subsets with Bitmasks20 min
    4. Primes, the Sieve and GCD22 min
    5. Modular Arithmetic and pow(a, b, m)20 min
    6. Bit Manipulation and Math Checkpoint24 min
    7. Must-do problems: Bit Manipulation and Math90 min
12. 5.12Pattern Practice5 lessons

    Choose the right pattern from the wording and limits, avoid time-pressure mistakes, and practise on mixed problems.

    1. Recognising a Pattern from Wording and Constraints20 min
    2. Choosing a Pattern: Decision Guide and Worked Examples22 min
    3. Mistakes Under Time Pressure20 min
    4. Pattern Practice Checkpoint25 min
    5. Must-do problems: Pattern Practice120 min