25 Pattern Problems Later: What I Learned About Loops in C++

I’ve completed all 25 pattern problems in my C++ logic-building practice.

At first, these exercises looked like simple output problems. But as the patterns grew more complex, I had to think carefully about rows, columns, spaces, counters, and how values change from one iteration to the next.

Here are some of the ideas that clicked for me along the way.

Start by understanding each row

For most patterns, I can break a row into a few questions:

How many spaces come first?

How many characters should I print?

Does the value change across a row, or carry over to the next one?

The outer loop controls the rows. The inner loops print the contents of each row.

For example, an increasing number triangle can use the row number to decide how many values to print:

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
        cout << j;
    }
    cout << endl;
}

Once I could describe the row in terms of i, choosing the loop bounds became much easier.

Spaces are part of the pattern

Right-aligned triangles and pyramids helped me understand that spaces are output too. A row may have one loop for leading spaces and another for the visible characters.

Thinking of a row in phases made alignment easier to reason about:

Print leading spaces.

Print the left or growing section.

Print any remaining characters.

Move to the next line.

Counters have to change at the right time

In continuous number patterns, the counter needs to continue across rows. When the pattern wraps after 9, the order of operations matters: print the current value, increment it, then wrap it back into the range.

cout << num << " ";
num++;

if (num >= 10) {
    num %= 10;
}

This helped me see how a small state variable can control a pattern across multiple rows.

Characters follow the same loop logic

Alphabet patterns use the same ideas as number patterns. Incrementing a char moves to the next letter:

char ch = 'A';

for (int j = 1; j <= count; j++) {
    cout << ch;
    ch++;
}

I also learned to pay attention to where a character variable is initialized. If every row should restart from A, initialize it inside the outer loop. If the sequence should continue across rows, keep it outside.

Build mirrored patterns in two parts

For a number pyramid such as:

1
121
12321
1234321

I can split each row into an increasing half and a decreasing half. The second half starts one number below the peak so the middle value is not printed twice.

That same “split the row into phases” approach made other pyramids easier to work through.

What I’m taking from the 25 problems

The biggest lesson was to derive the pattern before trying to write all the loops. I now look for the relationship between the row number and the number of spaces or characters, and I check whether a counter should reset or continue.

I also got more comfortable tracing loop values by hand. When output looked wrong, writing down the value of i, j, and the counter for one row often showed where the logic needed to change.

Completing these 25 problems gave me a stronger foundation in nested loops and basic pattern logic. Next, I’m moving on to more DSA practice and will keep using the same habit: break the problem into smaller steps, trace them, then code.

Updated Repo - Repo

#cpp #dsa #beginners #programming