Remove All Characters In A String Except Alphabets In C Programming

When working with user input or data from external sources, strings often contain unwanted characters like numbers, symbols, or whitespace. Cleaning these strings to retain only alphabetic characters is a common preprocessing step. In this article, you will learn how to efficiently remove all non-alphabetic characters from a string using C programming.

Problem Statement

Many applications require data validation or text processing where only alphabetic content is relevant. For instance, extracting names from mixed input, sanitizing user-submitted text for display, or preparing data for linguistic analysis often necessitates removing digits, punctuation, and special symbols. Failing to clean strings can lead to incorrect parsing, display issues, or security vulnerabilities if input is not properly sanitized.

Example

Consider the following input string: H3ll0, W0rld! 123 The desired output after removing non-alphabetic characters would be: HelloWorld

Background & Knowledge Prerequisites

To follow this guide, a basic understanding of C programming concepts is recommended, including:

• Variables and Data Types: Especially char and char arrays (strings).
• Loops: for and while loops for iterating through strings.
• Conditional Statements: if statements for character checking.
• Standard Library Functions: Basic knowledge of stdio.h for input/output and ctype.h for character classification functions.

Use Cases or Case Studies

Removing non-alphabetic characters is a fundamental operation in various scenarios:

• Data Preprocessing for Machine Learning: Cleaning text data before training models for natural language processing (NLP) tasks.
• User Input Validation: Ensuring that names, IDs, or specific text fields only contain alphabetic characters.
• Text Search and Indexing: Normalizing text by stripping non-alphabets to improve search accuracy.
• Creating 'Slug' URLs: Converting a title like "My Article Title 1.0!" into "MyArticleTitle" for a clean URL.
• Password/Username Sanitization: While robust validation involves more, this step can be part of an initial filter for acceptable characters.

Solution Approaches

Approach 1: Using a Temporary String

Summary: This method involves iterating through the original string, checking each character. If a character is an alphabet, it is copied to a new, temporary string.

// Remove Non-Alphabets (Temporary String)
#include <stdio.h>
#include <string.h> // For strlen (not strictly needed for this loop, but good for general string ops)
#include <ctype.h>  // For isalpha

int main() {
    char originalString[] = "H3ll0, W0rld! 123";
    char cleanString[100]; // Assuming the cleaned string won't exceed 99 chars + null terminator
    int i, j;

    // Step 1: Initialize an index for the cleanString
    j = 0;

    // Step 2: Iterate through the original string
    for (i = 0; originalString[i] != '\\0'; i++) {
        // Step 3: Check if the character is an alphabet using isalpha()
        if (isalpha(originalString[i])) {
            // Step 4: If it's an alphabet, copy it to the cleanString
            cleanString[j] = originalString[i];
            j++; // Increment index for cleanString
        }
    }
    // Step 5: Null-terminate the cleanString to make it a valid C string
    cleanString[j] = '\\0';

    printf("Original string: %s\\n", originalString);
    printf("Cleaned string: %s\\n", cleanString);

    return 0;
}

Run

Sample Output:

Original string: H3ll0, W0rld! 123
Cleaned string: HelloWorld

Stepwise Explanation:

1. Declare originalString with the input and cleanString to store the result.
2. Initialize an index j to 0 for cleanString. This j will track the current position in the new string.
3. Loop through originalString character by character until the null terminator (\0) is encountered.
4. Inside the loop, use isalpha(originalString[i]) from ctype.h to check if the current character is an alphabet.
5. If isalpha() returns true (non-zero), copy originalString[i] to cleanString[j] and increment j.
6. After the loop finishes, add a null terminator (\0) at cleanString[j] to properly end the string.

Approach 2: In-Place Removal (Two-Pointer Approach)

Summary: This method modifies the string directly without using extra space for a temporary string. It uses two pointers: one for reading characters and one for writing valid characters back into the same string.

// Remove Non-Alphabets (In-Place)
#include <stdio.h>
#include <string.h> // For strlen (not strictly needed for this loop, but good for general string ops)
#include <ctype.h>  // For isalpha

int main() {
    char myString[] = "H3ll0, W0rld! 123";
    int readPtr, writePtr;

    // Step 1: Initialize writePtr to 0, which will point to the next available position for a valid character
    writePtr = 0;

    // Step 2: Iterate through the string using readPtr
    for (readPtr = 0; myString[readPtr] != '\\0'; readPtr++) {
        // Step 3: Check if the character is an alphabet
        if (isalpha(myString[readPtr])) {
            // Step 4: If it's an alphabet, copy it to the writePtr position
            myString[writePtr] = myString[readPtr];
            writePtr++; // Move writePtr forward
        }
    }
    // Step 5: Null-terminate the modified string at the writePtr position
    myString[writePtr] = '\\0';

    printf("Original string (after modification): %s\\n", myString);

    return 0;
}

Run

Sample Output:

Original string (after modification): HelloWorld

Stepwise Explanation:

1. Declare myString with the input. Initialize writePtr to 0. This pointer will indicate where the next valid character should be placed.
2. Iterate with readPtr from the beginning of myString until the null terminator.
3. Inside the loop, use isalpha(myString[readPtr]) to check if the character is an alphabet.
4. If it is an alphabet, copy myString[readPtr] to myString[writePtr] and then increment writePtr. This effectively overwrites non-alphabetic characters with subsequent alphabetic ones.
5. After the loop, place a null terminator (\0) at myString[writePtr] to correctly truncate the string at its new logical end.

Conclusion

Cleaning strings by removing non-alphabetic characters is a fundamental task in C programming, essential for data validation and text processing. Both the temporary string and in-place approaches effectively achieve this. The temporary string method is simpler to understand and implement but uses additional memory, while the in-place two-pointer approach is memory-efficient by modifying the string directly.

Summary

• Purpose: Remove non-alphabetic characters from a string.
• ctype.h: The isalpha() function is crucial for identifying alphabetic characters.
• Temporary String Approach:
• Creates a new string to store only alphabetic characters.
• Easy to implement and understand.
• Requires additional memory for the new string.
• In-Place Approach (Two-Pointer):
• Modifies the original string directly, saving memory.
• Uses two pointers: one to read, one to write valid characters.
• Generally more efficient for very large strings due to reduced memory allocation overhead.