Floyd's Triangle is a number pattern where consecutive integers are printed in rows, with each new row containing one more number than the previous row.

For 5 rows:

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

It is a useful pattern problem for understanding nested loops, row structure, and maintaining a running value.

Pattern Logic

For each row:

Row 1 contains 1 number.
Row 2 contains 2 numbers.
Row 3 contains 3 numbers.
Row N contains N numbers.

The numbers continue increasing across rows.

For example:

Row 1 → 1
Row 2 → 2 3
Row 3 → 4 5 6

The next number after one row becomes the starting number of the next row.

C Program

#include <stdio.h>

int main() {
    int rows = 5;
    int num = 1;

    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%d ", num);
            num++;
        }

        printf("\n");
    }

    return 0;
}

Output:

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

How It Works

The outer loop controls the number of rows:

for (int i = 1; i <= rows; i++)

The inner loop prints i numbers in the current row:

for (int j = 1; j <= i; j++)

The variable num keeps track of the next number to print:

printf("%d ", num);
num++;

Therefore, the number continues increasing even after moving to the next row.

Algorithm

Set num = 1.
Start from the first row.
Print as many numbers as the current row number.
Increase num after every number.
Move to the next row.
Repeat until all rows are printed.

Pseudocode

num = 1

FOR i = 1 TO rows
    FOR j = 1 TO i
        PRINT num
        num = num + 1
    PRINT new line

Complexity

For N rows, the total number of numbers printed is:

1 + 2 + 3 + ... + N

which is:

N(N + 1) / 2

Therefore:

Time Complexity:  O(N²)
Space Complexity: O(1)

The O(N²) time is because the program prints approximately N² / 2 numbers.

Common Mistakes

Resetting num inside the outer loop.
Using j <= rows instead of j <= i.
Forgetting to increment num.
Forgetting the newline after each row.

For example, num should be initialized before the outer loop:

int num = 1;

for (...) {
    ...
}

not inside each row.

Quick Reference

int num = 1;

for (int i = 1; i <= rows; i++) {
    for (int j = 1; j <= i; j++) {
        printf("%d ", num++);
    }

    printf("\n");
}

The key pattern is:

Row 1 → 1 number
Row 2 → 2 numbers
Row 3 → 3 numbers
...
Row N → N numbers

Key Takeaways

Floyd's Triangle contains consecutive numbers arranged in rows.
Row i contains exactly i numbers.
Nested loops are used to generate the pattern.
A running variable keeps the numbers consecutive across rows.
Printing N rows requires O(N²) time.

Practice Questions

Print Floyd's Triangle for N rows.
Start Floyd's Triangle from a number other than 1.
Print Floyd's Triangle in reverse order.
Print only the odd numbers in a triangular pattern.
Modify the pattern to print consecutive even numbers.

What's Next?

Next, practice another number pattern to strengthen your understanding of nested loops and row-column relationships.

C programming dsa floyds-triangle loops nested-loops patterns

Found a problem on this page, or something that could be clearer?

What kind of thing?

What happened?

Email — only if you want a reply

Goes straight to the author. Not published anywhere.

Floyd's Triangle