Program To Remove Vowels From A String In C Program

In this article, you will learn how to efficiently remove vowels from a given string in the C programming language. This task is fundamental in text processing and string manipulation.

Problem Statement

The challenge is to process an input string and produce a new string (or modify the existing one) where all occurrences of vowels (a, e, i, o, u, and their uppercase counterparts) have been eliminated. This problem is common in various text-based applications, from data filtering to simple text transformations.

Example

Consider the input string "Hello World". After removing all vowels, the expected output should be "Hll Wrld".

Background & Knowledge Prerequisites

To understand the solutions presented, readers should have a basic understanding of:

• C Language Fundamentals: Variables, data types, functions.
• Strings in C: How strings are represented as character arrays and terminated by a null character (\0).
• Loops: for and while loops for iterating through strings.
• Conditional Statements: if-else structures for decision-making.
• Character Manipulation: Basic operations like comparing characters.

Use Cases or Case Studies

Removing vowels from a string can be useful in several scenarios:

• Text Preprocessing: Normalizing text data for natural language processing (NLP) tasks, like creating simplified representations for analysis.
• Data Masking/Obfuscation: Simple methods to obscure sensitive information, although not a robust security measure.
• Educational Programming Exercises: A common problem for beginners to practice string manipulation, loops, and conditionals.
• Game Development (Text-Based): Creating puzzles or challenges where vowels are removed from words.
• Basic Data Filtering: Cleaning user input or data streams by removing specific character types.

Solution Approaches

We will focus on an efficient in-place solution that modifies the string directly, avoiding the need for an additional string buffer in most cases.

In-Place Vowel Removal

This approach iterates through the string, identifying non-vowel characters and copying them to an earlier position in the same string, effectively overwriting the vowels.

Summary: Traverse the string with two pointers: one for reading the original characters and one for writing non-vowel characters to the current string.

// Remove Vowels from String
#include <stdio.h>
#include <string.h> // For strlen
#include <ctype.h>  // For tolower

// Function to check if a character is a vowel
int isVowel(char c) {
    c = tolower(c); // Convert to lowercase for easier comparison
    return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}

// Function to remove vowels from a string (in-place)
void removeVowels(char* str) {
    // Step 1: Initialize two pointers: 'readIndex' to traverse the original string
    // and 'writeIndex' to place non-vowel characters in the modified string.
    int readIndex = 0;
    int writeIndex = 0;

    // Step 2: Loop through the string until the null terminator is encountered.
    while (str[readIndex] != '\\0') {
        // Step 3: Check if the character at 'readIndex' is a vowel.
        if (!isVowel(str[readIndex])) {
            // Step 4: If it's NOT a vowel, copy it to the 'writeIndex' position.
            str[writeIndex] = str[readIndex];
            // Step 5: Increment 'writeIndex' to prepare for the next non-vowel.
            writeIndex++;
        }
        // Step 6: Always increment 'readIndex' to move to the next character in the original string.
        readIndex++;
    }
    // Step 7: After the loop, null-terminate the modified string at 'writeIndex'.
    str[writeIndex] = '\\0';
}

int main() {
    char str1[] = "Hello World";
    char str2[] = "Programming Is Fun";
    char str3[] = "AEIOUaeiou";
    char str4[] = "Rhythm";

    printf("Original string: \\"%s\\"\\n", str1);
    removeVowels(str1);
    printf("After removing vowels: \\"%s\\"\\n\\n", str1);

    printf("Original string: \\"%s\\"\\n", str2);
    removeVowels(str2);
    printf("After removing vowels: \\"%s\\"\\n\\n", str2);

    printf("Original string: \\"%s\\"\\n", str3);
    removeVowels(str3);
    printf("After removing vowels: \\"%s\\"\\n\\n", str3);

    printf("Original string: \\"%s\\"\\n", str4);
    removeVowels(str4);
    printf("After removing vowels: \\"%s\\"\\n\\n", str4);

    return 0;
}

Run

Sample Output:

Original string: "Hello World"
After removing vowels: "Hll Wrld"

Original string: "Programming Is Fun"
After removing vowels: "Prgrmmng Is Fn"

Original string: "AEIOUaeiou"
After removing vowels: ""

Original string: "Rhythm"
After removing vowels: "Rhythm"

Stepwise Explanation:

1. isVowel(char c) function: This helper function takes a character, converts it to lowercase using tolower(), and then checks if it matches 'a', 'e', 'i', 'o', or 'u'. It returns 1 (true) if it's a vowel, 0 (false) otherwise.
2. removeVowels(char* str) function:
   • It initializes readIndex and writeIndex to 0. readIndex traverses the original string, while writeIndex points to where the next non-vowel character should be placed.

1. main() function: Demonstrates the usage of removeVowels with several test strings, printing both the original and modified versions.

Conclusion

Removing vowels from a string in C can be effectively achieved using an in-place modification approach. This method optimizes memory usage by performing the operation directly on the original string buffer, making it a good choice for many applications. By using two pointers, one to read and one to write, the process remains clear and efficient.

Summary

• The problem involves eliminating 'a', 'e', 'i', 'o', 'u' (and their uppercase forms) from a string.
• An efficient solution utilizes an in-place approach, modifying the string directly.
• A isVowel helper function simplifies vowel detection, handling both cases.
• Two pointers (readIndex and writeIndex) are used: readIndex iterates through the entire string, and writeIndex marks where non-vowel characters are placed.
• The modified string is null-terminated at the final writeIndex to ensure proper string handling.