Printing Inverted Number Triangle | Number Patterns in C

This tutorial will teach you how to create an inverted number triangle pattern in C. This is an excellent exercise for mastering nested loops and building upon the fundamental pattern programming concepts you've already learned. By the end, you'll be able to create this pattern and understand the logic behind it.

Final Output

The final output is an inverted number triangle where each row starts from 1 and prints a sequence of numbers up to a decreasing value. For a user input of 5, the output will look like this:

Enter the number of rows: 5
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

---

Deconstructing the Pattern: The Logic

Creating this inverted pattern requires breaking it down into rows and columns, just like the regular half pyramid, but with a slight change in the loop conditions. The logic is based on controlling two loops: an outer loop for the rows and an inner loop for the numbers in each row.

Problem Statement: The program should take an integer input n from the user and print an inverted number triangle pattern where each row starts from 1 and decreases in length.

Pattern Analysis & Logic:

• Identifying the Rows: The pattern has n rows, but they are in decreasing order. So, our outer loop will run from i = n down to 1. This loop controls the row number.

• Identifying the Columns: The number of characters in each row is equal to the current row number i. This means our inner loop will run from j = 1 up to i. This loop controls the numbers printed on each row.

• Printing the Numbers: Inside the inner loop, we will print the value of j. Since the inner loop's counter j starts at 1 and goes up to i, this naturally prints the sequence 1 2 3 4 5, then 1 2 3 4, and so on.

Here is the step-by-step breakdown of the algorithm:

1. Start the program.

2. Declare an integer variable n for the number of rows.

3. Prompt the user to enter the number of rows.

4. Read the user's input and store it in n.

5. Create an outer for loop that iterates from i = n down to 1 (for the rows).

6. Inside the outer loop, create an inner for loop that iterates from j = 1 up to i (for the columns).

7. Inside the inner loop, print the value of j followed by a space.

8. After the inner loop finishes (meaning a full row has been printed), use printf("\n"); to move to the next line.

9. Repeat the process until the outer loop completes.

---

The Code Implementation

Here is the complete C program, with inline comments to explain each key line of code.

C

#include <stdio.h>

int main() {
    // Declare variables for rows and user input
    int i, j, n;

    // Prompt the user for the number of rows
    printf("Enter the number of rows: ");
    scanf("%d", &n);

    // Outer loop for the rows (from n down to 1)
    for (i = n; i >= 1; i--) {
        // Inner loop for the columns (from 1 up to i)
        for (j = 1; j <= i; j++) {
            // Print the number and a space
            printf("%d ", j);
        }
        // Move to the next line after each row is complete
        printf("\n");
    }

    return 0;
}

Explanation:

• int i, j, n;: We declare three integer variables: n to store the user input, i for the outer loop (rows), and j for the inner loop (columns).

• for (i = n; i >= 1; i--): This outer loop iterates from the user-specified number n down to 1. This is the key difference from the regular half-pyramid and is what creates the inverted shape.

• for (j = 1; j <= i; j++): This inner loop runs for each row. The condition j <= i ensures that the number of elements printed in each row is equal to the current row number i.

• printf("%d ", j);: This statement prints the value of j followed by a space. Since j increments in the inner loop, it prints 1 2 3 4 5, then 1 2 3 4, and so on.

• printf("\n");: After the inner loop completes its execution for a given row, this statement moves the cursor to the next line, preparing for the next row of the pattern.

---

Sample Output

Here is an example of what you'll see when you compile and run the program with a sample input.

Enter the number of rows: 5
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

Output Analysis:

• Row 1 (i=5): The inner loop runs from j=1 to 5, printing 1 2 3 4 5. A newline is then printed.

• Row 2 (i=4): The inner loop runs from j=1 to 4, printing 1 2 3 4. A newline is then printed.

• Row 3 (i=3): The inner loop runs from j=1 to 3, printing 1 2 3. A newline is then printed.

• The pattern continues this way until i reaches 1.

---

Variations and Enhancements

• Change the Logic: Modify the printf statement to print i instead of j. This will produce a pattern where each row prints the row number repeatedly (e.g., 5 5 5 5 5, 4 4 4 4).

• Modify the Character: Suggest how to convert the pattern to a star, hollow, mirrored, or alphabet version.

• Challenge: Try to create an inverted pyramid with a different type of numbering (e.g., repeating numbers).

---

Common Mistakes and Troubleshooting

• Incorrect Loop Conditions: A small typo in the outer loop condition, such as i > 1 instead of i >= 1, will cause the program to stop one row short.

• Missing Newline: Forgetting the printf("\n"); statement will cause all the numbers to print on a single line, resulting in a horizontal pattern instead of an inverted triangle.

---

Complexity Analysis

• Time Complexity: The time complexity is O(n^2) because of the nested loops. The total number of operations is roughly proportional to the square of n.

• Space Complexity: The space complexity is O(1) as the program uses a constant amount of memory for variables, regardless of the number of rows entered by the user.

  
  

  Dry-Run Table

  A dry-run table is an excellent way to show how the variables change during each iteration of the loop.

  Dry-Run Table of Printing Inverted Number Triangle | Number Patterns in C

  
  
  
  

---

Conclusion

You have successfully learned how to build an inverted number triangle pattern using nested loops. This exercise reinforces the critical concepts of loop control and pattern analysis, which are the building blocks for more complex programming challenges.

....till next post, bye-bye & take care!