Printing patterns using C programs has always been an interesting problem domain. We can print different patterns like star patterns, pyramid patterns, Floyd's triangle, Pascal's triangle, etc. in C language. These problems require the knowledge of loops and if-else statements.
We will discuss the following example programs for printing patterns in the C programming language.
If you want to deep dive into loops and how they are applied in different scenarios, the C Programming Course Online with Data Structures provides extensive exercises and examples.
1. Right Half Pyramid Pattern
The right-half pyramid is nothing but a right-angle triangle whose hypotenuse is in the right direction. We can print the right half pyramid pattern using numbers, alphabets, or any other character like a star (*).
#include <stdio.h>
int main() {
int rows = 5;
// This loop for traverse
// pyramid from top to bottom
for (int i = 0; i < rows; i++) {
// Inner loop for printing
// character in each rows
for (int j = 0; j <= i; j++) {
printf("* ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main()
{
int rows = 5;
// This loop for traverse pyramid from top to bottom
for (int i = 0; i < rows; i++)
{
// Inner loop for printing character in each rows
for (int j = 0; j <= i; j++)
{
printf("%d ", j + 1);
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main()
{
int rows = 5;
// This loop for traverse
// pyramid from top to bottom
for (int i = 0; i < rows; i++) {
// Inner loop for printing
// character in each rows
for (int j = 0; j <= i; j++) {
printf("%c ", 'A' + j);
}
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * | 1 2 | A B
* * * | 1 2 3 | A B C
* * * * | 1 2 3 4 | A B C D
* * * * * | 1 2 3 4 5 | A B C D E
2. Left Half Pyramid Pattern
The Left Half Pyramid looks like a right-angled triangle with its hypotenuse facing the left. We can also print this pattern using a character, alphabets, or numbers.
#include <stdio.h>
int main()
{
int rows = 5;
// This loop for traverse pyramid from top to bottom
for (int i = 0; i < rows; i++)
{
// This loop for printing leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 1; j++)
{
printf(" ");
}
// This loop for printing * character in each row
for (int k = 0; k <= i; k++)
{
printf("* ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// This loop for traverse
// pyramid from top to bottom
for (int i = 0; i < rows; i++) {
// This loop for printing
// leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 2; j++) {
printf(" ");
}
// This loop for printing
// continious numbers in each row
for (int k = 0; k <= i; k++) {
printf("%d ", k + 1);
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// This loop for traverse
// pyramid from top to bottom
for (int i = 0; i < rows; i++) {
// This loop for printing
// leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 1; j++) {
printf(" ");
}
// This loop for printing alphabets
// in each row
for (int k = 0; k <= i; k++) {
printf("%c ", 'A' + k);
}
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * | 1 2 | A B
* * * | 1 2 3 | A B C
* * * * | 1 2 3 4 | A B C D
* * * * * | 1 2 3 4 5 | A B C D E
3. Full Pyramid Pattern
The Full Pyramid pattern looks similar to the Equilateral triangle. We can see this as the combination of the Left Half and Right Half pyramids patterns. The following example demonstrates how to print this pattern using alphabets, numbers, or a star (*).
#include <stdio.h>
int main()
{
int rows = 5;
// This loop to print all rows
for (int i = 0; i < rows; i++)
{
// Inner loop 1 to print white spaces for each row
for (int j = 0; j < 2 * (rows - i) - 1; j++)
{
printf(" ");
}
// Inner loop 2 to print star (*) character for each row
for (int k = 0; k < 2 * i + 1; k++)
{
printf("* ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// first loop to print all rows
for (int i = 0; i < rows; i++) {
// Inner loop 1 to print
// white spaces for each row
for (int j = 0; j < 2 * (rows - i) - 1; j++) {
printf(" ");
}
// Inner loop 2 to print alphabets
// for each row
for (int k = 0; k < 2 * i + 1; k++) {
printf("%c ", 'A' + k);
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// first loop to print all rows
for (int i = 0; i < rows; i++) {
// Inner loop 1 to print
// white spaces for each row
for (int j = 0; j < 2 * (rows - i) - 1; j++) {
printf(" ");
}
// inner loop 2 to print star numbers
// for each row
for (int k = 0; k < 2 * i + 1; k++) {
printf("%d ", k + 1);
}
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * * | 1 2 3 | A B C
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
4. Inverted Right Half Pyramid Pattern
This pattern is the 180° flipped version of the Right Half Pyramid Pattern we discussed earlier.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop to print all rows
for (int i = 0; i < rows; i++)
{
// Inner loop to print the * in each row
for (int j = 0; j < rows - i; j++)
{
printf("* ");
}
printf("\n");
}
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to print all rows
for (int i = 0; i < rows; i++) {
// Inner loop to print the
// numbers in each row
for (int j = 0; j < rows - i; j++) {
printf("%d ", j + 1);
}
printf("\n");
}
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to print all rows
for (int i = 0; i < rows; i++) {
// Inner loop to print the
// alphabets in each row
for (int j = 0; j < rows - i; j++) {
printf("%c ", 'A' + j);
}
printf("\n");
}
}
Output
* * * * * | 1 2 3 4 5 | A B C D E
* * * * | 1 2 3 4 | A B C D
* * * | 1 2 3 | A B C
* * | 1 2 | A B
* | 1 | A
5. Inverted Left Half Pyramid Pattern
This pattern is the 180° flipped version of the left half pyramid pattern we discussed earlier.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++)
{
// First Inner loop for printing white spaces
for (int j = 0; j < 2 * i; j++)
{
printf(" ");
}
// Second inner loop for printing star *
for (int k = 0; k < rows - i; k++)
{
printf("* ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++) {
// First Inner loop for
// printing white spaces
for (int j = 0; j < 2 * i; j++) {
printf(" ");
}
// Second inner loop for
// printing numbers
for (int k = 0; k < rows - i; k++) {
printf("%d ", k + 1);
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++) {
// First Inner loop for
// printing white spaces
for (int j = 0; j < 2 * i; j++) {
printf(" ");
}
// Second inner loop for
// printing alphabets
for (int k = 0; k < rows - i; k++) {
printf("%c ", 'A' + k);
}
printf("\n");
}
return 0;
}
Output
* * * * * | 1 2 3 4 5 | A B C D E
* * * * | 1 2 3 4 | A B C D
* * * | 1 2 3 | A B C
* * | 1 2 | A B
* | 1 | A
6. Inverted Full Pyramid Pattern
It is a 180° flipped version of the Full Pyramid Pattern we discussed earlier. We can see this as the combination of the Inverted Left Half and Inverted Right Half Pyramid Pattern we discussed earlier.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++)
{
// First inner loop printing leading white spaces
for (int j = 0; j < 2 * i; j++)
{
printf(" ");
}
// Second inner loop printing stars *
for (int k = 0; k < 2 * (rows - i) - 1; k++)
{
printf("* ");
}
printf("\n");
}
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++) {
// First inner loop printing
// leading white spaces
for (int j = 0; j < 2 * i; j++) {
printf(" ");
}
// Second inner loop for
// printing numbers
for (int k = 0; k < 2 * (rows - i) - 1; k++) {
printf("%d ", k + 1);
}
printf("\n");
}
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop for printing all rows
for (int i = 0; i < rows; i++) {
// First inner loop printing
// leading white spaces
for (int j = 0; j < 2 * i; j++) {
printf(" ");
}
// Second inner loop for
// printing alphabets
for (int k = 0; k < 2 * (rows - i) - 1; k++) {
printf("%c ", 'A' + k);
}
printf("\n");
}
}
Output
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * | 1 2 3 4 5 | A B C D E
* * * | 1 2 3 | A B C
* | 1 | A
7. Rhombus Pattern
The Rhombus pattern is similar to the square pattern, just that we have to add spaces before each line and their count decreases progressively with rows.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop to iterate through each row
for (int i = 0; i < rows; i++)
{
// First inner loop to print white spaces
for (int j = 0; j < rows - i - 1; j++)
printf(" ");
// Second inner loop to print * star in each row
for (int k = 0; k < rows; k++)
printf("* ");
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterate
// through each row
for (int i = 0; i < rows; i++) {
// First inner loop to print
// white spaces
for (int j = 0; j < rows - i - 1; j++)
printf(" ");
// Second inner loop to
// print number in each row
for (int k = 0; k < rows; k++)
printf("%d ", k + 1);
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// first outer loop to
// iterate through each row
for (int i = 0; i < rows; i++) {
// First inner loop to print
// white spaces
for (int j = 0; j < rows - i - 1; j++)
printf(" ");
// Second inner loop to
// print alphabet in each row
for (int k = 0; k < rows; k++)
printf("%c ", k + 'A');
printf("\n");
}
return 0;
}
Output
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * | 1 2 3 4 5 | A B C D E
8. Diamond Pattern
The Diamond Pattern is obtained by joining the Full Pyramid and Inverted Full Pyramid Pattern by their bases. We can also print this pattern using any character.
#include <stdio.h>
int main()
{
int n = 5;
// Outer loop to iterate through each row
for (int i = 0; i < 2 * n - 1; i++)
{
// assigning values to the comparator according to the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to print leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print stars *
for (int k = 0; k < 2 * n - comp; k++)
printf("* ");
printf("\n");
}
return 0;
}
#include <stdio.h>
int main(){
int n = 5;
// Outer loop to iterate
// through each row
for (int i = 0; i < 2 * n - 1; i++) {
// assigning values to the
// comparator according to
// the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to
// print leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// second inner loop to print number
for (int k = 0; k < 2 * n - comp; k++)
printf("%d ", k + 1);
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int n = 5;
// Outer loop to iterate
// through each row
for (int i = 0; i < 2 * n - 1; i++) {
// assigning values to the
// comparator according to
// the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to
// print leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print alphabet
for (int k = 0; k < 2 * n - comp; k++)
printf("%c ", k + 'A');
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * * | 1 2 3 | A B C
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * | 1 2 3 4 5 | A B C D E
* * * | 1 2 3 | A B C
* | 1 | A
9. Hourglass Pattern
Hourglass Pattern is a combination of the inverted full pyramid and full pyramid patterns but in the opposite sense to that of diamond pattern. Here we join them using their tip.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop to iterate each row
for (int i = 0; i < 2 * rows - 1; i++)
{
// Assigning comparator
int comp;
if (i < rows)
comp = 2 * i + 1;
else
comp = 2 * (2 * rows - i) - 3;
// First inner loop to print leading spaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print star *
for (int k = 0; k < 2 * rows - comp; k++)
printf("* ");
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterate each row
for (int i = 0; i < 2 * rows - 1; i++) {
// Assigning comparator
int comp;
if (i < rows)
comp = 2 * i + 1;
else
comp = 2 * (2 * rows - i) - 3;
// First inner loop to
// print leading spaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print number
for (int k = 0; k < 2 * rows - comp; k++)
printf("%d ", k + 1);
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterate each row
for (int i = 0; i < 2 * rows - 1; i++) {
// Assigning comparator
int comp;
if (i < rows)
comp = 2 * i + 1;
else
comp = 2 * (2 * rows - i) - 3;
// First inner loop to
// print leading spaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print alphabets
for (int k = 0; k < 2 * rows - comp; k++)
printf("%c ", k + 'A');
printf("\n");
}
return 0;
}
Output
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * | 1 2 3 4 5 | A B C D E
* * * | 1 2 3 | A B C
* | 1 | A
* * * | 1 2 3 | A B C
* * * * * | 1 2 3 4 5 | A B C D E
* * * * * * * | 1 2 3 4 5 6 7 | A B C D E F G
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
10. Hollow Square Pattern
The Hollow Square Pattern is a square with only the boundary lines. The space inside should be empty in this pattern.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop to iterator through each row
for (int i = 0; i < rows; i++)
{
// Inner loop to print * star in each row
for (int j = 0; j < rows; j++)
{
// Statement to check boundry condition
if (i > 0 && i < rows - 1 && j > 0 && j < rows - 1)
{
printf(" ");
}
else
{
printf("* ");
}
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterator
// through each row
for (int i = 0; i < rows; i++) {
// Inner loop to print number
// in each row
for (int j = 0; j < rows; j++) {
// Statement to check
// boundry condition
if (i > 0 && i < rows - 1 && j > 0
&& j < rows - 1) {
printf(" ");
}
else {
printf("%d ", j + 1);
}
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterator
// through each row
for (int i = 0; i < rows; i++) {
// Inner loop to print alphabet
// in each row
for (int j = 0; j < rows; j++) {
// statement to check
// boundry condition
if (i > 0 && i < rows - 1 && j > 0
&& j < rows - 1) {
printf(" ");
}
else {
printf("%c ", j + 'A');
}
}
printf("\n");
}
return 0;
}
Output
* * * * * | 1 2 3 4 5 | A B C D E
* * | 1 5 | A E
* * | 1 5 | A E
* * | 1 5 | A E
* * * * * | 1 2 3 4 5 | A B C D E
11. Hollow Full Pyramid Pattern
In the Hollow Pyramid pattern, we only have to print the boundary of the full pyramid.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop to iterate through each loop
for (int i = 0; i < rows; i++)
{
// First inner loop to print leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 1; j++)
printf(" ");
// Second inner loop to print stars * and inner whitespaces
for (int k = 0; k < 2 * i + 1; k++)
{
if (k == 0 || k == 2 * i || i == rows - 1)
printf("* ");
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterate
// through each loop
for (int i = 0; i < rows; i++) {
// First inner loop to
// print leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 1; j++)
printf(" ");
// Second inner loop to print
// numbers and innerwhitespaces
for (int k = 0; k < 2 * i + 1; k++) {
if (k == 0 || k == 2 * i || i == rows - 1)
printf("%d ", k + 1);
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop to iterate
// through each loop
for (int i = 0; i < rows; i++) {
// First inner loop to print
// leading whitespaces
for (int j = 0; j < 2 * (rows - i) - 1; j++)
printf(" ");
// Second inner loop to print
// alphabets and inner whitespaces
for (int k = 0; k < 2 * i + 1; k++) {
if (k == 0 || k == 2 * i || i == rows - 1)
printf("%c ", k + 'A');
else
printf(" ");
}
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * | 1 3 | A C
* * | 1 5 | A E
* * | 1 7 | A G
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
12. Hollow Inverted Full Pyramid Pattern
In this pattern, we print the inverted full pyramid with only boundary elements and remove the inside elements to make it hollow.
#include <stdio.h>
int main()
{
int rows = 5;
// Outer loop iterating through each row
for (int i = 0; i < rows; i++)
{
// First inner loop to print leading white space
for (int j = 0; j < 2 * i + 1; j++)
printf(" ");
// Second inner loop to print star * and hollow white space
for (int k = 0; k < 2 * (rows - i) - 1; k++)
{
if (k == 0 || k == 2 * (rows - i) - 2 || i == 0)
printf("* ");
else
{
printf(" ");
}
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop iterating
// through each row
for (int i = 0; i < rows; i++) {
// First inner loop to
// print leading white space
for (int j = 0; j < 2 * i + 1; j++) {
printf(" ");
}
// second inner loop to print number and hollow
// number and hollow white space
for (int k = 0; k < 2 * (rows - i) - 1; k++) {
if (k == 0 || k == 2 * (rows - i) - 2 || i == 0)
printf("%d ", k + 1);
else {
printf(" ");
}
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop iterating
// through each row
for (int i = 0; i < rows; i++) {
// First inner loop to print
// leading white space
for (int j = 0; j < 2 * i + 1; j++) {
printf(" ");
}
// Second inner loop to print
// alphabets and hollow white space
for (int k = 0; k < 2 * (rows - i) - 1; k++) {
if (k == 0 || k == 2 * (rows - i) - 2 || i == 0)
printf("%c ", k + 'A');
else
printf(" ");
}
printf("\n");
}
return 0;
}
Output
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
* * | 1 7 | A G
* * | 1 5 | A E
* * | 1 3 | A C
* | 1 | A
13. Hollow Diamond Pattern
This pattern is also similar to the Diamond Pattern but without the inner elements such that it appears hollow inside.
#include <stdio.h>
int main()
{
int n = 5;
// Outer loop to iterator through each row
for (int i = 0; i < 2 * n - 1; i++)
{
// assigning values to the comparator according to the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to print leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print star * and inner whitespaces
for (int k = 0; k < 2 * n - comp; k++)
{
if (k == 0 || k == 2 * n - comp - 1)
printf("* ");
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int n = 5;
// Outer loop to iterator
// through each row
for (int i = 0; i < 2 * n - 1; i++) {
// Assigning values to the
// comparator according to
// the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to print
// leading whitespaces
for (int j = 0; j < comp; j++) {
printf(" ");
}
// Second inner loop to print number and inner
// whitespaces
for (int k = 0; k < 2 * n - comp; k++) {
if (k == 0 || k == 2 * n - comp - 1)
printf("%d ", k + 1);
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int n = 5;
// Outer loop to iterator through each row
for (int i = 0; i < 2 * n - 1; i++) {
// Assigning values to the
// comparator according to
// the row number
int comp;
if (i < n)
comp = 2 * (n - i) - 1;
else
comp = 2 * (i - n + 1) + 1;
// First inner loop to print
// leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print
// alphabet and inner whitespaces
for (int k = 0; k < 2 * n - comp; k++) {
if (k == 0 || k == 2 * n - comp - 1)
printf("%c ", k + 'A');
else
printf(" ");
}
printf("\n");
}
return 0;
}
Output
* | 1 | A
* * | 1 3 | A C
* * | 1 5 | A E
* * | 1 7 | A G
* * | 1 9 | A I
* * | 1 7 | A G
* * | 1 5 | A E
* * | 1 3 | A C
* | 1 | A
14. Hollow Hourglass Pattern
The hollow hourglass is the pattern in which only the boundary of the hourglass pattern is visible.
#include <stdio.h>
int main()
{
int n = 5;
// Outer loop to iterate through each row
for (int i = 0; i < 2 * n - 1; i++)
{
// Assigning comparator
int comp;
if (i < n)
comp = 2 * i + 1;
else
comp = 2 * (2 * n - i) - 3;
// First inner loop to print leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print star * and inner whitespaces
for (int k = 0; k < 2 * n - comp; k++)
{
if (k == 0 || k == 2 * n - comp - 1 || i == 0 || i == 2 * n - 2)
printf("* ");
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main() {
int n = 5;
// Outer loop to iterate
// through each row
for (int i = 0; i < 2 * n - 1; i++) {
// Assigning comparator
int comp;
if (i < n)
comp = 2 * i + 1;
else
comp = 2 * (2 * n - i) - 3;
// First inner loop to print
// leading whitespaces
for (int j = 0; j < comp; j++)
printf(" ");
// Second inner loop to print
// number and inner whitespaces
for (int k = 0; k < 2 * n - comp; k++) {
if (k == 0 || k == 2 * n - comp - 1 || i == 0
|| i == 2 * n - 2)
printf("%d ", k + 1);
else
printf(" ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main(){
int n = 5;
// Outer loop to iterate
// through each row
for (int i = 0; i < 2 * n - 1; i++) {
// Assigning comparator
int comp;
if (i < n)
comp = 2 * i + 1;
else
comp = 2 * (2 * n - i) - 3;
// First inner loop to print
// leading whitespaces
for (int j = 0; j < comp; j++) {
printf(" ");
}
// Second inner loop to print
// alphabets and inner whitespaces
for (int k = 0; k < 2 * n - comp; k++) {
if (k == 0 || k == 2 * n - comp - 1 || i == 0
|| i == 2 * n - 2)
printf("%c ", k + 'A');
else
printf(" ");
}
printf("\n");
}
return 0;
}
Output
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
* * | 1 7 | A G
* * | 1 5 | A E
* * | 1 3 | A C
* | 1 | A
* * | 1 3 | A C
* * | 1 5 | A E
* * | 1 7 | A G
* * * * * * * * * | 1 2 3 4 5 6 7 8 9 | A B C D E F G H I
15. Floyd's Triangle
In Floyd's Triangle pattern, instead of starting the sequence of the numbers from 1 in each row, we print consecutive natural numbers. We can also print this pattern for alphabet sequence.
#include <stdio.h>
int main()
{
int rows = 4;
int n = 1;
// outer loop to print all rows
for (int i = 0; i < rows; i++)
{
// innter loop to print abphabet in each row
for (int j = 0; j <= i; j++)
{
printf("%d ", n++);
}
printf("\n");
}
return 0;
}
// C Program to print the Floyd's Triangle of Alphabets
#include <stdio.h>
int main()
{
int rows = 4;
char n = 'A';
// outer loop to print all rows
for (int i = 0; i < rows; i++) {
// innter loop to print abphabet in each row
for (int j = 0; j <= i; j++) {
printf("%c ", n++);
}
printf("\n");
}
return 0;
}
Output
1 | A
2 3 | B C
4 5 6 | D E F
7 8 9 10 | G H I J
16. Pascal's Triangle
A Pascal's Triangle is a triangular array of binomial coefficients where the nth row contains the binomial coefficients nC0, nC1, nC2, ……. nCn. The following example demonstrates one of the methods using which we can print Pascal's Triangle Pattern.
#include <stdio.h>
int main() {
int rows = 5;
// Outer loop for rows
for (int i = 1; i <= rows; i++) {
// Inner loop 1 for leading
// white spaces
for (int j = 0; j < rows - i; j++)
printf(" ");
// coefficient
int C = 1;
// Inner loop 2 for
// printing numbers
for (int k = 1; k <= i; k++) {
printf("%d ", C);
C = C * (i - k) / k;
}
printf("\n");
}
return 0;
}
Output
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1