Star Pattern In C {Symbol + Number + Alphabetic in C}

Mastering Star, Number, and Alphabet Patterns in C

Printing patterns is a fundamental programming exercise that hones your logical thinking and loop control skills.

In this article, you will learn how to create various patterns using symbols, numbers, and alphabets in C programming.

Problem Statement

The challenge lies in using nested loops to control the placement of characters and numbers, forming specific geometric patterns on the console. This task is crucial for developing a strong grasp of iteration and conditional logic, often appearing in coding interviews and foundational programming courses.

Example

Let's start with a simple right-angled triangle of stars:

*
**
***
****
*****

 

Background & Knowledge Prerequisites

To effectively follow this tutorial, you should have a basic understanding of:

• C Language Basics: Variables, data types, input/output (printf, scanf).
• Loops: Specifically for loops and the concept of nested for loops.
• ASCII Values: For generating alphabetic patterns.

 

No special imports or setup are needed beyond a standard C compiler (like GCC).

Use Cases or Case Studies

Pattern printing might seem like a purely academic exercise, but the underlying concepts are widely applicable:

1. Interview Preparation: Frequently used in technical interviews to assess a candidate's problem-solving and logical reasoning abilities.
2. Algorithmic Thinking: Enhances your ability to break down complex problems into smaller, manageable steps, a core skill in algorithm design.
3. Debugging Skills: Helps in understanding how loops execute and how to trace program flow, which is vital for debugging.
4. Game Development (Console): Basic console-based games often rely on character patterns to render simple graphics or UI elements.
5. Educational Tool: An excellent way for beginners to visualize the impact of nested loops and iteration.

 

Solution Approaches

We will explore three main categories of patterns: symbols (stars), numbers, and alphabets. For each, we'll demonstrate a common triangular pattern.

Approach 1: Symbol Patterns (Stars)

1. Right-Angled Triangle (Increasing Stars)

• Summary: Prints a right-angled triangle where each row has one more star than the previous.

• Code Example:

// Right-Angled Star Triangle
#include <stdio.h>

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

    // Step 1: Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Step 2: Inner loop for columns (stars in each row)
        // Prints 'i' number of stars in the i-th row
        for (j = 1; j <= i; j++) {
            printf("*");
        }
        // Step 3: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

*
    **
    ***
    ****
    *****

 

• Stepwise Explanation:

1. The outer for loop (i) iterates from 1 to rows (e.g., 5), controlling the number of rows.
2. The inner for loop (j) iterates from 1 to the current value of i. This ensures that in row i, exactly i stars are printed.
3. printf("") prints a single star.
4. printf("\n") moves the cursor to the next line after all stars for the current row have been printed, forming the next row.

 

2. Inverted Right-Angled Triangle (Decreasing Stars)

• Summary: Prints a right-angled triangle where each row has one fewer star than the previous, starting from the maximum.

• Code Example:

// Inverted Right-Angled Star Triangle
#include <stdio.h>

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

    // Step 1: Outer loop for rows
    for (i = rows; i >= 1; i--) { // Start from max rows, decrement
        // Step 2: Inner loop for columns (stars in each row)
        // Prints 'i' number of stars in the i-th row
        for (j = 1; j <= i; j++) {
            printf("*");
        }
        // Step 3: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

*****
    ****
    ***
    **
    *

 

• Stepwise Explanation:

1. The outer for loop (i) iterates from rows (e.g., 5) down to 1.
2. The inner for loop (j) iterates from 1 to the current value of i. This means the first row prints 5 stars, the second 4, and so on.
3. printf("") prints a single star.
4. printf("\n") moves to the next line for the subsequent row.

 

Approach 2: Number Patterns

1. Right-Angled Triangle (Increasing Numbers)

• Summary: Prints a triangle where each row shows numbers incrementing from 1 up to the row number.

• Code Example:

// Right-Angled Number Triangle (Increasing)
#include <stdio.h>

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

    // Step 1: Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Step 2: Inner loop for columns (numbers in each row)
        for (j = 1; j <= i; j++) {
            printf("%d ", j); // Print the column number
        }
        // Step 3: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

1
    1 2
    1 2 3
    1 2 3 4
    1 2 3 4 5

 

• Stepwise Explanation:

1. The outer for loop (i) controls the row number.
2. The inner for loop (j) controls the column number. Instead of printing a , we print the value of j (the current column index).
3. Because j increments from 1 to i, each row displays numbers from 1 up to its row number.

 

2. Right-Angled Triangle (Row Number Repetition)

• Summary: Prints a triangle where each row consists of the row number repeated.

• Code Example:

// Right-Angled Number Triangle (Row Repetition)
#include <stdio.h>

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

    // Step 1: Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Step 2: Inner loop for columns
        for (j = 1; j <= i; j++) {
            printf("%d ", i); // Print the row number
        }
        // Step 3: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

1
    2 2
    3 3 3
    4 4 4 4
    5 5 5 5 5

 

• Stepwise Explanation:

1. Similar to the previous number pattern, but inside the inner loop, we print the value of i (the current row index) instead of j.
2. This causes the row number to be repeated i times in each i-th row.

 

Approach 3: Alphabetic Patterns

1. Right-Angled Triangle (Increasing Alphabets)

• Summary: Prints a triangle where each row shows alphabets incrementing from 'A' up to a character determined by the row number.

• Code Example:

// Right-Angled Alphabet Triangle (Increasing)
#include <stdio.h>

int main() {
    int i, j, rows = 5;
    char ch;

    // Step 1: Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Step 2: Inner loop for columns (alphabets in each row)
        for (j = 1; j <= i; j++) {
            ch = 'A' + j - 1; // Convert column number to character (A, B, C...)
            printf("%c ", ch);
        }
        // Step 3: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

A
    A B
    A B C
    A B C D
    A B C D E

 

• Stepwise Explanation:

1. The outer loop (i) controls the row.
2. The inner loop (j) controls the column.
3. ch = 'A' + j - 1; uses ASCII arithmetic. 'A' is treated as an integer value. Adding j-1 to 'A' results in 'A' for j=1, 'B' for j=2, and so on.
4. printf("%c ", ch) prints the calculated character.

 

2. Right-Angled Triangle (Row Alphabet Repetition)

• Summary: Prints a triangle where each row consists of a single alphabet repeated, corresponding to the row number ('A' for row 1, 'B' for row 2, etc.).

• Code Example:

// Right-Angled Alphabet Triangle (Row Repetition)
#include <stdio.h>

int main() {
    int i, j, rows = 5;
    char ch;

    // Step 1: Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Step 2: Calculate the character for the current row
        ch = 'A' + i - 1;
        // Step 3: Inner loop for columns
        for (j = 1; j <= i; j++) {
            printf("%c ", ch); // Print the row character
        }
        // Step 4: Newline after each row
        printf("\\n");
    }
    return 0;
}

Run

• Sample Output:

A
    B B
    C C C
    D D D D
    E E E E E

 

• Stepwise Explanation:

1. The outer loop (i) determines the current row.
2. ch = 'A' + i - 1; calculates the character to be printed for the entire row (e.g., 'A' for row 1, 'B' for row 2).
3. The inner loop (j) simply prints this ch character i times.

 

Conclusion

Mastering pattern printing in C is a crucial step in becoming a proficient programmer. By understanding how to manipulate nested loops and leverage simple arithmetic with character ASCII values, you can create a wide array of visual patterns. This not only strengthens your control over program flow but also enhances your problem-solving skills, which are invaluable in any coding endeavor.

Summary

Here's a quick recap of the key takeaways:

• Nested Loops are Key: Outer loop controls rows, inner loop controls columns and what's printed.
• Variable Control: Incrementing the loop variable (j) or using the outer loop variable (i) determines the pattern's content.
• Star Patterns: Use printf("") within the inner loop.
• Number Patterns: Use printf("%d", j) for increasing numbers in a row, or printf("%d", i) for repeating the row number.
• Alphabet Patterns: Use ASCII arithmetic ('A' + value) and printf("%c", ch) to print characters based on loop variables.
• printf("\n"): Essential after each inner loop completes to move to the next line for the next row.

 

Quiz Time!

1. What is the primary role of the outer loop when printing patterns?

• To determine what character to print.
• To control the number of rows.
• To control the number of columns.
• To add a new line.

1. If you want to print a pattern like:

1
    2 3
    4 5 6

 

What kind of variable would you need to track, separate from the loop counters?

• A character variable.
• A static row counter.
• A global incrementing number counter.
• Another nested loop.

1. How would you modify the "Right-Angled Alphabet Triangle (Increasing)" code to print characters in decreasing order (e.g., E, E D, E D C)?

(Answers: 1. b, 2. c, 3. Hint: Change the inner loop's start/end condition and the character calculation.)