Problem Solving & Coding Patterns

What you will be able to do

• Follow a step-by-step method to go from a problem statement to working, tested code
• Work out the time and space complexity of your code and pick a target from the input limits
• Check your own solutions with hand-made test cases, a brute-force version and simple JUnit tests
• Recognise and apply two pointers, sliding window, prefix sums, hashing and binary search
• Write recursive and backtracking solutions and trace them on paper
• Use bit tricks and basic number theory that coding rounds expect

What you will learn

1. 5.1How to Approach a Problem

   A repeatable routine for any coding question, so you never start by staring at a blank editor.

   1. What problem solving really means30 min
   2. Restate the problem and make examples30 min
   3. Start with brute force30 min
   4. Dry run on paper30 min
   5. The edge case checklist30 min
   6. From brute force to optimal35 min
   7. Practice: the full routine40 min

2. 5.2Time & Space Complexity

   Analyse real code, not just labels, and use the input limits to know which solution will pass.

   1. Why we measure speed25 min
   2. Big O notation30 min
   3. Counting work in loops30 min
   4. Halving loops and log n30 min
   5. Space complexity30 min
   6. Best, average and worst case30 min
   7. From constraints to a target complexity30 min
   8. Practice: analyse real code40 min

3. 5.3Testing Your Solutions

   Catch wrong answers yourself before a judge does, with hand tests, a brute-force checker and a first look at JUnit.

   1. Why test your own code25 min
   2. Writing test cases by hand25 min
   3. Stress testing against brute force30 min
   4. JUnit 5 first look30 min
   5. Many cases with parameterized tests25 min
   6. Writing tests before the solution25 min
   7. Practice: test and fix35 min

4. 5.4Array & String Techniques

   The everyday moves that most array and string questions are built from.

   1. Array traversal patterns25 min
   2. Dynamic arrays: how ArrayList grows30 min
   3. Reverse and rotate in place25 min
   4. Counting with arrays25 min
   5. Maximum subarray: Kadane's algorithm30 min
   6. Matrix traversal35 min
   7. Building strings efficiently25 min
   8. Parsing and cleaning text30 min
   9. Simulation problems30 min
   10. Practice: arrays and strings45 min

5. 5.5Two Pointers

   Move two indexes through an array or string to replace a nested loop with one pass.

   1. The two pointers idea25 min
   2. Pair sum in a sorted array30 min
   3. Read and write pointers30 min
   4. Merging two sorted arrays30 min
   5. Palindromes with two pointers30 min
   6. Container with most water35 min
   7. Three sum and k-sum35 min
   8. Dutch national flag30 min
   9. Practice: two pointers45 min

6. 5.6Sliding Window

   Answer questions about subarrays and substrings by growing and shrinking a window instead of checking every range.

   1. The sliding window idea25 min
   2. Fixed-size windows22 min
   3. Variable-size windows26 min
   4. Longest substring without repeating characters25 min
   5. Windows with a count map28 min
   6. The at most k trick27 min
   7. Sliding window maximum28 min
   8. Real world: rate limits and moving averages24 min
   9. Practice: a reusable window template32 min

7. 5.7Prefix Sums & Hashing

   Precompute running totals and use maps and sets to answer range and subarray questions fast.

   1. Prefix sum arrays22 min
   2. 2D prefix sums26 min
   3. Difference arrays24 min
   4. HashMap and HashSet patterns24 min
   5. Subarray sum equals k27 min
   6. Longest subarray with a given sum25 min
   7. Longest consecutive sequence24 min
   8. Hashing pitfalls in Java24 min
   9. Practice: prefix sums and hashing35 min

8. 5.8Binary Search

   Search sorted data in log n time, then use the same idea to search for the answer itself.

   1. How binary search works25 min
   2. Classic binary search in Java28 min
   3. First and last position30 min
   4. Rotated arrays and peaks32 min
   5. Searching a sorted matrix28 min
   6. Binary search on the answer35 min
   7. Advanced binary search35 min
   8. Ternary search28 min
   9. Practice: binary search40 min

9. 5.9Recursion in Depth

   Go beyond factorial: trace recursion trees, recurse on arrays and strings, and measure the cost of recursive code.

   1. Recursion refresher25 min
   2. Recursion trees28 min
   3. Recursion on arrays and strings28 min
   4. Several recursive calls30 min
   5. Divide and conquer30 min
   6. The cost of recursive code28 min
   7. Recursion depth and StackOverflowError28 min
   8. Practice: recursion38 min

10. 5.10Backtracking

    Build answers one choice at a time and undo choices that cannot work.

    1. What backtracking is30 min
    2. Generating subsets32 min
    3. Generating permutations35 min
    4. Combinations and combination sum35 min
    5. Backtracking on grids35 min
    6. N-Queens and Sudoku40 min
    7. Pruning the search35 min
    8. Practice: backtracking45 min

11. 5.11Bit Manipulation & Math Basics

    Binary tricks and number theory that appear again and again in placement tests.

    1. Binary numbers28 min
    2. Bitwise operators30 min
    3. Common bit tricks35 min
    4. XOR tricks and bitmasks25 min
    5. GCD and LCM24 min
    6. Primes and the sieve26 min
    7. Modular arithmetic26 min
    8. Counting: nCr, Pascal and modular inverse28 min
    9. Overflow and big numbers24 min
    10. Practice: bits and math35 min

12. 5.12Pattern Practice

    Mixed problems where you first decide which pattern fits, then solve and test it.

    1. Spotting the pattern25 min
    2. Mixed set: easy35 min
    3. Mixed set: medium40 min
    4. Mixed set: hard45 min
    5. Your pattern notes22 min
    6. Patterns checkpoint45 min