Hey folks!

Announcing the release of a collection of over 70 tutorials and solution write-ups of coding challenges!

If you’re prepping for coding interviews or sharpening data-structures skills, this can save you hours. PFM Coding Challenge Tutorials packs 70+ step-by-step write-ups with crystal-clear reasoning, edge cases, and clean C++.

What you’ll get

The why behind each approach (not just code).
Trade-offs, complexity, and common pitfalls.
Alternative patterns when they help (A/B variants).
C++-first solutions: STL, idioms, and readable code.

Get 6 free solutions!Get all 70+ solutions!! 34% off $29.99

Here are some of the included challenges:
Two Sum* · Palindrome Number · Roman to Integer* · Longest Common Prefix · Generate Parentheses ·
Merge Two Sorted Lists (A/B) · Search Insert Position (A/B) · Plus One · Add Binary · Sqrt(x) ·
Climbing Stairs* · Balanced Binary Tree · Pascal’s Triangle (I/II) · Best Time to Buy/Sell Stock ·
Happy Number (A/B*) · Reverse Linked List · Palindrome Linked List* · Move Zeroes · Intersection of Two Arrays
and many others!!

* in the free sample

Launch discount ends Tue, Oct 21, 2025 @ 11:59pm PT.

Why I made this eBook:

I've been dissatisfied by a lot of the solution explanations I've found out there on the internet for the past few months while I worked through these challenges as prep for coding interviews. I found a lot of them lacked depth, were making assumptions about the reader's coding abilities, or were just poorly written and omitted important details. I knew that if I was struggling understanding these solutions, that meant that lots of other people were struggling understanding these solutions too. So I embarked on a journey learning to solve these challenges on my own, and in doing so, arrived at some really clear understandings of the solutions as well as how to clearly articulate the solutions and concepts in a way that anyone could understand!

I've learned so much in the process while working through each challenge and I wanted to share that knowledge with you!

As an example of what's included, here the write up for challenge #70: Climbing Stairs below:

Challenge:

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

URL: https://leetcode.com/problems/climbing-stairs/description/

class Solution {
public:
    int climbStairs(int n) {
        
    }
};

Intuition

This challenge wants us to compute permutations.
How many different ways can we sum the values 1 and 2 to equal n?

The hint gives us a great starting point:
To reach nth step, what could have been your previous steps? (Think about the step sizes)

Let's look at the possible combos for the first few possibilities of N:

possible step combos: 

n = 0: 
    0 combos
n = 1: 
    1 step
    1 combo
n = 2: 
    2
    1 + 1
    2 combos
n = 3: 
    2 + 1
    1+1 + 1
    1 + 2
    3 combos

Notice that the various ways to combine for n=3 look like the various ways to combine n=2 and n=1, added together.

Let's check a few more n values:

n = 4: 
    2+2
    2 + 1+1
    1+1 + 1+1 or 1 + 1+1 + 1
    1 + 2 + 1
    1+1 + 2
    5 combos
n = 5: 
    1+1+1+1+1
    2+1+1+1
    1+2+1+1
    1+1+2+1
    1+1+1+2
    1+2+2
    2+1+2
    2+2+1
    8 combos

The pattern is starting to emerge.

Notice that starting from n=3 onward, the pattern is always:
numCombos for n = numCombos for n-1 + numCombos for n-2
When n = 4, the combo count is 5:
n-1 count is 3
n-2 count is 2
their sum is 5.

When n = 5:
n-1 count is 5
n-2 count is 3
Their sum is 8.

Let's confirm this by talking through n = 6:
We should get n=5 (8) + n=4 (5), or 13 combos:

n = 6:
1.     1+1+1+1+1+1
2.     2+1+1+1+1
3.     1+2+1+1+1
4.     1+1+2+1+1
5.     1+1+1+2+1
6.     1+1+1+1+2
7.     2+1+1+2
8.     2+1+2+1
9.     2+2+1+1
10.    1+2+2+1
11.    1+2+1+2
12.    1+1+2+2
13.    2+2+2

13 combos!
It's confirmed!
The pattern is:

    combos @ n = combos @ n-1 + combos @ n-2

With this pattern, we can build up a cache using a vector, with size n + 1, because the n needs to match the index, and not be zero based.

std::vector<int> cache (n + 1);

We need to initialize the first two true N's:

cache[0] = 0;
cache[1] = 1;
cache[2] = 2;

For the rest of the N's, we can use a loop, remembering that n needs to match the index, and not be zero-based. That means we use i <= n instead of i < n:

for( int i = 3; i <= n; ++i )
{
    cache[i] = cache[i-1] + cache[i-2];
}

Once we've built up the cache, we just return the appropriate index for whatever n we were given:

return cache[n];

Here's the full solution:

Code

class Solution {
    
public:
    int climbStairs(int n) 
    {
        if( n <= 2 )
            return n;

        std::vector<int> cache (n + 1);
        
        cache[0] = 0;
        cache[1] = 1;
        cache[2] = 2;

        for( int i = 3; i <= n; ++i )
        {
            cache[i] = cache[i-1] + cache[i-2];
        }

        return cache[n]; 
    }
};

Looking for help with C++, coding challenges, and the JUCE framework?

Check out the JUCE & C++ Consultation Membership!

Hire me for your project!

Thank you so much for supporting Matkat Music LLC, ChordieApp, and ProgrammingForMusicians!

https://www.pfmcpp.com

https://www.chordieapp.com

When the biggest impact costs nothing...

[🎛🎹🎻] 🛒🛍️ LAST CHANCE 2025 Memorial Day Sale!!! 🛒🛍️

[🎛🎹🎻] 🛒🛍️ 2025 Memorial Day Sale!!! 🛒🛍️

IT'S HERE!!!! New FreeCodeCamp tutorial is Live!

FreeCodeCamp and I are back at it again! (PFM::Project13 video tut)

See all posts from Matkat Music