# Most Asked Pattern Programs in C

Posted in /   /  Vinay Khatri
Last updated on August 26, 2022

Pattern programs are commonly asked during interviews, and we will cover the top pattern programs in C. Moreover, the logic is universal and can be applied to different programming languages, such as C++, Java, Python, and JavaScript. These pattern programs are called * patterns because we use * as a pixel or unit to build the program.

## Pattern Programs in C

The patterns that we will be discussing are:

1. Solid Rectangular Star Pattern in C
2. Hollow Rectangular star Pattern in C
3. Half Pyramid Star Pattern in C
4. Inverted Half Pyramid Pattern in C
5. Full Pyramid Star Pattern in C
6. Hollow Pyramid Star Pattern
7. Inverted Hollow Half pyramid in C
8. Full Hollow Inverted Pyramid in C
9. Half Diamond Star pattern in C
10. Solid Full Diamond Pattern in C
11. Right Arrow Star Pattern in C
12. Left Arrow Star Pattern
13. Plus Star Pattern
14. X Pattern in C
15. The Diagonal Hollow Square Pattern in C
16. Solid Rhombus Star Pattern in C
17. Hollow Rhombus Star Pattern in C
18. Solid Mirrored Rhombus Pattern in C
19. Hollow Mirrored Rhombus Star Pattern
20. Pascal's triangle in C
21. Floyd's Triangle in C
22. Half Pyramid of Alphabets in C
23. Palindrome Half Pyramid Pattern in Alphabets
24. Palindrome Half Pyramid Pattern Using Numbers in C
25. Hour Glass Star Pattern program in C

### 1. Solid Rectangular Star Pattern in C

rows: 3 columns: 5

#### Preview

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

#### Logic:

The logic for this pattern program is straightforward. In this star design, we only need a nested loop.

In that nested loop, the outer loop(i) will act as a row, the inner loop(j) will act as a column, and the star printing statement will reside in the inner loop.

• The outer loop (i) will start from 0 to rows (number of rows).
• The inner loop (i) will also start from 0 up to columns (number of columns)

#### Pseudocode

``````FOR i = 1; i <= rows; i++:
FOR j = 1; j <= columns; j++:
PRINT(*)

PRINT("\n")   #new line
ENDFOR ``````

#### Solid rectangular pattern program in C

``````#include <stdio.h>

int main()
{

int rows, columns,i,j;

printf("Enter the number of rows : ");
scanf("%d", &rows);

printf("Enter the number of columns : ");
scanf("%d", &columns);

printf("\n");

/* print solid rectangle*/

for (i = 1; i <= rows; i++)
{
for (j = 1; j <= columns; j++)
{
printf("*");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the number of rows : 3
Enter the number of columns : 5
*****
*****
*****``````

### 2. Hollow Rectangular Star Pattern in C

rows: 3 columns: 5

#### Preview

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

#### Logic

In the hollow rectangular design pattern, we also require a single nested ``` for ``` loop.

And for the hollow effect in the pattern, we need to put some conditions inside the inner loop (j), which decide whether to print a * or white space .

In the inner loop (j) we will only print the * pattern when

``i==1 || i==rows || j==1 || j==columns``

#### Pseudocode

``````FOR i = 1; i <= rows; i++:
for j = 1; j <= columns; j++:
IF i==1 || i==rows || j==1 || j==columns:
PRINT("*")  #PRINT STAR
ELSE:
PRINT(" ")   #PRINT WHITE SPACE

PRINT("\n") #NEW LINE
``````

#### Hollow Rectangular star Pattern Program in C

``````#include <stdio.h>
int main()
{
int rows, columns,i, j;

printf("Enter the number of rows : ");
scanf("%d", &rows);
printf("Enter the number of columns : ");
scanf("%d", &columns);

printf("\n");
/*Logic for holow rectangle*/
for (i = 1; i <= rows; i++)

{
for (j = 1; j <= columns; j++)
{
if (i==1 || i==rows || j==1 || j==columns)
printf("*");
else
printf(" ");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the number of rows : 4
Enter the number of columns : 5

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

### 3. Half Pyramid Star Pattern in C

stars: 6  #### Preview

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

#### Logic

The logic for printing the pyramid and triangle can be more tricky than printing square or rectangular patterns in C. Becaue in the pyramid or triangle patterns; we do not accept rows and columns; instead, we look for the total height of the pyramid. The inner loop (j) statement's starting or ending points depend on the outer loop (i) value .

In the half Pyramid pattern, we also require a nested loop, where

• The outer loop (i) will start from 1 to the total number of starts or the pyramid's height.
• And the inner loop(j) will also start from 1 but ends at the current value of the outer loop (i)

#### Pseudocode

``````FOR i = 1; i <= height; i++:
FOR j = 1; j <= i; j++:
PRINT("*")

PRINT("\n") # NEW LINE
``````

#### Half Pyramid Star Pattern Program in C

``````#include <stdio.h>

int main()
{
int stars,i, j;;

printf("Enter the number of stars : ");
scanf("%d", &stars);    //height of the pyramid

/*Logic for half Pyramid*/
for (i = 1; i <= stars; i++)

{
for (j = 1; j <= i; j++)
{
printf("*");
}
printf("\n");
}

return 0;
}``````

Output

``````Enter the number of stars : 6
*
**
***
****
*****
******``````

### 4. Inverted Half Pyramid Pattern in C

stars: 6

#### Preview

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

#### Logic

The logic for this pattern program in c is similar to the above program; the only difference is, here, instead of using an increment for the loop will use a decrement outer for the loop statement.

#### Pseudocode

``````FOR i = stars; i >= 1; i--:
FOR j = 1 ; j <= i; j++:
PRINT("*")

PRINT("\n")``````

#### Inverted Half Pyramid Pattern Program in C

``````#include <stdio.h>

int main()
{

int stars,i, j;;

printf("Enter the number of stars : ");

scanf("%d", &stars);   //height of the pyramid

/*Logic for inverted Pyramid*/
for (i = stars; i >= 1; i--)

{
for (j = 1 ; j <= i; j++)
{
printf("*");
}
printf("\n");
}

return 0;
}
``````

Output

``````Enter the number of stars : 6
******
*****
****
***
**
*``````

### 5. Full Pyramid Star Pattern in C

height=5

#### Preview

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

#### Logic

In this pattern design, we need to print an equilateral triangle. And to print this design pattern in C, again, we need a nested loop.

But there is a catch in this pattern. The nested loop contains two inner ``` for ``` loops j and k . Where j will be responsible for printing the white space and k will print the star for the pattern.

#### Pseudocode

``````space = height;

FOR i=1;i<=height;i++:
FOR j=1;j<space-1;j++:
PRINT(" ")

FOR k=1;k<=2*i-1;k++:
PRINT("*")

space -=1

PRINT("\n") #NEW LINE``````

#### Full Pyramid Star Pattern Program in C

``````#include <stdio.h>
int main()
{
int height,space,i,j,k;
printf("Enter the height of the triangle: ");
scanf("%d",&height);
space=height;
for( i=1;i<=height;i++)
{
for( j=1;j<space-1;j++)
{
printf(" ");
}
for( k=1;k<=2*i-1;k++)
{
printf("*");
}
space--;

printf("\n");
}
return 0;
}``````

Output

``````Enter the height of the triangle: 5
*
***
*****
*******
*********``````

### 6. Hollow Pyramid Star Pattern

Height of Pyramid: 6

#### Preview

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

#### Logic

We can use the following logic to print the hollow Pyramid Start pattern in C.

• initialize a variable space equal to the height of the pyramid
• Run the outer loop i from 1 to the height of the triangle.
• In the inner loop, j runs the loop from 1 to space-1 for printing the space.
• Again in the inner loop, k runs the loop from 1 to 2*i-1 . And in the k loop, check for the condition ``` k==1 OR k==2*i-1 OR i==height ``` print * else print a space.
• after the k loop decrement, the value of space by 1

#### Pseudocode:

``````space = height

FOR i=1;i<=height;i++:
FOR  j=1;j<=space-1;j++:
PRINT(" ")
FOR k=1;k<=2*i-1;k++:
IF(k==1 || k==2*i-1 || i==height):
PRINT("*")
ELSE:
PRINT(" ")

space -= 1;``````

#### Hollow Pyramid Star Pattern Program in C

``````#include<stdio.h>

int main()
{
int height,space,i,j,k;
printf("Height of Pyramid: ");
scanf("%d",&height);
space=height;
for( i=1;i<=height;i++)
{
for( j=1;j<=space-1;j++)
{
printf(" ");
}
for( k=1;k<=2*i-1;k++)
{
if(k==1 || k==2*i-1 || i==height)
printf("*");
else
printf(" ");
}
space--;

printf("\n");
}
return 0;
}``````

Output

``````Height of Pyramid: 6
*
* *
*   *
*     *
*       *
***********``````

### 7. Inverted Hollow Half Pyramid in C

height = 7

Preview

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

#### Logic

We can follow the following logic to print the inverted design pattern in the C programming language.

1. Run the outer for loop i from total height to 1.
2. Run the inner loop j from 1 to the current value of i
3. In the inner loop, check for the condition ``` j==1 || j==i || i==height ``` and print * else print the white space.

#### Pseudocode

``````FOR i=height;i>=1;i--:
FOR j=1;j<=i;j++:
IF(j==1 OR j==i OR i==height):
PRINT("*")
ELSE:
PRINT(" ")``````

#### Inverted Hollow Half Pyramid Program in C

``````#include<stdio.h>

int main()
{
int height,i,j;
printf("Enter the height of Pyramid: ");
scanf("%d",&height);
for(i=height;i>=1;i--)
{
for( j=1;j<=i;j++)
{
if(j==1 || j==i || i==height)
printf("*");
else
printf(" ");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the height of Pyramid: 7
*******
*    *
*   *
*  *
* *
**
*``````

### 8. Full Hollow Inverted Pyramid in C

height: 6

#### Preview

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

#### Logic

Logic to print the full hollow inverted pyramid

• set the value of space = 1
• Run the outer for loop in decrement order from height to 1.
• Run the inner first loop j from i to space, and print the space.
• Run the second inner loop k from 1 to 2*i-1. Check for the condition ``` k==1 || k==2*i-1 || i==height ``` that print the star else, print the white space.
• Increase the value of space by 1

#### Pseudocode

``````space = height

FOR i=height;i>=1;i--:
FOR j=1;j<space;j++:
PRINT(" ")
FOR k=1;k<=2*i-1;k++:
IF k==1 OR k==2*i-1 OR i==height:
PRINT("*")
ELSE:
PRINT(" ")

SPACE +=1

PRINT("\n")
``````

#### Full Hollow Inverted Pyramid Program in C

``````#include <stdio.h>

int main()
{
int height,space=1,i,j,k;
printf("Enter the height of pyramid: ");
scanf("%d",&height);

for( i=height;i>=1;i--)
{
for( j=1;j<space;j++)
{
printf(" ");
}
for( k=1;k<=2*i-1;k++)
{
if(k==1 || k==2*i-1 || i==height)
printf("*");
else
printf(" ");
}
space++;

printf("\n");
}
return 0;
}``````

Output

``````Enter the height of pyramid: 6
***********
*       *
*     *
*   *
* *
*``````

### 9. Half Diamond Star Pattern in C

max stars: 7

#### Preview

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

#### Logic

This pattern design is a combination of half pyramid and half inverted pyramid.

To design the upper half "half pyramid," we will use the nested loop, in which the outer loop ``` i ``` will go 1 to the max width of the pattern, and the inner loop j will print the i number of stars in each row.

And to design the lower half "half inverted pyramid", the outer loop will start from max width - 1 and ends with 1, and the inner loop j will print the i numbers of star in each row.

#### Pseudocode

``````//upper half
FOR i=1; i<= max_width; i++:
FOR j=1; j<=i; j++:
PRINT("*")

PRINT("\n")    //print new line

//lower half
FOR i=max_stars-1 ;i>=1 ;i--:
FOR j=1; j<=i; j++:
PRINT("*")

PRINT("\n") //print new line``````

#### Half Diamond Star Pattern Program

``````#include<stdio.h>

int main()
{
int max_stars,i,j;
printf("Enter the width of diamond: ");
scanf("%d",&max_stars);

//upper half of the daimond
for( i=1;i<=max_stars;i++)
{
for( j=1;j<=i;j++)
{
printf("*");
}
printf("\n");
}

//lowerhalf of the daimond
for( i=max_stars-1;i>=1;i--){
for( j=1;j<=i;j++){
printf("*");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the width of diamond: 7
*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````

### 10. Solid Full Diamond Pattern in C

width: 7

#### Preview

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

#### Logic

This pattern can be designed using either two nested loops or a single nested loop.

We can design this pattern in c with the combination of the full pyramid and the full inverted pyramid, but it will take two nested loops.

We also have an alternative approach: we will use a single nested loop with some conditions and print this design.

To design this pattern, the only thing we need to keep in mind that how many numbers of stars and spaces we want to print in each row.

#### Pseudocode

``````space = width-1

stars = 1

FOR i=1; i<=width; i++:

FOR j=1; j<=space; j++:
PRINT(" ")     //print space numbers of white space " "

FOR k=1; k<=stars; k++:
PRINT("*")       // print stars number of *

IF space>i:
space=space-1;
stars=stars+2;

IF space<i:
space=space+1;
stars=stars-2;

PRINT("\n")   //NEW LINE``````

#### Solid Full Diamond Pattern Program

``````#include<stdio.h>
int main(void) {
int width, space, stars, i, j, k;
printf("Enter the width of diamonds: ");
scanf("%d",&width);
space=width-1;
stars=1;
for( i=1;i<=width;i++)
{
for( j=1;j<=space;j++)
{
printf(" ");
}
for( k=1;k<=stars;k++) { printf("*"); } if(space>i)
{
space=space-1;
stars=stars+2;
}
if(space<i)
{
space=space+1;
stars=stars-2;
}
printf("\n");
}
return 0;}``````

Output

``````Enter the width of diamonds: 7
*
***
*****
*******
*****
***
*``````

### 11. Right Arrow Star Pattern in C

width: 7

#### Preview

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

#### Logic

In this design pattern, the space before the stars can be designed using the inverted Half and half pyramids.

And for the star pattern, we can print width-i number of stars for the upper Half and i+1 numbers of stars for the lower part.

Pseudocode

``````//upper part
FOR i=0; i<width; i++:

FOR j=0; j<i; j++:
PRINT(" ")

FOR k=1;k<=width-i;k++:
PRINT("*")

PRINT("\n") //new line

//lower part
FOR i=1; i<width; i++:

FOR j=1; j<width-i; j++:
PRINT(" ")

FOR k=1; k<=i+1; k++:
PRINT("*")

PRINT("\n")``````

#### Right Arrow Star Pattern Program

``````#include<stdio.h>

int main(void) {

int width,i,j,k;
printf("Enter the width of arrow: ");
scanf("%d",&width);

//  arrow upper part
for( i=0;i<width;i++)
{
for( j=0;j<i;j++)
{
printf(" ");
}
for( k=1;k<=width-i;k++)
{
printf("*");
}
printf("\n");
}

// arrow lower part
for( i=1;i<width;i++)
{
for( j=1;j<width-i;j++)
{
printf(" ");
}
for( k=1;k<=i+1;k++)
{
printf("*");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the width of arrow: 7
*******
******
*****
****
***
**
*
**
***
****
*****
******
*******``````

### 12. Left Arrow Star Pattern in C

width : 6

#### Preview

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

#### Logic

To design the left arrow star pattern in C, we can divide the complete program into two parts.

To print the upper and lower part of the arrow we will use the two nested double for loops.

In the nested loop, the outer loop ``` i ``` will go from 1 up to the arrow's width. Where the inner loops ``` j ``` and ``` k ``` will be printing the spaces and stars for the pattern.

#### Pseudocode

``````//upper half of the arrow
FOR i=1;i<=width;i++:
//loop to print the space
FOR j=1;j<=width-i;j++:
PRINT(" ");

//loop to print the stars
FOR k=0;k<=width-i;k++:
PRINT("*");

PRINT("\n");

//lower half of the arrow
FOR i=1;i<width;i++:
// loop to print the space
FOR j=1;j<i+1;j++:
printf(" ");

// loop to print the stars
FOR k=1;k<=i+1;k++:
PRINT("*");
PRINT("\n");  ``````

#### Left Arrow Star Pattern Program

``````#include<stdio.h>

int main(void) {

int width,i,j,k;
printf("Enter the width of arrow: ");
scanf("%d",&width);
for( i=1;i<=width;i++)
{
for( j=1;j<=width-i;j++)
{
printf(" ");
}
for( k=0;k<=width-i;k++)
{
printf("*");
}
printf("\n");
}
for( i=1;i<width;i++)
{
for( j=1;j<i+1;j++)
{
printf(" ");
}
for( k=1;k<=i+1;k++)
{
printf("*");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the width of arrow: 6
******
*****
****
***
**
*
**
***
****
*****
******``````

### 13. Plus Star Pattern in C

height: 7

#### Preview

``````   +
+
+
+++++++
+
+
+``````

#### Plus Star Pattern Program

``````#include<stdio.h>

int main() {
int height,i,j;
printf("Enter the height (odd): ");
scanf("%d", &height);
for( i=1;i<=height;i++)
{
if(i==((height/2)+1))
{
for( j=1;j<=height;j++)
{
printf("+");
}

}
else
{
for( j=1;j<=height/2;j++)
{
printf(" ");
}
printf("+");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the height (odd): 7
+
+
+
+++++++
+
+
+``````

### 14. X Pattern in C

width: 6

#### Preview

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

#### X Pattern Program

``````#include<stdio.h>

int main() {
int width,space, i,j;
printf("Enter the width: ");
scanf("%d",&width);
space=2*width-1;
for( i=1;i<=space;i++)
{
for( j=1;j<=space;j++)
{
if(i==j || j==(space-i+1))
{
printf("*");
}
else
{
printf(" ");
}
}
printf("\n");
}
return 0;
}``````

Output

``````Enter the width: 6
*         *
*       *
*     *
*   *
* *
*
* *
*   *
*     *
*       *
*         *``````

### 15. The Diagonal Hollow Square Pattern in C

rows: 8

#### Preview

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

#### The Diagonal Hollow Square Pattern Program

``````#include<stdio.h>
int main()
{
int rows, i, j;
printf("Enter rows: ");
scanf("%d",&rows);
for( i=1;i<=rows;i++)
{
for( j=1;j<=rows;j++)
{
if(i==1 ||i==rows||j==1||j==rows-i+1||i==j||j==rows)
{
printf("*");
}
else
{
printf(" ");
}
}
printf("\n");
}

return 0;
}``````

Output

``````Enter rows: 8
********
**    **
* *  * *
*  **  *
*  **  *
* *  * *
**    **
********``````

### 16. Solid Rhombus Star Pattern in C

rows: 7

#### Preview

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

#### Solid Rhombus Star Pattern Program

``````#include<stdio.h>

int main()
{
int rows, i,j,k;
printf("Enter rows: ");
scanf("%d",&rows);
for( i=rows;i>=1;i--)
{
for( j=1;j<=i-1;j++)
{
printf(" ");
}
for( k=1;k<=rows;k++)
{
printf("*");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter rows: 7
*******
*******
*******
*******
*******
*******
*******``````

### 17. Hollow Rhombus Star Pattern in C

rows: 7

#### Preview

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

#### Hollow Rhombus Star Pattern Program

``````#include<stdio.h>

int main()
{
int rows,i,j,k;
printf("Enter rows: ");
scanf("%d",&rows);
for( i=rows;i>=1;i--)
{
for( j=1;j<=i-1;j++)
{
printf(" ");
}
for( k=1;k<=rows;k++)
{
if(i==1 || i==rows || k==1 || k==rows)
printf("*");
else
printf(" ");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter rows: 7
*******
*     *
*     *
*     *
*     *
*     *
*******``````

### 18. Solid Mirrored Rhombus Pattern in C

rows: 7

#### Preview

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

#### Solid Mirrored Rhombus Pattern Program

``````#include<stdio.h>
int main()
{
int rows,i,j,k;
printf("Enter rows: ");
scanf("%d",&rows);
for( i=1;i<=rows;i++)
{
for( j=1;j<i;j++)
{
printf(" ");
}
for( k=1;k<=rows;k++)
{
printf("*");

}
printf("\n");
}
return 0;
}``````

Output

``````Enter rows: 7
*******
*******
*******
*******
*******
*******
*******``````

### 19. Hollow Mirrored Rhombus Star Pattern

rows: 7

Preview

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

#### Hollow Mirrored Rhombus Star Pattern Program

``````#include  <stdio.h>
int main()
{
int rows, i,j,k;
printf("Enter rows: ");
scanf("%d",&rows);
for( i=1;i<=rows;i++)
{
for( j=1;j<i;j++)
{
printf(" ");
}
for( k=1;k<=rows;k++)
{
if(i==1 || i==rows || k==1 || k==rows)
printf("*");
else
printf(" ");
}
printf("\n");
}
return 0;
}``````

Output

``````Enter rows: 7
*******
*     *
*     *
*     *
*     *
*     *
*******``````

### 20. Pascal's Triangle in C

rows: 6

#### Preview

``````          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
6 7 8 9 10 11 10 9 8 7 6``````

#### Pascal's Triangle in C Program

``````#include <stdio.h>
int main() {
int i, s, r, k = 0, c1 = 0, c2 = 0;
printf("Enter rows(r): ");
scanf("%d", &r);
for (i = 1; i <= r; ++i) {
for (s = 1; s <= r - i; ++s) {
printf("  ");
++c1;
}
while (k != 2 * i - 1) {
if (c1 <= r - 1) {
printf("%d ", i + k);
++c1;
} else {
++c2;
printf("%d ", (i + k - 2 * c2));
}
++k;
}
c2 = c1 = k = 0;
printf("\n");
}
return 0;
}``````

Output

``````Enter rows(r): 6
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
6 7 8 9 10 11 10 9 8 7 6``````

### 21. Floyd's Triangle in C

#### rows: 6 Preview

``````1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21``````

#### Floyd's Triangle in Program

``````#include<stdio.h>
int main() {
int rows, i, j, n = 1;
printf("Enter rows: ");
scanf("%d", &rows);
for (i = 1; i <= rows; i++) {
for (j = 1; j <= i; ++j) {
printf("%d ", n);
++n;
}
printf("\n");
}
return 0;
}``````

Output

``````Enter rows: 6
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21``````

### 22. Half Pyramid of Alphabets in C

Last Alphabet: F

#### Preview

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

#### Half Pyramid of Alphabets Program

``````#include<stdio.h>
int main() {
int i, j;
char input, alphabet = 'A';
printf("Enter an uppercase character you want to print in the last row: ");
scanf("%c", &input);
for (i = 1; i <= (input - 'A' + 1); ++i) {
for (j = 1; j <= i; ++j) {
printf("%c ", alphabet);
}
++alphabet;
printf("\n");
}
return 0;
}``````

Output

``````Enter an uppercase character you want to print in the last row: F
A
B B
C C C
D D D D
E E E E E
F F F F F F``````

### 23. Palindrome Half Pyramid Patterns in Alphabets

rows: 5

#### Preview

``````A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA``````

#### Palindrome Half Pyramid Patterns in Alphabets Program

``````#include<stdio.h>

int main() {
int i, j, rows, c=0;

printf("Enter rows: ");
scanf("%d", &rows);

for (i = 1; i <= 2*rows; i=i+2) {
for (j = 1; j <= i; j++) {
printf("%c", 'A'+c);
if(j <= i/2)
c++;
else
c--;
}
c = 0;
printf("\n");
}
return(0);
}``````

Output

``````Enter rows: 6
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA``````

Note: Check out C program to print a triangle of alphabets .

### 24. Palindrome Half Pyramid Pattern Using Numbers in C

rows: 6

#### Preview

``````1
121
12321
1234321
123454321
12345654321``````

#### Palindrome Half Pyramid Pattern Using Numbers Program

``````#include <stdio.h>

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

printf("Enter rows: ");
scanf("%d", &rows);

for(i=1; i<=rows; i++)
{
for(j=1;j<=i;j++) { printf("%d",j); } for(k=i-1;k>=1;k--)
{
printf("%d",k);
}
printf("\n");
}
return(0);
}``````

Output

``````Enter rows: 6
1
121
12321
1234321
123454321
12345654321``````

### 25. Hour Glass Star Pattern in C

width = 7

#### Preview

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

#### Logic

This star pyramid pattern combines a full pyramid and an inverted full pyramid star pattern. We can divide this star pattern into two sub-star patterns: upper and lower Half.

The upper half pattern will be a full inverted pyramid.

And the lower half pattern will be the full pyramid.

#### Pseudocode

``````n = INPUT("width of the hour glass");

//upper half Pyramid
FOR i 1 -> n:
FOR k 1 -> i:
PRINT(" ");
FOR j i->n;
PRINT("*");
PRINT(" ");

PRINT("\n");

//lower half Pyramid

FOR i n->1; i--:
FOR k 1->1; k++:
PRINT(" ");
FOR j i ->n; j++:
PRINT("*");
PRINT(" ");

PRINT("\n");``````

#### Hour Glass Star Pattern program in C

``````#include<stdio.h>

int main()
{
int n, i,j,k;
printf("Enter the width of the HourGlass: ");
scanf("%d",&n);

// for loop for printing
// upper half of the Hour Glass
for (i = 1; i <= n; i++) {

// printing i spaces at
// the beginning of each row
for (k = 1; k < i; k++)
printf(" ");

// printing i to rows value
// at the end of each row
for (j = i; j <= n; j++){
printf("*");

//space after every star print
printf(" ");
}
//new line for each row
printf("\n");
}

// for loop for printing
//the lower half of the Hour Glass
for (i = n - 1; i >= 1; i--)
{

// printing i spaces at the
// beginning of each row
for (k = 1; k < i; k++)
printf(" ");

// printing i to width number of * in each rows
for (j = i; j <= n; j++){
printf("*");
//space after every start print
printf(" ");
}

printf("\n");
}
return 0;
}
``````

Output

``````Enter the width of the HourGlass: 7
* * * * * * *
* * * * * *
* * * * *
* * * *
* * *
* *
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *``````

## Conclusion

Those were some of the most popular pattern programs in C. What are your favorite pattern programs? Let us know in the comments.

Buy the course here to hone your skills and master the C language.

People are also reading: