Mastering Filled Patterns: A Comprehensive Guide with Code Examples
Tags: c, coding, tutorial, beginners
Published: 2024-05-22 15:22:18


Welcome to our comprehensive guide on creating various filled patterns using loops in C programming! In this tutorial, we'll walk through step-by-step instructions on how to draw 18 different filled patterns. These patterns range from basic shapes like squares and triangles to more complex forms like diamonds, hexagons, and pentagons. Each pattern is created using nested loops, making it an excellent exercise for beginners to practice control structures in C. Let's dive in!
You can find all the code in our [GitHub repository](https://github.com/jithesh-poojari/c-programs/blob/main/fillled-patterns.c).

#### Table of Contents

1. [Introduction to Nested Loops](#introduction-to-nested-loops)
2. [Filled Square](#filled-square)
3. [Filled Right Triangle](#filled-right-triangle)
4. [Filled Inverted Right Triangle](#filled-inverted-right-triangle)
5. [Filled Right Aligned Triangle](#filled-right-aligned-triangle)
6. [Filled Right Aligned Inverted Triangle](#filled-right-aligned-inverted-triangle)
7. [Filled Right Pascal Triangle](#filled-right-pascal-triangle)
8. [Filled Left Pascal Triangle](#filled-left-pascal-triangle)
9. [Filled Equilateral Triangle](#filled-equilateral-triangle)
10. [Filled Inverted Equilateral Triangle](#filled-inverted-equilateral-triangle)
11. [Filled Pyramid](#filled-pyramid)
12. [Filled Inverted Pyramid](#filled-inverted-pyramid)
13. [Filled Diamond](#filled-diamond)
14. [Filled Hourglass](#filled-hourglass)
15. [Filled Rhombus](#filled-rhombus)
16. [Filled Parallelogram](#filled-parallelogram)
17. [Filled Hexagon](#filled-hexagon)
18. [Filled Pentagon](#filled-pentagon)
19. [Filled Inverted Pentagon](#filled-inverted-pentagon)
20. [Conclusion](#conclusion)

---

### Introduction to Nested Loops

Before we start with the patterns, it’s essential to understand the concept of nested loops. A nested loop is a loop inside another loop. This structure is particularly useful for handling multi-dimensional arrays and for generating patterns. In C, a typical nested loop structure looks like this:

```c
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        // Code to execute
    }
}
```  
---

### Filled Square

#### Explanation:
- The filled square pattern is one of the simplest patterns to create.
- It consists of `n` rows and `n` columns, where each cell contains the same character.
- We use two nested loops to iterate over each row and column, printing the character in each cell.

```c
int n = 5; // size of the square
char ch = '*';

printf("1. Filled Square:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
*  *  *  *  *  
*  *  *  *  *  
*  *  *  *  *  
*  *  *  *  *  
*  *  *  *  *  
```

---
### Filled Right Triangle

#### Explanation:
- The filled right triangle pattern starts with one character in the first row and increases by one character in each subsequent row.
- This pattern is achieved by using two nested loops. The outer loop controls the number of rows, and the inner loop controls the number of characters printed in each row.

```c
printf("2. Filled Right Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j <= i; j++) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
*  
*  *  
*  *  *  
*  *  *  *  
*  *  *  *  *   
```
---
### Filled Inverted Right Triangle

#### Explanation:
- The filled inverted right triangle pattern is the opposite of the filled right triangle.
- It starts with `n` characters in the first row and decreases by one character in each subsequent row.
- Similar to the filled right triangle, this pattern is created using two nested loops.

```c
printf("3. Filled Inverted Right Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n; j > i; j--) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
*  *  *  *  *  
*  *  *  *  
*  *  *  
*  *  
*  
```
---
### Filled Right Aligned Triangle

#### Explanation:
- The filled right aligned triangle pattern is similar to the filled right triangle, but the triangle is right-aligned.
- This pattern is achieved by adding spaces before each row, creating a right-aligned appearance.

```c
printf("4. Filled Right Aligned Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j <= i; j++) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
            *  
         *  *  
      *  *  *  
   *  *  *  *  
*  *  *  *  * 
```
---
### Filled Right Aligned Inverted Triangle

#### Explanation:
- The filled right aligned inverted triangle pattern is the opposite of the filled right aligned triangle.
- It starts with one character in the first row and increases by one character in each subsequent row, but the triangle is right-aligned.

```c
printf("5. Filled Right Aligned Inverted Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 1; j <= i; j++) {
        printf("   ");
    }
    for (int j = n; j > i; j--) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
*  *  *  *  *  
   *  *  *  *  
      *  *  *  
         *  *  
            *  
```
---
### Filled Right Pascal Triangle

#### Explanation:
- The filled right Pascal triangle pattern combines the right triangle and the inverted right triangle to form a Pascal-like triangle.
- The first half of the pattern is similar to the filled right triangle, and the second half is similar to the filled inverted right triangle.

```c
printf("6. Filled Right Pascal Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i + 1; j++) {
        printf("%c  ", ch);
    }
    printf("\n");
}
for (int i = 0; i < n; i++) {
    for (int j = n; j > i + 1; j--) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
*  
*  *  
*  *  *  
*  *  *  *  
*  *  *  *  *  
*  *  *  *  
*  *  *  
*  *  
*    
```
---
### Filled Left Pascal Triangle

#### Explanation:
- The filled left Pascal triangle pattern is similar to the filled right Pascal triangle, but it is left-aligned.
- The first half of the pattern is similar to the filled right aligned triangle, and the second half is similar to the filled right aligned inverted triangle.

```c
printf("7. Filled Left Pascal Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j < i + 1; j++) {
        printf("%c  ", ch);
    }
    printf("\n");
}

for (int i = 0; i < n; i++) {
    for (int j = 0; j < i + 1; j++) {
        printf("   ");
    }
    for (int j = n - 1; j > i; j--) {
        printf("%c  ", ch);
    }
    printf("\n");
}
```
#### Output:
```
            *  
         *  *  
      *  *  *  
   *  *  *  *  
*  *  *  *  *  
   *  *  *  *  
      *  *  *  
         *  *  
            *   
```
---
### Filled Equilateral Triangle

#### Explanation:
- The filled equilateral triangle pattern has a symmetrical shape with each row centered.
- To achieve this, we print spaces before each row to center the characters.

```c
printf("8. Filled Equilateral Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j <= i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
    * 
   * * 
  * * * 
 * * * * 
* * * * *  
```
---
### Filled Inverted Equilateral Triangle

#### Explanation:
- The filled inverted equilateral triangle pattern is the inverted version of the filled equilateral triangle.
- It starts with `n` characters at the base and decreases by one character per row, centered.

```c
printf("9. Filled Inverted Equilateral Triangle:\n");
for (int i = n - 1; i >= 0; i--) {
    for (int j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j <= i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
* * * * * 
 * * * * 
  * * * 
   * * 
    *   
```
---
### Filled Pyramid

#### Explanation:
- The filled pyramid pattern starts with one character at the top and increases by two characters per row, forming a symmetrical pyramid.
- We use spaces to center each row.

```c
printf("10. Filled Pyramid:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j < (2 * i + 1); j++) {
        printf("%c", ch);
    }
    printf("\n");
}
```
#### Output:
```
    *
   ***
  *****
 *******
*********  
```
---
### Filled Inverted Pyramid

#### Explanation:
- The filled inverted pyramid pattern is the opposite of the filled pyramid.
- It starts with `2 * n - 1` characters at the top and decreases by two characters per row, centered.

```c
printf("11. Filled Inverted Pyramid:\n");
for (int i = n; i > 0; i--) {
    for (int j = n - i; j > 0; j--) {
        printf(" ");
    }
    for (int j = 0; j < (2 * i - 1); j++) {
        printf("%c", ch);
    }
    printf("\n");
}
```
#### Output:
```
*********
 *******
  *****
   ***
    *  
```
---
### Filled Diamond

#### Explanation:
- The filled diamond pattern is formed by combining the filled equilateral triangle and the filled inverted equilateral triangle.
- It creates a symmetrical diamond shape.

```c
printf("12. Filled Diamond:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j <= i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j <= i; j++) {
        printf(" ");
    }
    for (int j = n - 1; j > i; j--) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *  
```
---
### Filled Hourglass

#### Explanation:
- The filled hourglass pattern combines an inverted equilateral triangle and an equilateral triangle, forming an hourglass shape.
- Each row is centered by adding spaces.

```c
printf("13. Filled Hourglass:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i; j++) {
        printf(" ");
    }
    for (int j = 0; j < (n - i); j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
for (int i = 1; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j <= i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
* * * * * 
 * * * * 
  * * * 
   * * 
    * 
   * * 
  * * * 
 * * * * 
* * * * *   
```
---
### Filled Rhombus

#### Explanation:
- The filled rhombus pattern consists of rows where each row is shifted to the right by spaces.
- This creates a diamond-like shape with equal length sides.

```c
printf("14. Filled Rhombus:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n - i - 1; j++) {
        printf(" ");
    }
    for (int j = 0; j < n; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
    * * * * * 
   * * * * * 
  * * * * * 
 * * * * * 
* * * * *  
```
---
### Filled Parallelogram

#### Explanation:
- The filled parallelogram pattern is created by shifting each row to the right.
- It looks like a rectangle leaning to one side.

```c
printf("15. Filled Parallelogram:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i; j++) {
        printf(" ");
    }
    for (int j = 0; j < n * 2; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
* * * * * * * * * * 
 * * * * * * * * * * 
  * * * * * * * * * * 
   * * * * * * * * * * 
    * * * * * * * * * *  
```
---
### Filled Hexagon

#### Explanation:
- The filled hexagon pattern has a wider middle section, with each row increasing and then decreasing in width.
- This creates a hexagonal shape.

```c
printf("16. Filled Hexagon:\n");
for (int i = 0; i < n / 2; i++) {
    for (int j = n / 2 - i; j > 0; j--) {
        printf(" ");
    }
    for (int j = 0; j < n + 1 * i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
for (int i = n / 2; i >= 0; i--) {
    for (int j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (int j = 0; j < n + i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * *  
```
---
### Filled Pentagon

#### Explanation:
- The filled pentagon pattern starts with one character at the top and increases, forming a wider base.
- This creates a pentagon-like shape.

```c
printf("17. Filled Pentagon:\n");
for (int i = 0; i < n + 1; i++) {
    for (int j = n; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j < (i + 1); j++) {
        printf(" %c", ch);
    }
    printf("\n");
}
for (int i = n / 2; i >= 0; i--) {
    for (int j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (int j = 0; j < n + i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
      *
     * *
    * * *
   * * * *
  * * * * *
 * * * * * *
* * * * * * * 
 * * * * * * 
  * * * * *  
```
---
### Filled Inverted Pentagon

#### Explanation:
- The filled inverted pentagon pattern is the inverted version of the filled pentagon.
- It starts with the wider base and decreases, forming an inverted pentagon shape.

```c
printf("18. Filled Inverted Pentagon:\n");
for (int i = 0; i <= n / 2; i++) {
    for (int j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (int j = 0; j < n + i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
for (int i = n + 1; i > 0; i--) {
    for (int j = n + 2; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j < i; j++) {
        printf("%c ", ch);
    }
    printf("\n");
}
```
#### Output:
```
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 
    * * * 
     * * 
      *   
```
---
### Conclusion

Learning to create these filled patterns in C is an excellent way to practice using nested loops and enhance your understanding of how loops work. By experimenting with different values and shapes, you can deepen your understanding of control structures in C and develop a keen eye for detail and logic. Whether you're a beginner or looking to brush up on your skills, these patterns provide a solid foundation for mastering loops in C programming.

We hope this guide has been helpful and encourages you to explore more complex patterns and designs. Happy coding!

For more tutorials and coding tips, be sure to subscribe to our blog and follow us on social media!