Patterns using Pointers in C | Advanced Concepts

Introduction

Pattern programming is a valuable exercise for developing logical thinking and mastering fundamental programming concepts in C. While traditional pattern programs primarily rely on nested loops, advanced pattern programming introduces techniques that involve arrays, pointers, memory management, and data traversal.

Among these concepts, pointers provide a powerful way to access and manipulate data in memory while generating patterns.

A pointer is a variable that stores the memory address of another object. By combining pointers with loops, pointer arithmetic, and array traversal, programmers can generate numeric patterns, reverse sequences, symmetric arrangements, and matrix-based patterns without relying exclusively on array indexing.

In this article, we will explore how pointers can be used in pattern programming, examine the logic behind pointer-based traversal, and implement several practical examples in C.

By the end of this tutorial, you will understand how pointers interact with pattern generation and how to use them safely and effectively in C programs.

1. Understanding Pointers in Pattern Programming

A pointer stores the address of an object in memory.

Consider the following example:

int num = 10;
int *ptr = #

Here:

• num is an integer variable containing the value 10.

• &num evaluates to the address of num.

• ptr stores that address.

• *ptr accesses the value stored at the address held by ptr.

The expression *ptr is called dereferencing the pointer.

Pointers are useful in pattern programming because they allow us to access values indirectly and move between consecutive elements of an array.

For example:

#include <stdio.h>

int main(void)
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    for (int i = 0; i < 5; i++)
    {
        printf("%d ", *(ptr + i));
    }

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

Output:

10 20 30 40 50

In this program, ptr points to the first element of the array. The expression *(ptr + i) accesses the element at index i.

Pointer arithmetic automatically accounts for the size of the pointed-to type. For an int *, adding one advances the pointer by one integer element, not by one byte.

This technique forms the foundation of pointer-based pattern programming.

2. Pattern 1: Printing a Right-Angled Numeric Triangle Using Pointers

Let us begin with a simple triangular pattern in which each successive row contains one additional element from an array.

Expected output

10
10 20
10 20 30
10 20 30 40
10 20 30 40 50

C program

#include <stdio.h>

int main(void)
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    int n = sizeof(arr) / sizeof(arr[0]);

    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j < i; j++)
        {
            printf("%d ", *(ptr + j));
        }

        printf("\n");
    }

    return 0;
}

Explanation

The pointer ptr points to the first element of the array.

The outer loop determines the number of rows, while the inner loop controls how many elements are printed in each row.

The expression:

*(ptr + j)

retrieves the element located j positions after the first array element.

During the first iteration, only the first element is printed. During the second iteration, the first two elements are printed. This process continues until all elements have been included.

The array itself remains unchanged. Only the pointer expression used to access its elements determines which values are printed.

Key concept: Pointer arithmetic can replace array indexing when accessing elements sequentially.

Time complexity: (O(n^2)), because the total number of printed elements is (n(n+1)/2).

Space complexity: (O(1)) auxiliary space, excluding the input array.

3. Pattern 2: Printing an Array in Reverse Triangular Order

Pointers can also be used to access array elements in a pattern whose rows decrease in length.

Expected output

10 20 30 40 50
10 20 30 40
10 20 30
10 20
10

C program

#include <stdio.h>

int main(void)
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    int n = sizeof(arr) / sizeof(arr[0]);

    for (int i = n; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            printf("%d ", *(ptr + j));
        }

        printf("\n");
    }

    return 0;
}

Explanation

In this program, the outer loop starts at n and decreases to 1.

For every iteration, the inner loop prints the first i elements using pointer arithmetic. As i decreases, fewer elements are printed.

For example, when i = 3, the expression *(ptr + j) is evaluated for j = 0, j = 1, and j = 2.

The result is:

10 20 30

The same pointer is reused throughout the program, demonstrating that a pointer does not necessarily need to move physically through memory to access different elements. Expressions such as ptr + j can calculate addresses relative to the original pointer.

Key concept: Changing loop boundaries changes the pattern without changing the underlying data.

Time complexity: (O(n^2)).

4. Pattern 3: Generating a Palindromic Numeric Pattern Using Pointers

A palindromic numeric pattern increases toward a central value and then decreases symmetrically.

Expected output

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

C program

#include <stdio.h>

int main(void)
{
    int arr[] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    int n = sizeof(arr) / sizeof(arr[0]);

    for (int i = 1; i <= n; i++)
    {
        /* Print the ascending sequence */
        for (int j = 0; j < i; j++)
        {
            printf("%d ", *(ptr + j));
        }

        /* Print the descending sequence */
        for (int j = i - 2; j >= 0; j--)
        {
            printf("%d ", *(ptr + j));
        }

        printf("\n");
    }

    return 0;
}

Explanation

This program constructs each row using two inner loops.

First loop: Ascending sequence

The first loop prints the elements from the beginning of the array up to the current row's maximum value.

Second loop: Descending sequence

The second loop accesses the preceding elements in reverse order.

The descending loop begins at i - 2 because the largest element has already been printed by the ascending loop. Starting at i - 1 would duplicate the central value.

For the fourth row, the first loop prints:

1 2 3 4

The second loop prints:

3 2 1

Together, they form:

1 2 3 4 3 2 1

Key concept: A pointer can be used to traverse the same data in both forward and reverse directions without modifying the array.

Time complexity: (O(n^2)).

5. Pattern 4: Generating Floyd's Triangle Using Pointers

Floyd's Triangle is a numeric pattern in which consecutive integers are arranged across successive rows.

Expected output

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

This example demonstrates how pointers can be used to populate an array and then traverse it to print a structured pattern.

C program

#include <stdio.h>

int main(void)
{
    int arr[15];
    int *ptr = arr;
    int value = 1;
    int index = 0;
    int n = 5;

    /* Store consecutive integers */
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            *(ptr + index) = value;
            index++;
            value++;
        }
    }

    /* Reset the index before printing */
    index = 0;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            printf("%d ", *(ptr + index));
            index++;
        }

        printf("\n");
    }

    return 0;
}

Explanation

The program separates array population from pattern printing.

During the first stage, the expression:

*(ptr + index) = value;

stores a consecutive integer in the array through the pointer.

The variable index determines the position to write, while value determines the number being stored.

Once all 15 elements have been initialized, the program resets index to zero and prints the stored numbers in triangular order.

For a triangle with n rows, the total number of elements is:

[
\frac{n(n+1)}{2}
]

Therefore, the array must have enough capacity to hold that many integers. In this example, the array has exactly 15 elements, which is sufficient for five rows.

Key concept: Pointers can be used for both writing to and reading from an array, allowing data generation and pattern display to be handled separately.

Time complexity: (O(n^2)).

6. Pattern 5: Printing a Two-Dimensional Matrix Using Pointers

Pointers can also be used to access elements of a two-dimensional array.

Consider a matrix containing four rows and four columns.

Expected output

1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

C program

#include <stdio.h>

int main(void)
{
    int a[4][4] = {
        {1,  2,  3,  4},
        {5,  6,  7,  8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    int (*ptr)[4] = a;

    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            printf("%-4d", ptr[i][j]);
        }

        printf("\n");
    }

    return 0;
}

Explanation

The declaration:

int (*ptr)[4] = a;

defines ptr as a pointer to an array of four integers. It is different from int *ptr, which points to a single integer.

The expression ptr[i][j] accesses the element at row i and column j.

Although this example uses familiar subscript notation, the pointer is responsible for identifying the appropriate row of the matrix.

For a two-dimensional array, pointer arithmetic must account for the size of each row. Incrementing ptr advances it to the next row, not to the next integer.

This distinction is important when working with multidimensional arrays in C.

Key concept: A pointer to an array provides a convenient way to traverse two-dimensional data while preserving the row structure.

Time complexity: (O(r \times c)), where r is the number of rows and c is the number of columns.

7. Pattern 6: Printing a Matrix in Spiral Order Using Pointers

Spiral traversal is an advanced matrix-processing technique in which elements are visited clockwise, beginning at the top-left corner and moving inward.

Consider the following matrix:

1   2   3   4
5   6   7   8
9  10  11  12
13 14  15  16

The spiral output is:

1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10

C program

#include <stdio.h>

int main(void)
{
    int a[4][4] = {
        { 1,  2,  3,  4},
        { 5,  6,  7,  8},
        { 9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    int (*ptr)[4] = a;

    int top = 0, bottom = 3;
    int left = 0, right = 3;

    while (top <= bottom && left <= right)
    {
        /* Traverse the top row */
        for (int j = left; j <= right; j++)
            printf("%d ", *(*(ptr + top) + j));

        top++;

        /* Traverse the right column */
        for (int i = top; i <= bottom; i++)
            printf("%d ", *(*(ptr + i) + right));

        right--;

        /* Traverse the bottom row */
        if (top <= bottom)
        {
            for (int j = right; j >= left; j--)
                printf("%d ", *(*(ptr + bottom) + j));

            bottom--;
        }

        /* Traverse the left column */
        if (left <= right)
        {
            for (int i = bottom; i >= top; i--)
                printf("%d ", *(*(ptr + i) + left));

            left++;
        }
    }

    printf("\n");

    return 0;
}

Explanation

The program maintains four boundaries that define the remaining unvisited region of the matrix.

The expression:

*(*(ptr + i) + j)

is equivalent to ptr[i][j].

It works in two stages:

1. ptr + i identifies row i.

2. Dereferencing that pointer gives the row, and adding j identifies the required column. The final dereference retrieves the integer stored at that location.

The algorithm traverses the top row, right column, bottom row, and left column. After each traversal, the corresponding boundary moves inward.

The conditions around the bottom-row and left-column traversals prevent duplicate visits when the remaining region contains only one row or one column.

Key concept: Pointer arithmetic can be used to implement structured matrix traversal while making the underlying memory-access operations explicit.

Time complexity: (O(r \times c)), because each matrix element is visited at most once.

Space complexity: (O(1)) auxiliary space, excluding the matrix itself.

8. Pattern 7: Generating a Pattern Using Dynamic Memory Allocation

Pointers become particularly useful when the size of a pattern is not known until runtime.

Dynamic memory allocation allows a program to request the required amount of memory while it is running.

The following example uses malloc() to allocate an array and generates a triangular numeric pattern.

Expected output

For an input of 4 rows:

1
2 3
4 5 6
7 8 9 10

C program

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int n;

    printf("Enter the number of rows: ");

    if (scanf("%d", &n) != 1 || n <= 0)
    {
        printf("Invalid number of rows.\n");
        return 1;
    }

    /* Prevent overflow in the triangular-size calculation */
    if (n > 65535)
    {
        printf("Number of rows is too large.\n");
        return 1;
    }

    size_t total = (size_t)n * (n + 1) / 2;

    int *ptr = malloc(total * sizeof(*ptr));

    if (ptr == NULL)
    {
        printf("Memory allocation failed.\n");
        return 1;
    }

    int value = 1;
    size_t index = 0;

    /* Populate the allocated array */
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            ptr[index++] = value++;
        }
    }

    /* Print the triangular pattern */
    index = 0;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            printf("%d ", ptr[index++]);
        }

        printf("\n");
    }

    free(ptr);

    return 0;
}

Explanation

The program asks the user to enter the number of rows and validates the input before allocating memory.

The total number of integers required is calculated using:

[
\text{total} = \frac{n(n+1)}{2}
]

The call to malloc() allocates enough memory to store the required number of integers.

If allocation fails, malloc() returns NULL, and the program exits without dereferencing the pointer.

After generating and printing the pattern, the program calls free(ptr) to release the allocated memory.

The size limit also ensures that the triangular-size calculation and the incrementing loop counter remain within their intended integer ranges. For applications accepting much larger inputs, additional checks for allocation-size overflow and resource limits should be included.

Key concept: Dynamic memory allocation allows pointer-based patterns to adapt to runtime input rather than relying on a fixed-size array.

Time complexity: (O(n^2)).

Space complexity: (O(n^2)), because the program stores all elements required by the triangular pattern.

9. Important Pointer Concepts in Pattern Programming

The examples above demonstrate several concepts that are essential for writing correct pointer-based programs.

9.1 Pointer arithmetic

Pointer arithmetic allows a pointer to move between elements of an array.

For example:

int arr[] = {10, 20, 30};
int *ptr = arr;

printf("%d\n", *ptr);
printf("%d\n", *(ptr + 1));
printf("%d\n", *(ptr + 2));

Output:

10
20
30

The expressions ptr + 1 and ptr + 2 refer to subsequent integer elements. They do not simply add one or two bytes to the address.

Pointer arithmetic is valid only within the same array object, or one position past its last element. The one-past pointer must not be dereferenced.

9.2 Difference between pointers and array indexing

The expression:

arr[i]

is equivalent to:

*(arr + i)

Both expressions access the element at index i.

However, an array name is not an ordinary modifiable pointer variable. In most expressions, it converts to a pointer to its first element, but it cannot be incremented or assigned a new address.

For example, this is valid:

int *ptr = arr;
ptr++;

But this is invalid:

arr++;

Understanding this distinction prevents common mistakes in pointer-based programs.

9.3 Pointers and two-dimensional arrays

A two-dimensional array is stored in row-major order in C, meaning that elements of each row occupy consecutive memory locations.

For an array declared as:

int a[3][4];

the expression:

int (*ptr)[4] = a;

creates a pointer to a row containing four integers.

The expression ptr + 1 advances to the next row, whereas ptr[0] + 1 advances to the next integer within the first row.

Choosing the correct pointer type is essential for reliable matrix traversal.

9.4 Pointers and dynamic memory

Dynamic allocation is helpful when the size of a pattern depends on user input.

The malloc() function allocates memory but does not initialize its contents. Every element must be assigned a value before it is read.

Memory allocated dynamically must also be released when it is no longer needed. Calling free() exactly once for a successfully allocated block helps prevent memory leaks.

10. Common Mistakes to Avoid

Pointer-based pattern programs require particular care because invalid memory access can lead to undefined behavior.

Common mistakes include:

• Incorrect pointer initialization: Never dereference an uninitialized pointer.

• Out-of-bounds access: Ensure pointer arithmetic remains within the allocated object.

• Incorrect dereferencing: Distinguish between a pointer's address and the value stored at that address.

• Confusing pointer types: A pointer to an integer and a pointer to an array of integers have different arithmetic behavior.

• Modifying the original pointer unnecessarily: Use a separate index or temporary pointer when the original address must be preserved.

• Reading uninitialized memory: Initialize every array element before using it in calculations.

• Ignoring allocation failures: Check whether malloc() returned NULL.

• Forgetting to release allocated memory: Call free() when dynamically allocated storage is no longer required.

• Integer overflow: Validate calculations used to determine array sizes and pattern values.

A good debugging practice is to verify the pointer's starting address, the current index, and the valid range of the target array before accessing an element.

11. Practice Problems

After working through the examples, try implementing these patterns independently.

Beginner level

1. Print an array in triangular order using pointer arithmetic.

2. Display an array in reverse order using a pointer.

3. Print a right-angled numeric triangle without using array-index notation.

Intermediate level

4. Generate a palindromic numeric pattern using pointers.

5. Store consecutive integers through a pointer and display them as Floyd's Triangle.

6. Traverse a two-dimensional array using a pointer to an array.

7. Print a matrix in zigzag row-wise order using pointers.

Advanced level

8. Implement clockwise spiral traversal using pointer arithmetic.

9. Generate a triangular pattern using dynamically allocated memory.

10. Use a pointer-to-pointer to access dynamically allocated rows of a matrix.

11. Create a pattern from a matrix after reversing each row through pointer manipulation.

12. Generate Pascal's Triangle using dynamically allocated storage.

For each problem, begin by determining the expected output and the relationship between elements. Then identify the correct pointer type, define the traversal boundaries, and verify that every memory access is valid.

Conclusion

Pattern programming using pointers in C introduces a more detailed understanding of memory access, address arithmetic, array traversal, and dynamic allocation.

Simple triangular patterns demonstrate how pointers can access sequential elements. Palindromic patterns illustrate forward and reverse traversal, while Floyd's Triangle shows how pointers can populate and reuse stored values. Matrix and spiral patterns demonstrate how pointer types and arithmetic interact with multidimensional data, and dynamic allocation makes it possible to construct patterns whose dimensions are determined at runtime.

The most important lesson is that pointers provide an alternative way to access and manipulate data, but they do not eliminate the need for careful indexing, memory-boundary checks, and appropriate data structures.

As you advance through C programming, experiment with equivalent array-index and pointer-based implementations. Understanding both approaches will strengthen your grasp of memory organization and prepare you for more advanced topics, including dynamic data structures, linked lists, and efficient matrix algorithms.

---

For all Pattern Programs list click here: 

…till the next post, bye-bye & take care