Open In App

C++ Program To Print Pyramid Patterns

In this article, we will discuss the following top pattern programs in C++ star *, numbers, or other characters.

Pyramid Patterns in C++

1. Simple Pyramid Pattern
2. Simple Pyramid Pattern after 180Â° Rotation
3. Inverted Pyramid Pattern
4. Inverted Pyramid Pattern after 180Â° Rotation
5. Triangle Pattern
6. Inverted Triangle Pattern
7. Number Pyramid Pattern
8. Numbers Pyramid Pattern without Reassigning
9. Continuous Number Pyramid Pattern after 180Â° Rotation
10. Palindrome Triangle Pattern
11. Alphabet Pyramid Pattern
12. Continuous Alphabet Pyramid Pattern

C++ Programs to Print Patterns and Pyramids

1. Simple Pyramid Pattern in C++

Method 1: Printing simple pyramid pattern using for loop

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j <= i; j++) {` `            ``// Printing stars``            ``cout << ``"* "``;``        ``}` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Function``int` `main()``{``    ``int` `n = 5;``    ``pypart(n);``    ``return` `0;``}`

Output

```*
* *
* * *
* * * *
* * * * * ```

Time Complexity: O(n^2), where n is the input number of rows.

Auxiliary Space: O(1),

Method 2: Printing the above pattern using while Loop

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``// Outer loop to handle number of rows``    ``// n in this case``    ``int` `i = 0, j = 0;``    ``while` `(i < n) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``while` `(j <= i) {` `            ``// Printing stars``            ``cout << ``"* "``;``            ``j++;``        ``}``        ``j = 0; ``// we have to reset j value so as it can``               ``// start from beginning and print * equal to``               ``// i.``        ``i++;``        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;``    ``pypart(n);``    ``return` `0;``}`

Output

```*
* *
* * *
* * * *
* * * * * ```

Method 3: Printing the above pattern using recursion.

C++

 `// C++ code to demonstrate star pattern using recursion``#include ``using` `namespace` `std;` `// recursive function to print * on console``void` `print(``int` `n)``{``    ``if``(n == 0) ``// base case``    ``{``        ``return``;``    ``}``      ``cout << ``"* "``;``      ``print(n - 1); ``// calling recursively``}` `// recursive function to demonstrate printing pattern``void` `pattern(``int` `n)``{``    ``// base case``    ``if` `(n == 0)``    ``{``        ``return``;``    ``}``    ``else``    ``{``        ``// calling function recursively``        ``pattern(n - 1);` `        ``// print "* " n times``          ``print(n);``      ` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Function``int` `main()``{``    ``int` `n = 5;``    ``pattern(n);``}``// this code is contributed by Shivesh Kumar Dwivedi`

Output

```*
* *
* * *
* * * *
* * * * * ```

2. Simple Pyramid Pattern in C++ after 180Â° Rotation

Method 1: Printing the 180Â° rotated simple pyramid pattern using for loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// looping rows``    ``for` `(``int` `i = n; i > 0; i--) {``        ``for` `(``int` `j = 1; j <= n; j++) ``// looping columns``        ``{``            ``if` `(j >= i) {``                ``cout << ``"* "``;``            ``}``            ``else` `{``                ``cout << ``"  "``;``            ``}``        ``}``        ``cout << endl;``    ``}``    ``return` `0;``}`

Output

```        *
* *
* * *
* * * *
* * * * * ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate pattern printing``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart2(``int` `n)``{``    ``int` `i = 0, j = 0, k = 0;``    ``while` `(i < n) {` `        ``// for number of spaces``        ``while` `(k < (n - i - 1)) {``            ``cout << ``"  "``;``            ``k++;``        ``}` `        ``// resetting k because we want to run k from``        ``// beginning.``        ``k = 0;``        ``while` `(j <= i) {``            ``cout << ``"* "``;``            ``j++;``        ``}` `        ``// resetting k so as it can start from 0.``        ``j = 0;``        ``i++;``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart2(n);``    ``return` `0;``}`

Output

```        *
* *
* * *
* * * *
* * * * * ```

3. Inverted Pyramid Pattern in C++

Method 1: Printing the pattern using for loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = n; i > 0; i--) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j < i; j++) {` `            ``// Printing stars``            ``cout << ``"* "``;``        ``}` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Function``int` `main()``{``    ``int` `n = 5;``    ``pypart(n);``    ``return` `0;``}`

Output

```* * * * *
* * * *
* * *
* *
* ```

Method 2: Printing the pattern using while loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``// Outer loop to handle number of rows``    ``// n in this case``    ``int` `i = n, j = 0;``    ``while` `(i > 0) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``while` `(j < i) {` `            ``// Printing stars``            ``cout << ``"* "``;``            ``j++;``        ``}``        ``j = 0; ``// we have to reset j value so as it can``               ``// start from beginning and print * equal to``               ``// i.``        ``i--;``        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;``    ``pypart(n);``    ``return` `0;``}`

Output

```* * * * *
* * * *
* * *
* *
* ```

Method 3: Printing the above pattern using recursion.

C++

 `// C++ code to print  Inverted Pyramid Pattern using``// recursion``#include ``using` `namespace` `std;` `// recursive function for printing``void` `print(``int` `n)``{``      ``if``(n == 0) ``// base case``    ``{``        ``return``;``    ``}``      ``cout << ``"* "``;``      ``print(n - 1); ``// recursive calling for printing``}` `void` `pattern(``int` `n)``{``    ``if` `(n == 0) {``        ``return``;``    ``}``       ``print(n);``    ``cout << endl;``    ``pattern(n - 1);``}` `// driver function``int` `main()``{``    ``int` `n = 5;``    ``pattern(n);``    ``return` `0;``}``// This code is contributed by Shivesh Kumar Dwivedi`

Output

```* * * * *
* * * *
* * *
* *
* ```

4. Inverted Pyramid Pattern in C++ after 180Â° Rotation

Method 1: Printing this pattern using for loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart2(``int` `n)``{``    ``// number of spaces``    ``int` `k = 2 * n - 2;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = n; i > 0; i--) {` `        ``// Inner loop to handle number spaces``        ``// values changing acc. to requirement``        ``for` `(``int` `j = 0; j < n - i; j++)``            ``cout << ``"  "``;` `        ``// Decrementing k after each loop``        ``k = k - 2;` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j < i; j++) {``            ``// Printing stars``            ``cout << ``"* "``;``        ``}` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart2(n);``    ``return` `0;``}`

Output

```* * * * *
* * * *
* * *
* *
* ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate pattern printing``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart2(``int` `n)``{``    ``int` `i = n, j = 0, k = 0;``    ``while` `(i > 0) {` `        ``// for number of spaces``        ``while` `(k < (n - i)) {``            ``cout << ``"  "``;``            ``k++;``        ``}` `        ``// resetting k because we want to run k from``        ``// beginning.``        ``k = 0;``        ``while` `(j < i) {``            ``cout << ``"* "``;``            ``j++;``        ``}` `        ``// resetting k so as it can start from 0.``        ``j = 0;``        ``i--;``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart2(n);``    ``return` `0;``}`

Output

```* * * * *
* * * *
* * *
* *
* ```

5. Triangle Pattern in C++

Method 1: Printing the given pattern using for loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart2(``int` `n)``{``    ``// Number of spaces``    ``int` `i, j, k = n;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(i = 1; i <= n; i++) {` `        ``// Inner loop for columns``        ``for` `(j = 1; j <= n; j++) {` `            ``// Condition to print star pattern``            ``if` `(j >= k)``                ``cout << ``"* "``;``            ``else``                ``cout << ``" "``;``        ``}``        ``k--;``        ``cout << ``"\n"``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;``    ``// Function Call``    ``pypart2(n);``    ``return` `0;``}`

Output

```    *
* *
* * *
* * * *
* * * * * ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate star pattern``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart2(``int` `n)``{``    ``int` `i = 0, j = 0, k = 0;``    ``while` `(i < n) {` `        ``// for spacing``        ``while` `(k <= n - i - 2) {``            ``cout << ``" "``;``            ``k++;``        ``}``        ``k = 0;` `        ``// For Pattern printing``        ``while` `(j <= i) {``            ``cout << ``"* "``;``            ``j++;``        ``}``        ``j = 0;``        ``i++;``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart2(n);``    ``return` `0;``}`

Output

```    *
* *
* * *
* * * *
* * * * * ```

6. Inverted Triangle Pattern in C++

Method 1: Printing the inverted triangle pattern using for loop.

C++

 `// C++ Program to print the inverted triangle pattern``#include ``using` `namespace` `std;` `// function to print inverted triangle``void` `printInvTriangle(``int` `n)``{` `    ``// outer loop to go thruough every row``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// leading space counter``        ``int` `space = i;` `        ``// inner loop to print space and star * in each row``        ``for` `(``int` `j = 0; j < 2 * n - i - 1; j++) {` `            ``// condition to check weather the star * or``            ``// whitespace is to be printed``            ``if` `(space) {``                ``cout << ``"  "``;``                ``space--;``            ``}``            ``else` `{``                ``cout << ``"* "``;``            ``}``        ``}``        ``cout << endl;``    ``}``}` `// driver code``int` `main()``{``    ``printInvTriangle(5);` `    ``return` `0;``}`

Output

```* * * * * * * * *
* * * * * * *
* * * * *
* * *
* ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ program to print inverted triangle pattern using``// while loop``#include ``using` `namespace` `std;` `// function to print pattern``void` `printInvTriangle(``int` `n)``{` `    ``// loop variables``    ``int` `i = 0;``    ``int` `j;` `    ``// outer loop to iterate through each row``    ``while` `(i < n) {` `        ``// leading space counter``        ``int` `space = i;``        ``j = 0;` `        ``// inner loop to print pattern in each row``        ``while` `(j < 2 * n - i - 1) {` `            ``// condition to check weather to print star * or``            ``// whitespace``            ``if` `(space) {``                ``cout << ``"  "``;``                ``space--;``            ``}``            ``else` `{``                ``cout << ``"* "``;``            ``}``            ``j++;``        ``}``        ``cout << endl;``        ``i++;``    ``}``}` `// driver code``int` `main()``{``    ``printInvTriangle(5);` `    ``return` `0;``}`

Output

```* * * * * * * * *
* * * * * * *
* * * * *
* * *
* ```

6. Number Pyramid Pattern in C++

Method 1: Printing the number pyramid pattern using for loop.

C++

 `// C++ code to demonstrate printing``// pattern of numbers``#include ``using` `namespace` `std;` `// Function to demonstrate printing``// pattern``void` `numpat(``int` `n)``{``    ``// initializing starting number``    ``int` `num = 1;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j <= i; j++)``            ``cout << num << ``" "``;` `        ``// Incrementing number at each column``        ``num = num + 1;` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``numpat(n);``    ``return` `0;``}`

Output

```1
2 2
3 3 3
4 4 4 4
5 5 5 5 5 ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ Code for pattern Printing``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``int` `i = 1, j = 0;``    ``while` `(i <= n) {``        ``while` `(j <= i - 1) {``            ``cout << i << ``" "``;``            ``j++;``        ``}``        ``j = 0;``        ``i++;``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart(n);``    ``return` `0;``}`

Output

```1
2 2
3 3 3
4 4 4 4
5 5 5 5 5 ```

7. Numbers Pyramid Pattern in C++ without Reassigning

Method 1: Printing the number pyramid pattern in C++ without reassigning using for loop.

C++

 `// C++ code to demonstrate  printing pattern of numbers``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `numpat(``int` `n)``{``    ``// Initialising starting number``    ``int` `num = 1;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j <= i; j++) {` `            ``// Printing number``            ``cout << num << ``" "``;` `            ``// Incrementing number at each column``            ``num = num + 1;``        ``}` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``numpat(n);``    ``return` `0;``}`

Output

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

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate  printing pattern of numbers``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `pypart(``int` `n)``{``    ``int` `i = 1, j = 0;` `    ``// here we declare an num variable which is``    ``// assigned value 1``    ``int` `num = 1;``    ``while` `(i <= n) {``        ``while` `(j <= i - 1) {` `            ``// Printing numbers``            ``cout << num << ``" "``;` `            ``// here we are increasing num for every``            ``// iteration.``            ``num++;``            ``j++;``        ``}``        ``j = 0;``        ``i++;` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``pypart(n);``    ``return` `0;``}`

Output

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

C++

 `#include ``using` `namespace` `std;` `int` `main()``{``    ``int` `rows = 5, count = 0, count1 = 0, k = 0;` `    ``for` `(``int` `i = 1; i <= rows; ++i) {``        ``for` `(``int` `space = 1; space <= rows - i; ++space) {``            ``cout << ``"  "``;``            ``++count;``        ``}` `        ``while` `(k != 2 * i - 1) {``            ``if` `(count <= rows - 1) {``                ``cout << i + k << ``" "``;``                ``++count;``            ``}` `            ``++k;``        ``}``        ``count1 = count = k = 0;` `        ``cout << endl;``    ``}``    ``return` `0;``}` `// code by Kashif RB`

Output

```        1
2 3
3 4 5
4 5 6 7
5 6 7 8 9 ```

C++

 `#include ``using` `namespace` `std;` `int` `main()``{``    ``int` `rows = 5, count = 0, count1 = 0, k = 0;` `    ``for` `(``int` `i = 1; i <= rows; ++i) {``        ``for` `(``int` `space = 1; space <= rows - i; ++space) {``            ``cout << ``"  "``;``            ``++count;``        ``}` `        ``while` `(k != 2 * i - 1) {``            ``if` `(count <= rows - 1) {``                ``cout << i + k << ``" "``;``                ``++count;``            ``}``            ``else` `{``                ``++count1;``                ``cout << i + k - 2 * count1 << ``" "``;``            ``}``            ``++k;``        ``}``        ``count1 = count = k = 0;` `        ``cout << endl;``    ``}``    ``return` `0;``}` `// code by Kashif Rb`

Output

```        1
2 3 2
3 4 5 4 3
4 5 6 7 6 5 4
5 6 7 8 9 8 7 6 5 ```

10. Alphabet Pyramid Pattern in C++

Method 1: Printing the given pattern using for loop.

C++

 `// C++ code to demonstrate printing pattern of alphabets``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `alphabet(``int` `n)``{``    ``// Initializing value corresponding to 'A'``    ``// ASCII value``    ``int` `num = 65;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j <= i; j++) {` `            ``// Explicitly converting to char``            ``char` `ch = ``char``(num);` `            ``// Printing char value``            ``cout << ch << ``" "``;``        ``}` `        ``// Incrementing number``        ``num = num + 1;` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Function``int` `main()``{``    ``int` `n = 5;``    ``alphabet(n);``    ``return` `0;``}`

Output

```A
B B
C C C
D D D D
E E E E E ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate printing pattern of alphabets``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `alphabet(``int` `n)``{``    ``int` `i = 1, j = 0;` `    ``// assigning ASCII value of A which is 65``    ``int` `num = 65;` `    ``// converting ASCII value to character,``    ``// now our alpha variable is having``    ``// value A after typecasting.``    ``char` `alpha = ``char``(num);``    ``while` `(i <= n) {` `        ``// alpha is having A value and it``        ``// will change as soon as alpha``        ``// increased or decreased.``        ``while` `(j <= i - 1) {``            ``cout << alpha << ``" "``;``            ``j++;``        ``}` `        ``// incrementing alpha value so as it can``        ``// point to next character``        ``alpha++;` `        ``// we have to reset j value so as it can``        ``// start from beginning and print * equal to``        ``// i.``        ``j = 0;``        ``i++;` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``alphabet(n);``    ``return` `0;``}`

Output

```A
B B
C C C
D D D D
E E E E E ```

11. Continuous Alphabet Pyramid Pattern in C++

Method 1: Printing the above pattern using for loop.

C++

 `// C++ code to demonstrate printing pattern of alphabets``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `contalpha(``int` `n)``{``    ``// Initializing value corresponding to 'A'``    ``// ASCII value``    ``int` `num = 65;` `    ``// Outer loop to handle number of rows``    ``// n in this case``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Inner loop to handle number of columns``        ``// values changing acc. to outer loop``        ``for` `(``int` `j = 0; j <= i; j++) {` `            ``// Explicitly converting to char``            ``char` `ch = ``char``(num);` `            ``// Printing char value``            ``cout << ch << ``" "``;` `            ``// Incrementing number at each column``            ``num = num + 1;``        ``}` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``contalpha(n);``    ``return` `0;``}`

Output

```A
B C
D E F
G H I J
K L M N O ```

Method 2: Printing the above pattern using while loop.

C++

 `// C++ code to demonstrate printing pattern of alphabets``#include ``using` `namespace` `std;` `// Function to demonstrate printing pattern``void` `contalpha(``int` `n)``{``    ``int` `i = 1, j = 0;``    ``int` `num = 65;``    ``char` `alpha = ``char``(num);``    ``while` `(i <= n) {``        ``while` `(j <= i - 1) {``            ``cout << alpha << ``" "``;` `            ``// incrementing alpha value in every``            ``// iteration so as it can assign to``            ``// next character``            ``alpha++;``            ``j++;``        ``}``        ``j = 0;``        ``i++;` `        ``// Ending line after each row``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``// Function Call``    ``contalpha(n);``    ``return` `0;``}`

Output

```A
B C
D E F
G H I J
K L M N O ```

Printing patterns in python language are discussed in the following article – Programs for printing pyramid patterns in Python

This article is contributed by Manjeet Singh(S.Nandini). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

Write a program to print the pyramid pattern formed of stars

Example

input n=10

output:

*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *

Approach: using nested loop

The approach used here is to first print a certain number of spaces based on the current row number (i) and the total number of rows (n) to make sure that the pattern is aligned to the right. Then, the required number of asterisks are printed in the current row using a nested loop.

Algorithm

1. Take input for the number of rows (n)
2. Iterate through each row from 1 to n
3. Print spaces before the asterisks for alignment
4. Iterate through each column from 1 to i
5. Print an asterisk followed by a space
6. Move to the next line for the next row

Python3

 `n``=``10``for` `i ``in` `range``(``1``,n``+``1``):``  ``print``(``" "``*``(n``-``i),end``=``"")``  ``for` `j ``in` `range``(``1``,i``+``1``):``    ``print``(``"*"``,end``=``" "``)``  ``print``()`

Output

```         *
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * * ```

Time Complexity:
The time complexity of this program is O(n^2), as it involves two nested loops, one for the rows and another for the columns.

Space Complexity:
The space complexity of this program is O(1), as it uses a constant amount of space to print each character.