Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Pascal Triangle Program in C

Last Updated on January 9, 2024 by Ankit Kochar

The Pascal Triangle is a mathematical marvel that exhibits fascinating properties and finds applications in various fields such as mathematics, computer science, and even in real-world problem-solving. It’s a triangular array of numbers where each number is the sum of the two numbers directly above it. Creating a program in C to generate Pascal’s Triangle not only demonstrates the beauty of mathematical patterns but also provides an excellent opportunity to delve into programming logic and iterative techniques.

## What is Pascal Triangle?

The pascal triangle is referred to as a mathematical concept that is named after the famous french mathematician Blaise Pascal. The Pascal Triangle is a triangular collection of numbers that displays the coefficients of an extended binomial expression. The numbers in Pascal’s triangle pattern are designed so that each number will be the product of the closest two numbers in the triangle’s upper row and that the number at each row’s ends will be 1.

It is a triangular array of binomial coefficients that is frequently used in algebraic, combinatorial, and probability theory issues. Typically, the Pascal triangle is used to determine things like probability binomial expansion factors and coin toss results.

### How to Write Pascal Triangle Program in C?

The triangle shown above is an example of a pascal triangle as you can see at all the extreme ends of the rows we have 1 and for the rest of the elements it is the sum of the two closest elements to it in the upper row. The row is numbered from 0 and all the rows contain n+1 elements in total where n represents the number of rows. The leftmost element of any row is the 1st element.
As the pascal triangle is a special representation of binomial coefficients and it contains the 1 on all the extreme edges of every row. We have various methods to write a pascal program in c.

### Approach 1 of writing a Pascal Program in C: Brute Force

In this method we will use two loops to calculate the binomial coefficients by using combination formulas and factorial to print the pascal program in c.

Algorithm
Now we will discuss the algorithm of the above-mentioned approach of writing a pascal program in c.

• Take the input from the user of the number of rows required in the pascal triangle.
• Run the outer loop from 0 to n.
• Run the inner loop from 0 to the outer loop.
• Now for every pair of values of the inner loop and outer loop we will find the corresponding binomial coefficient.
• To find the binomial coefficients we first need to find the combination and factorial.
• Now for every point add the value of two points closest to it in the above row.
• Repeat this operation and you will get your pascal triangle.

Code Implementation

```#include <stdio.h>

int fact(int n) //function to calculate factorial of a number
{
int a;

for (a = 1; n > 1; n--)
a *= n;

return a;
}

int combination(int n, int r)
{
return fact(n) / (fact(n - r) * fact(r)); }

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

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

for (i = 0; i <= rows; i++)
{
for (j = 0; j <= rows - i; j++)
printf("  ");

for (j = 0; j <= i; j++)
printf(" %3d", combination(i, j));

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

```

Input

``Enter Number of Rows: 4``

Output

``````           1   1
1   2   1
1   3   3   1
1   4   6   4   1``````

Explanation of the above code
In the above code we have written the pascal triangle program in c using the brute force.

Time Complexity
The time complexity of the above approach is O(n^3). As we are using the nested loops and also finding the binomial coefficient with them.

Space Complexity
We are not using any additional space hence the space complexity is O(1).

### Approach 2 of Pascal Triangle Program in C: Optimized Approach

Now we will discuss the optimal approach. Here we will use a two-dimensional array. That will store the details of the previous rows.

Algorithm
Now we will discuss the algorithm for the optimized approach.

• We will create a 2d array.
• We will travel in the 2d array.
• In the 2d array we will initialize the extreme ends with 1.
• We will add the value of the two elements of the above row which are closest to the current element.

Dry Run
Now we will see a dry run of the above approach.

• Step1: The 0th row will look like this:

• Step 2: Now add the value of the above elements to get the first row which will look like this:

• Step 3: The second row will contain (2+1=3 ) elements and will look like below

• Step 4: The 3rd row will contain 4 elements and the elements will look like this.

Code Implementation

```#include<stdio.h>

void pascalTriangle(int n) {
int arr[n][n];

for (int j = 0; j < n; j++) {
for (int i = 0; i <= j; i++) {
if (j == i || i == 0)
arr[j][i] = 1;

else
arr[j][i] = arr[j-1][i-1] + arr[j-1][i];
printf("%3d ", arr[j][i]);
}
printf("\n");
}
}
int main() {
int rows;
printf("Enter the number of rows: ");
scanf("%d",&rows);
pascalTriangle(rows);
return 0;
}```

Input

``Enter the number of rows:  6``

Output

`````` 1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5  10  10   5   1``````

Explanation of the above code
In the above approach we have seen an optimized version of the first approach. We are not calculating the binomial coefficient. We are just using two loops and adding the corresponding elements.

Time Complexity
The time complexity of the above approach is O(N^2). As we are using only two nested loops.

Space Complexity
The space complexity of the above approach is O(N^2). As we are using the extra 2d array.

### Approach 3 of Pascal Program in C: Space Optimized

Now we do not use any extra space so it will save the extra space complexity that we are using in the above approach.

Algorithm
Now we will discuss the space-optimized approach of the pascal triangle program in c.

• First we will take the input from the user.
• Now we will travel from 1 to n, n is the number of rows.
• For each row we will run an internal loop.
• Before the loop we will initialize both the extreme ends of the row by 1.
• Now we will use the internal loop to calculate the value of the middle elements.
• And after the calculator of each element the updated value will help us to calculate the further values.

Code Implementation

```#include <stdio.h>

void pascalTriangle(int n) {
for (int j = 1; j <= n; j++) {
int B = 1;
for (int i = 1; i <= j; i++) {
printf("%d ", B);
B = B * (j - i) / i;
}
printf("\n");
}
}
int main() {
int nRows;
printf("Enter number of rows: ");
scanf("%d", &nRows);
pascalTriangle(nRows);
return 0;
}

```

Input

``Enter number of rows: 6``

Output

``````1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1``````

Explanation of the above code
In the above approach we have just used some formulas to write the pascal triangle program in c. We are not using any additional space.

Time Complexity
The time complexity of the above approach is O(N^2). As we are using two nested loops.

Space Complexity
The space complexity of the above approach is O(1). We are not using any extra space.

### Uses of Pascal Triangle in C

Pascal triangle is a mathematical concept that has wide applications in various fields. Some of them are given below:

• The pascal triangle is used to calculate the binomial coefficients. And these coefficients are used in probability theory, statistics, etc.
• It is used to calculate the Fibonacci numbers. As we can use the diagonal elements to find the Fibonacci sequence.
• It is also used to generate random numbers but with uniform distribution.
• It is also used to calculate probabilities in statistical experiments.

Conclusion
Pascal’s Triangle remains a captivating mathematical construct, offering insights into various mathematical principles and serving as a valuable tool in both mathematical calculations and programming practices. Developing a Pascal Triangle Program in C not only reinforces programming skills but also illuminates the beauty of mathematical patterns and their practical applications.

## Frequently Asked Questions Based on Pascal triangle Program in C

Here are some of the frequently asked questions about the pascal triangle program in c.

1. Are there any alternative methods to generate Pascal’s Triangle apart from iterative approaches?
Yes, recursive methods can also be employed to generate Pascal’s Triangle, although iterative methods are commonly preferred due to their efficiency.

2. How is Pascal’s Triangle formed?
The triangle begins with the number 1 at the top. Each subsequent row is constructed by adding the number above and to the left with the number above and to the right, treating empty spaces as 0.

3. What are the applications of Pascal’s Triangle?
Pascal’s Triangle finds applications in mathematics, probability, algebra, and even computer science, particularly in binomial expansion, probability calculations, and algorithmic designs.

4. How can I create Pascal’s Triangle using a C program?
A C program for generating Pascal’s Triangle typically involves nested loops to calculate and display the numbers in the triangle based on the row and column indices.

5. What are the key features of Pascal’s Triangle?
Its properties include symmetry along the center column, binomial coefficient representation, the Fibonacci sequence embedded within it, and many more intriguing mathematical properties.

6. Can Pascal’s Triangle be used to solve real-world problems?
Yes, it can be utilized in various real-world scenarios, such as calculating combinations in probability, estimating coefficients in algebraic expansions, and optimizing algorithms in computer science.

7. Is there a limit to the size of Pascal’s Triangle that can be generated using a C program?
The limit to the size of Pascal’s Triangle that can be generated using a C program depends on the memory available to the system. However, larger triangles may require optimization to handle memory constraints efficiently.

8. How can understanding Pascal’s Triangle benefit programmers?
Understanding Pascal’s Triangle can enhance a programmer’s ability to comprehend mathematical patterns, leading to improved problem-solving skills and algorithm design techniques.