Programming languages are tools for creating software solutions and a platform for logical reasoning and artistic expression. Programmers explore creativity and improve their command over a programming language by creating pattern programs. This article will guide you through pattern program in C with explanation, which is an essential skill that plays a crucial role in enhancing logical reasoning and code optimisation.
A pattern can be defined as any symbol, number, or character that forms a particular design. The pattern programs in C use loops extensively to print various patterns on the console. They're not only a fun exercise but also a great way to solidify your understanding of control structures and nested loops in C programming.
These programs are especially common in interviews because they can demonstrate a candidate's understanding of logic and syntax. Therefore, practising these pattern programs in C for interviews could benefit your coding career and help you crack the basic coding round of many companies you’ll interview for.
Below are some common patterns often used in pattern programming, along with their code examples.
This pattern is printed using nested loops. The outer loop is responsible for the number of lines, while the inner loop prints asterisks for each line.
#include <stdio.h>
int main() {
int row, col, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for(row = 1; row <= numRows; ++row) {
for(col = 1; col <= row; ++col) {
printf("* ");
}
printf("\n");
}
return 0;
} |
If you input 5, this will output:
* * * * * * * * * * * * * * * |
This pattern is similar to the previous one, except spaces are printed before the asterisks to align them to the right.
#include <stdio.h>
int main() {
int row, col, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for(row = 1; row <= numRows; row++) {
for(col = row; col < numRows; col++) {
printf(" ");
}
for(col = 1; col <= row; col++) {
printf("*");
}
printf("\n");
}
return 0;
} |
For an input of 5, you will see:
* ** *** **** ***** |
This pattern prints a number of spaces before and after printing the asterisks to align them in a pyramid shape. This pyramid contains an odd number of asterisks in each row.
#include <stdio.h>
int main() {
int row, space, numRows, count = 0;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = 1; row <= numRows; ++row, count = 0) {
for (space = 1; space <= numRows - row; ++space) {
printf(" ");
}
while (count != 2 * row - 1) {
printf("* ");
++count;
}
printf("\n");
}
return 0;
} |
With an input of 5, this will output:
* * * * * * * * * * * * * * * * * * * * * * * * * |
This pattern is the reverse of the right half pyramid pattern. It starts with the maximum number of asterisks and decreases by one in each line.
#include <stdio.h>
int main() {
int row, column, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = numRows; row >= 1; --row) {
for (column = 1; column <= row; ++column) {
printf("* ");
}
printf("\n");
}
return 0;
} |
If you input 5, this will output:
* * * * * * * * * * * * * * * |
This pattern can be perceived as an inverted variant of the left half pyramid. It prints a number of spaces before the asterisks to align them to the right.
#include <stdio.h>
int main() {
int row, space, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = numRows; row >= 1; --row) {
for (space = 1; space <= numRows - row; ++space) {
printf(" ");
}
for (space = 1; space <= row; ++space) {
printf("*");
}
printf("\n");
}
return 0;
} |
For an input of 5, you will see:
***** **** *** ** * |
This pattern is an inverted variant of the full pyramid. It starts with the maximum number of asterisks and decreases by two in each line.
#include <stdio.h>
int main() {
int row, space, numRows, count = 0;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = numRows; row >= 1; --row, count = 0) {
for (space = 0; space < numRows - row; ++space) {
printf(" ");
}
while (count != 2 * row - 1) {
printf("* ");
++count;
}
printf("\n");
}
return 0;
} |
With an input of 5, this will output:
* * * * * * * * * * * * * * * * * * * * * * * * * |
This pattern is essentially a combination of a full pyramid and an inverted full pyramid.
#include <stdio.h>
int main() {
int row, col, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = 1; row <= numRows; row++) {
for (col = 1; col <= numRows - row; col++) {
printf(" ");
}
for (col = 1; col <= numRows; col++) {
printf("*");
}
printf("\n");
}
for (row = numRows - 1; row >= 1; row--) {
for (col = 1; col <= numRows - row; col++) {
printf(" ");
}
for (col = 1; col <= numRows; col++) {
printf("*");
}
printf("\n");
}
return 0;
} |
If you input 5, this will output:
***** ***** ***** ***** ***** ***** ***** ***** ***** |
This pattern combines the Full Pyramid Pattern and the Inverted Full Pyramid Pattern.
#include <stdio.h>
int main() {
int row, space, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = 1; row <= numRows; row++) {
for (space = row; space < numRows; space++) {
printf(" ");
}
for (space = 1; space <= (2 * row - 1); space++) {
printf("*");
}
printf("\n");
}
for (row = numRows - 1; row >= 1; row--) {
for (space = numRows; space > row; space--) {
printf(" ");
}
for (space = 1; space <= (2 * row - 1); space++) {
printf("*");
}
printf("\n");
}
return 0;
}
|
For an input of 5, you will see:
* *** ***** ******* ********* ******* ***** *** * |
The hourglass pattern combines the Inverted Full Pyramid Pattern and the Full Pyramid Pattern.
#include <stdio.h>
int main() {
int row, space, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = numRows; row >= 1; --row) {
for (space = 0; space < numRows - row; ++space) {
printf(" ");
}
for (space = 1; space <= 2 * row - 1; ++space) {
printf("*");
}
printf("\n");
}
for (row = 2; row <= numRows; ++row) {
for (space = 0; space < numRows - row; ++space) {
printf(" ");
}
for (space = 1; space <= 2 * row - 1; ++space) {
printf("*");
}
printf("\n");
}
return 0;
} |
If you input 5, this will output:
********* ******* ***** *** * *** ***** ******* ********* |
This pattern is essentially a square shape made of asterisks. The inner part of the square is hollow, and we use a condition to print spaces in place of asterisks.
#include <stdio.h>
int main() {
int row, col, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = 1; row <= numRows; row++) {
for (col = 1; col <= numRows; col++) {
if (row == 1 || row == numRows || col == 1 || col == numRows)
printf("*");
else
printf(" ");
}
printf("\n");
}
return 0;
} |
For an input of 5, you will see:
***** * * * * * * ***** |
This pattern is similar to the full pyramid pattern, but we print spaces instead of asterisks in the inner part.
#include <stdio.h>
int main() {
int numRows, i, j, space;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (i = 1; i <= numRows; i++) {
// Print spaces before the first asterisk in each row
for (space = 1; space <= numRows - i; space++) {
printf(" ");
}
// Print asterisks for the current row
for (j = 1; j <= (2 * i - 1); j++) {
if (j == 1 || j == (2 * i - 1) || i == numRows) {
printf("*");
} else {
printf(" ");
}
}
printf("\n");
}
return 0;
} |
For an input of 5, this will output:
* * * * * * * * * * * * * * * * |
This pattern is the inverted version of the hollow full pyramid pattern.
#include <stdio.h>
int main() {
int row, space, numRows;
printf("Enter the number of rows: ");
scanf("%d", &numRows);
for (row = numRows; row >= 1; --row) {
for (space = 0; space < numRows - row; ++space) {
printf(" ");
}
if (row == numRows) {
for (space = 1; space <= 2 * numRows - 1; ++space) {
printf("*");
}
} else {
printf("*");
for (space = 1; space <= 2 * row - 3; ++space) {
printf(" ");
}
if (row != 1) {
printf("*");
}
}
printf("\n");
}
return 0;
} |
If you input 5, this will output:
********* * * * * * * * |
This pattern combines the hollow full pyramid pattern and the hollow inverted full pyramid pattern.
#include <stdio.h>
int main() {
int l, m, numRows;
printf("Enter number of rows: ");
scanf("%d", &numRows);
numRows = (numRows + 1) / 2;
for (l = 1; l <= numRows; ++l) {
for (m = 1; m <= numRows - l; ++m) {
printf(" ");
}
if (l == 1) {
printf("*");
} else {
printf("*");
for (m = 1; m <= (l - 2) * 2 + 1; ++m) {
printf(" ");
}
printf("*");
}
printf("\n");
}
for (l = numRows - 1; l >= 1; --l) {
for (m = 1; m <= numRows - l; ++m) {
printf(" ");
}
if (l == 1) {
printf("*");
} else {
printf("*");
for (m = 1; m <= (l - 2) * 2 + 1; ++m) {
printf(" ");
}
printf("*");
}
printf("\n");
}
return 0;
} |
For an input of 5, you will see:
* * * * * * * * |
The hollow hourglass pattern is formed by combining the characteristics of both the hollow inverted full pyramid pattern and the hollow full pyramid pattern.
#include <stdio.h>
int main()
{
int l, m, n, numRows;
printf("Enter number of rows for the Hollow Hourglass Star Pattern: ");
scanf("%d", &numRows);
printf("Printing Hollow Hourglass Star Pattern\n");
for (l = 1; l <= numRows; l++)
{
for (m = 1; m < l; m++)
{
printf(" ");
}
for (n = l; n <= numRows; n++)
{
if (l == 1 || n == l || n == numRows)
{
printf("* ");
}
else
{
printf(" ");
}
}
printf("\n");
}
for (l = numRows - 1; l >= 1; l--)
{
for (m = 1; m < l; m++)
{
printf(" ");
}
for (n = l; n <= numRows; n++)
{
if (l == 1 || n == l || n == numRows)
{
printf("* ");
}
else
{
printf(" ");
}
}
printf("\n");
}
return 0;
} |
For an input of 5, this will output:
********* * * * * * * * * * * * * * ********* |
Floyd’s triangle is a right-angled triangle of natural numbers. It starts with 1 at the top and increases sequentially in each line.
#include <stdio.h>
int main() {
int l, m, numRows, num = 1;
printf("Enter number of rows: ");
scanf("%d", &numRows);
for (l = 1; l <= numRows; l++) {
for (m = 1; m <= l; ++m) {
printf("%d ", num);
++num;
}
printf("\n");
}
return 0;
} |
For an input of 5, you will see:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Pascal's triangle is a triangular arrangement of binomial coefficients, where each number in the triangle is the sum of the two numbers directly above it.
#include <stdio.h>
int main() {
int l, m, numRows, coefficient = 1;
printf("Enter number of rows: ");
scanf("%d", &numRows);
for (l = 0; l < numRows; l++) {
for (m = 0; m <= l; m++) {
if (m == 0 || l == 0)
coefficient = 1;
else
coefficient = coefficient * (l - m + 1) / m;
printf("%4d", coefficient);
}
printf("\n");
}
return 0;
}
|
For an input of 5, you will see:
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 |
That concludes the 16 pattern program examples in C. Each example includes a clear explanation and the expected output for a given input. These programs help you understand the logic used to create patterns, which is a frequently asked topic in C interviews and important in understanding control structures in C.
In this comprehensive guide, we have explored a variety of pattern programs in C, including number pattern program in C, star pattern program in C, and alphabetic pattern programs. Understanding these pattern programs is crucial for both beginners and those preparing pattern program in C for interview. The logic in these patterns forms the foundation of many complex problems you may encounter in your coding journey.
In order to continue making use of these skills and pave a successful career path in programming and coding, check out upGrad's Data Science and Analytics Bootcamp, a professionally mentored course designed to suit your learning pace and challenge your understanding to help you explore in-demand opportunities.
1. What is a pattern program in C?
A pattern program in C is a program leveraging nested loops to display various patterns of numbers, alphabets and special characters. These patterns help to understand the concept of looping and conditional statements.
2. How do I write a pattern program in C?
To write a pattern program in C, you need to understand the use of for loops and how to nest them. The outer loop is often responsible for the number of rows, while the inner loop is responsible for the number of elements in each row.
3. What is the significance of pattern programs in C interviews?
Pattern programs are popular in coding interviews because they demonstrate an understanding of control structures, nested loops, and how to manipulate the data to create different outputs. They provide insight into a candidate's problem-solving skills and their ability to write clean, efficient code.
Leave a Reply
Your email address will not be published. Required fields are marked *