Inner Reducing Pattern printing in C++

Introduction:

Pattern printing is a fundamental concept in programming that helps improve logical thinking and understanding of nested loops. One specific type of pattern is the inner reducing pattern, where the number of elements in each row decreases progressively as you move downward.

In this pattern, you typically begin with a fixed number of elements in the first row. For every subsequent row, the number of elements is reduced by one. The elements themselves could be numbers, characters, or symbols, depending on the requirement. This type of pattern is popular in basic programming exercises and is often used to teach students how to manage loops and conditions effectively.

What is the Inner Reducing Pattern?

For example, you might want to print something like this:

This pattern shows:

• The first row has 5 numbers (from 1 to 5).
• The second row has 4 numbers (from 1 to 4).
• Each subsequent row has one fewer number than the previous one.

Steps to Create the Pattern in C++:

Understand the Rows and Columns:

• The number of rows in the pattern is equal to the starting count (in this case, 5).
• The number of columns in each row decreases as the row number increases.

Use Nested Loops:

• An outer loop controls the rows.
• An inner loop prints numbers in each row.

Logic for Printing Numbers:

• The inner loop runs for n - i columns in each row, where:
• n is the total number of rows.
• i is the current row (starting from 0).

Move to the Next Line:

• After printing one row, add a newline to move to the next row.

Approach 1: Simple Approach

Example:

Output:

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

Explanation:

Step 1: Input from the User

The program starts by asking the user to enter the number of rows (n). This input determines how many rows the pattern will have. For example, if the user enters 5, the pattern will have 5 rows. This makes the program flexible because it can generate patterns of any size based on the user's input.

Step 2: Outer Loop for Rows

The outer loop controls the number of rows in the pattern. It runs from i = 0 to i < n. Each time the outer loop runs, it represents one row of the pattern.

• In the first iteration (i = 0), it handles the first row.
• In the second iteration (i = 1), it handles the second row, and so on.
• This loop ensures that all rows are printed, one after another.

Step 3: Inner Loop for Columns

The inner loop is nested inside the outer loop. Its job is to print the numbers in each row.

• The inner loop runs from j = 1 to j <= n - i.
• j starts at 1 because the numbers in the pattern always begin at 1.
• The condition j <= n - i ensures that the number of columns decreases as the rows progress.

For example:

• In the first row (i = 0), the inner loop runs from 1 to 5 (prints 1 2 3 4 5).
• In the second row (i = 1), the inner loop runs from 1 to 4 (prints 1 2 3 4).
• In the third row (i = 2), the inner loop runs from 1 to 3 (prints 1 2 3).

This is how the decreasing number of elements is managed.

Step 4: Printing Numbers

Inside the inner loop, each number (j) is printed. After printing each number, a space (" ") is added to separate the numbers on the same row. This ensures that the numbers are displayed side by side in a single row.

Step 5: Moving to the Next Row

Once all the numbers in a row are printed, the program uses cout << endl; to move to the next line. This ensures that the numbers for the next row start on a new line.

Step 6: Repeating the Process

The outer loop continues to run, repeating the inner loop for each row. With each new row, the number of columns decreases because of the condition j <= n - i. This is why the pattern looks like a triangle with fewer numbers in each subsequent row.

Step 7: Ending the Program

Once all rows are printed, the program ends. The complete pattern is displayed on the screen.

Example Walkthrough

Let’s say the user enters 5:

• First Row: The outer loop starts (i = 0), and the inner loop runs from j = 1 to 5. It prints 1 2 3 4 5.
• Second Row: The outer loop continues (i = 1), and the inner loop runs from j = 1 to 4. It prints 1, 2, 3 4.
• Third Row: The outer loop continues (i = 2), and the inner loop runs from j = 1 to 3. It prints 1 2 3.
• Fourth Row: The outer loop continues (i = 3), and the inner loop runs from j = 1 to 2. It prints 1 2.
• Fifth Row: The outer loop continues (i = 4), and the inner loop runs from j = 1 to 1. It prints 1.

The program completes, and the final output is the full pattern.

Complexity analysis:

Time Complexity

The time complexity of the inner reducing pattern printing depends on the number of rows (n) and how many elements are printed in total.

Outer Loop:

The outer loop runs n times, once for each row.

Inner Loop:

• In the first row, the inner loop runs n times.
• In the second row, it runs n-1 times.
• In the third row, it runs n-2 times, and so on.

The total number of iterations for the inner loop is the sum of numbers from n to 1:

Total iterations = n + (n-1) + (n-2) + ... + 1 = n * (n + 1) / 2

This simplifies to O(n²) for time complexity.

Space Complexity

The program uses only a few variables for looping and storing input (n, i, j), so the space complexity is O(1).

• No extra data structures like arrays or lists are used.
• The program only utilizes constant memory for variables, regardless of the input size.

Approach 2: Reverse Loop Reduction

This approach uses a reverse loop for the inner loop, starting from the maximum number for each row and decreasing toward 1. It achieves the same result but provides a different perspective on loop management.

Example:

Output:

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

Explanation:

Step 1: Getting Input from the User

The program begins by asking the user to enter the number of rows (n). The value of n defines how many rows will be printed.

For example, if the user enters 5, the pattern will have 5 rows.

Step 2: Outer Loop for Rows

The outer loop runs from 1 to n, which means it will iterate from i = 1 to n.

• The variable i represents the current row number.
• For the first row, i = 1, for the second row, i = 2, and so on up to n.
• This loop ensures we process all rows from the first to the last.

Step 3: Inner Loop for Columns (Reverse Counting)

The inner loop runs from n down to i, where n is the maximum number of elements in the current row.

• The loop starts at j = n and decrements down to i.
• The variable j represents the current position within the row, starting from the largest number.
• For example, in the first row, j starts at n and decreases to 1.
• In the second row, j starts at n-1 and goes down to 1.

Step 4: Printing the Numbers

Inside the inner loop, the number (n - j + 1) is printed.

• This formula ensures that the numbers decrease as j decreases.
• For instance, in the first row, j = n gives 1, j = n-1 gives 2, and so on.
• The numbers are printed with spaces between them.

Step 5: Moving to the Next Row

After printing all the numbers in a row, the program uses cout << endl; to move to the next line.

• This creates a new row, and the pattern continues.

Step 6: Repeating the Process

The outer loop continues from i = 2 to n, reducing the number of columns printed each time.

• For the second row, i = 2, the inner loop goes from n-1 to 1, printing 1 2 3 4.
• For the third row, i = 3, the inner loop prints 1 2 3.
• This pattern continues until the last row, which only prints 1.

Step 7: Ending the Program

Once all rows are printed, the program finishes, and the full pattern is displayed on the screen.

Example Walkthrough with n = 5:

1. First row (i = 1): The numbers from 5 to 1 are printed.
2. Second row (i = 2): The numbers from 4 to 1 are printed.
3. Third row (i = 3): The numbers from 3 to 1 are printed.
4. Fourth row (i = 4): The numbers from 2 to 1 are printed.
5. Fifth row (i = 5): The number 1 is printed.

The program displays the entire pattern in reverse decreasing order, and this approach keeps the logic clean and efficient.

Complexity analysis:

Time Complexity:

• The outer loop runs n times, and for each iteration of the outer loop, the inner loop runs from n down to i.
• The total number of iterations for the inner loop is:
• Sum = n + (n-1) + (n-2) + ... + 1 = n * (n + 1) / 2

Time Complexity: O(n²)

Space Complexity:

• The program uses a constant amount of space for variables (i, j, and n).
• No extra data structures are used.
• Space Complexity: O(1)

Approach 3: Single Loop Reduction Approach

The Single Loop Reduction Approach is a pattern printing technique where we use a single loop to reduce the number of elements printed in each subsequent row. Instead of printing numbers from a fixed range (like decreasing from n), we gradually decrease the range based on the current row. This approach simplifies the logic and reduces the need for nested loops, making it more efficient in terms of both time and space complexity.

Example:

Output:

Enter the number of rows: 10
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 
1 2 3 4 5 6 
1 2 3 4 5 
1 2 3 4 
1 2 3 
1 2 
1   

Explanation:

Step 1: Input from the User

• The program first prompts the user to enter the number of rows (n).
• For example, if the user enters 5, the pattern will have 5 rows.

Step 2: Outer Loop for Rows

• The outer loop runs from n down to 1.
• This loop will help print rows from the top (largest row) to the bottom.
• The variable i represents the current row number.
• For i = n, it prints the largest row with the maximum number of elements.
• For i = n-1, it prints the second-largest row with fewer elements.
• This continues until i = 1.

Step 3: Inner Loop for Printing Numbers

• The inner loop runs from 1 to i for each row.
• The variable j represents the current position within the row.
• For the first row (i = n), j goes from 1 to n.
• For the second row (i = n-1), j goes from 1 to n-1, and so on.
• This ensures we only print the necessary numbers for each row.

Step 4: Printing Numbers

• Inside the inner loop, numbers are printed sequentially from 1 to i.
• A space separates each number for clarity.
• For example, in the first row, the numbers from 1 to n are printed.
• In the second row, numbers from 1 to n-1 are printed, and so on.
• After printing the numbers for each row, the program prints the endl to move to the next line.

Step 5: Completing the Rows

The outer loop continues reducing i from n to 1.

Each iteration of i ensures that fewer numbers are printed for each row.

For example:

• First row (i = n): 1 2 3 4 5
• Second row (i = n-1): 1 2 3 4
• Third row (i = n-2): 1 2 3
• Fourth row (i = n-3): 1 2
• Fifth row (i = 1): 1

This way, we print fewer numbers with each row.

Step 6: End of the Program

• Once all rows are printed, the program ends, and the full pattern is displayed.

Complexity Analysis:

Time Complexity:

• The outer loop runs from n down to 1, which is n iterations.
• For each row, the inner loop runs from 1 to i.
• Total number of operations:
• Sum = 1 + 2 + 3 + ... + n = n * (n + 1) / 2 = O(n²)

Time Complexity: O(n²)

Space Complexity:

• The program uses constant space for variables (i, j, and n).
• No extra space is used beyond these variables.
• Space Complexity: O(1)