C Program to Remove a Character from a String

C Program to Remove a Character from a String

By /

Removing characters from a string is a common operation in text processing, data cleaning, and formatting tasks. In C, strings are arrays of characters ending with a null terminator (\0). By scanning the string and selectively skipping unwanted characters, you can produce a cleaned-up version of the text.

In this tutorial, we will learn how to remove all occurrences of a specific character from a string. We will discuss multiple methods including loops and pointers. This will help you understand how strings are manipulated in C and how memory is handled during such operations.

Understanding the Problem

The goal is simple: given a string and a character to remove, produce a new string (or modify the original) that no longer contains that character.

For example, if the input string is "programming" and the character to remove is 'g', the resulting string should be "proramin".

The main idea is:

  1. Traverse the string character by character.
  2. If the current character matches the one to remove, skip it.
  3. Otherwise, copy it to the next position in the output string.
  4. Ensure the final string ends with a null terminator.

This problem demonstrates string traversal, conditional logic, and memory management in C.

Program 1: Removing a Character Using a Loop

The simplest method uses a loop to traverse the string and shift characters as needed.

#include <stdio.h>
#include <string.h>

int main() {

    char str[100];
    char target;
    int i, j;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");
    scanf("%c", &target);

    for (i = 0, j = 0; str[i] != '\0'; i++) {

        if (str[i] != target) {
            str[j++] = str[i];
        }

    }

    str[j] = '\0';

    printf("Updated string: %s\n", str);

    return 0;

}

In this method, j keeps track of the position in the resulting string. Characters not matching the target are copied forward, effectively removing the unwanted character.

Program 2: Using Pointers

Pointers allow traversal and modification without using array indices.

#include <stdio.h>
#include <string.h>

int main() {

    char str[100], *src, *dest;
    char target;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");
    scanf("%c", &target);

    src = str;
    dest = str;

    while (*src != '\0') {

        if (*src != target) {
            *dest = *src;
            dest++;
        }

        src++;

    }

    *dest = '\0';

    printf("Updated string: %s\n", str);

    return 0;

}

This method is efficient and highlights how C strings are simply sequences of memory locations. By moving dest only when characters are kept, we remove unwanted characters in-place.

Program 3: Case-Insensitive Removal

Sometimes, you may want to remove a character regardless of its case. Using tolower() from <ctype.h> allows case-insensitive removal.

#include <stdio.h>
#include <ctype.h>
#include <string.h>

int main() {

    char str[100];
    char target;
    int i, j;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");
    scanf("%c", &target);

    target = tolower(target);

    for (i = 0, j = 0; str[i] != '\0'; i++) {

        if (tolower(str[i]) != target) {
            str[j++] = str[i];
        }

    }

    str[j] = '\0';

    printf("Updated string (case-insensitive): %s\n", str);

    return 0;

}

This version ensures that 'A' and 'a' are considered the same, removing both if the target is 'a'.

Program 4: Using a Function for Modularity

We can wrap the logic inside a function so the removal process can be reused in different parts of a program.

#include <stdio.h>
#include <string.h>

void removeChar(char *str, char target) {

    char *src = str, *dest = str;

    while (*src != '\0') {

        if (*src != target) {
            *dest = *src;
            dest++;
        }

        src++;

    }

    *dest = '\0';

}

int main() {

    char str[100];
    char target;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");
    scanf("%c", &target);

    removeChar(str, target);

    printf("Updated string: %s\n", str);

    return 0;

}

This makes the code modular and easy to reuse in other projects.

Program 5: Using Recursion

Recursion processes one character at a time, skipping the target character and moving forward.

#include <stdio.h>
#include <string.h>

void removeCharRecursive(char *str, char target) {

    if (*str == '\0') return;

    if (*str == target) {

        int i = 0;

        while (str[i] != '\0') {
            str[i] = str[i + 1];
            i++;
        }

        removeCharRecursive(str, target); // Recheck current position

    } else {
        removeCharRecursive(str + 1, target);
    }

}

int main() {

    char str[100];
    char target;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");

    scanf("%c", &target);

    removeCharRecursive(str, target);

    printf("Updated string (recursion): %s\n", str);

    return 0;

}

This method is less efficient for long strings but demonstrates another programming paradigm.

Program 6: Using strchr() for Target Search

The standard library function strchr() finds the first occurrence of a character in a string. We can repeatedly use it to remove all occurrences.

#include <stdio.h>
#include <string.h>

int main() {

    char str[100];
    char target;
    char *pos;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    printf("Enter character to remove: ");
    scanf("%c", &target);

    while ((pos = strchr(str, target)) != NULL) {

        memmove(pos, pos + 1, strlen(pos)); // Shift characters left

    }

    printf("Updated string (using strchr): %s\n", str);

    return 0;

}

This approach leverages standard library functions, making the code concise and readable.

FAQs

Answering common questions about removing characters from strings in C.

1. Can I remove multiple different characters at once?
Yes. You can extend the logic to check against multiple target characters (for example, using strchr() to test membership) and skip them during traversal.

2. Can this program handle spaces and punctuation?
Yes. Any character, including spaces, punctuation, or digits, can be removed using the same logic.

3. How do I make the removal case-insensitive?
Use functions like tolower() or toupper() from <ctype.h> so that 'A' and 'a' are treated as the same.

4. How do I remove only the first occurrence of a character?
Add a break after the first removal to stop checking further characters.

5. Is in-place removal efficient?
Yes. Loop and pointer-based methods overwrite the string directly without allocating extra memory, making them efficient.

6. Which method is best for large strings?

  • Loops and pointers are simple and efficient.
  • The strchr() + memmove() method is concise and leverages the C standard library.
  • Recursion works but is less efficient for large strings due to function call overhead.

7. Can I remove all whitespace at once?
Yes. Instead of checking for a single character, use isspace() from <ctype.h> to remove spaces, tabs, and newlines together.

Conclusion

Removing a character from a string is a fundamental operation in C, useful in everything from cleaning user input to preparing data for processing. With loops, pointers, and case-insensitive logic, you can update strings directly and efficiently without extra memory.

We explored several methods: simple loops with index shifting, pointer-based traversal, case-insensitive removal using <ctype.h>, and a concise solution with strchr() and memmove(). Mastering these techniques not only strengthens your understanding of how strings work in C but also prepares you for advanced operations like search-and-replace, trimming whitespace, text formatting, and general string sanitization.

References & Additional Resources

A curated list of trusted books and tutorials for mastering string manipulation, pointers, and character handling in C.

  1. Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd Edition, Prentice Hall, 1988 – The foundational textbook covering strings, pointers, arrays, and essential C programming concepts.
  2. GeeksforGeeks: Deletion of character in String – Step-by-step methods to delete specific characters from a string in C.
  3. Tutorialspoint: C Strings – Overview of string declaration, initialization, and operations in C.
  4. Cprogramming.com: Pointers in C – Beginner-friendly guide to pointers and their applications in C programming.
  5. cplusplus.com: ctype.h Functions – Reference for C standard library functions used for character classification and transformation.

Related Posts

Scroll to Top