Why does the second loop start at k equals 2 instead of 1?

On row 1, the first loop already prints the apex at j equals 1. If the second loop started at k equals 1, the condition i equals k would print a second star on the same row. Starting at k equals 2 avoids duplicating the top star while still drawing the right leg from row 2 onward.

What is the time complexity of this inverted V-shaped hollow star pattern program?

With n rows, each row runs Theta(n) iterations across the two inner loops, so total time is Theta(n²), i.e. O(n²).

Inverted V-Shaped Hollow Star Pattern in C++

Q: How does the program create a hollow inverted V-shaped pattern?

For each row i, the first inner loop runs j from rows down to 1 and prints a star only if i equals j (one star on the descending diagonal). The second inner loop runs k from 2 to rows and prints a star only if i equals k (one star on the ascending diagonal). Every other position prints a space. As i increases from 1 to rows, the two legs move apart, so the shape opens toward the bottom like an inverted V.

Q: Why does the first inner loop run j from rows down to 1?

Printing columns from high j to low j orders the left segment so the star for row i lands in column j when i equals j. As i increases, the match moves leftward in that segment, which forms the left arm of the inverted V together with the second loop.

Beginner

⏱️ 7 min read

📚 Updated: Aug 2025

🎯 2 Code Examples

n rows total

Inverted V-shaped hollow star pattern (narrow top, wide bottom) in C++

What You'll Learn

This program prints a hollow inverted V (one star on the first row, then two stars per row farther apart) using only the diagonal checks i == j and i == k.

See Program 8 for the upright V (wide row first, vertex at the bottom). Each line has width 2 * rows - 1 (9 characters when rows = 5).

⭐ Pattern Output

When you run the program with rows = 5:

Output

Complete C++ Program

Fixed rows = 5 version:

C++

#include <iostream>
using namespace std;

int main() {
    int rows = 5;
    int i, j, k;

    for (i = 1; i <= rows; ++i) {
        for (j = rows; j >= 1; --j) {
            if (i == j) cout << "*";
            else cout << " ";
        }
        for (k = 2; k <= rows; ++k) {
            if (i == k) cout << "*";
            else cout << " ";
        }
        cout << "\n";
    }

    return 0;
}

🧠 How It Works

Outer loop: narrow top → wide base

for (i = 1; i <= rows; ++i) increases the row index so the two legs move apart. cout << "*" or cout << " " fills each cell.

Outer

Left leg (`j`)

for (j = rows; j >= 1; --j): if i == j then cout << "*", else space. That traces the downward diagonal on the left half.

Left

Right leg (`k`)

for (k = 2; k <= rows; ++k) mirrors the test: star when i == k. Starting at 2 avoids duplicating the apex star on row 1.

Right

Newline & width

cout << "\n" ends the row. The j loop emits rows characters and the k loop rows - 1, so width is always 2 * rows - 1.

Width

Hollow inverted V

O(rows²) writes, O(1) extra space. Full-width lines scroll horizontally in the green preview on narrow viewports.

Variation — User Input Version

Accept rows with cin:

C++

#include <iostream>
using namespace std;

int main() {
    int rows;
    int i, j, k;

    cout << "Enter the number of rows: ";
    cin >> rows;

    for (i = 1; i <= rows; ++i) {
        for (j = rows; j >= 1; --j) {
            if (i == j) cout << "*";
            else cout << " ";
        }
        for (k = 2; k <= rows; ++k) {
            if (i == k) cout << "*";
            else cout << " ";
        }
        cout << "\n";
    }

    return 0;
}

💡 Tips for Enhancement

Try These

Validate rows >= 1 after input
Parameterize both loops with rows and trace i == j / i == k on paper
Pair with Program 8 (upright V) to sketch a full hollow diamond
Print row numbers at star positions instead of *
Generalize column indices if you want a wider gap between the legs

Avoid

Starting the second loop at k = 1 without adjusting logic (duplicate * on row 1)
Mixing up j descending vs ascending—the pattern assumes j goes rows → 1
Forgetting spaces so columns collapse
Assuming cin always succeeds

Key Takeaways

Left leg: loop j from rows to 1; star when i == j.

Right leg: loop k from 2 to rows; star when i == k.

Line width is rows + (rows - 1) = 2 * rows - 1 characters.

Time complexity O(n²) for n rows.

Often taught as the top half of a hollow diamond.

❓ Frequently Asked Questions

How does the program create a hollow inverted V-shaped pattern?

Each inner loop prints at most one * per row, exactly where the row index matches the column index being visited. Everything else is a space, so you only see the two slanted edges.

Why does the first inner loop run j from rows down to 1?

That order fills the left block of columns so the i == j hit lands on the correct column for each row, forming the left arm of the inverted V.

Why does the second loop start at k = 2?

On row 1 the first loop already outputs the single top star. If k started at 1, i == k would fire again and duplicate it.

What is the time complexity of this program?

O(n²) for n rows: each row does Θ(n) iterations across the two inner loops.

Next: V-Shaped Hollow Pattern

Continue to Program 8 to print the upright V-shaped hollow pattern in C++.

Program 8 →

Did you know?

If you print this upper half and then print Program 8 starting from rows - 1, you get the full hollow diamond (Program 9) without duplicating the middle row.

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

13 people found this page helpful

C++ Star Pattern 6 C++ Star Pattern 8