Vowel or Consonant Check: Programs in C, C++, Python, Java

A vowel checker returns three results, not two: vowel, consonant, or neither, because digits and special characters belong to neither category.

This distinction matters for placement coding tests that specify “handle all input types.” A program that outputs only “vowel” or “consonant” is incomplete; the third bucket is where non-alphabetic input lands.

What the Check Must Return

The English alphabet has 26 letters: 5 vowels (a, e, i, o, u) and 21 consonants. A character check assigns one of three labels:

Input type	Example inputs	Output
Vowel (lowercase)	a, e, i, o, u	Vowel
Vowel (uppercase)	A, E, I, O, U	Vowel
Consonant (any case)	b, z, B, Z, y, Y	Consonant
Digit	0, 1, 9	Neither vowel nor consonant
Special character	@, #, space	Neither vowel nor consonant
Non-ASCII letter	à, ü	Neither (or locale-dependent)

The vowel set has 10 members total. Programs handle this in two common ways: check all 10 values directly in a switch-case block, or convert to lowercase first and check only the 5 lowercase vowels.

The if-else Approach

The if-else method uses tolower() to collapse 10 checks into 5. The logic runs in three stages.

Algorithm for the if-else approach

• Step 1: Read character ch.
• Step 2: Compute lower = tolower(ch). For alphabetic input this returns the lowercase form; for digits and special characters it returns the character unchanged.
• Step 3: If lower is one of 'a', 'e', 'i', 'o', 'u' — print “Vowel” and stop.
• Step 4: Else if isalpha(ch) is true — print “Consonant” and stop.
• Step 5: Else — print “Neither vowel nor consonant”.

The isalpha(ch) check in Step 4 catches the remaining alphabetic characters that are not vowels, classifying them as consonants. Without it, digits and special characters would fall through incorrectly.

Trace for the if-else approach

• Input 'E':
  • lower = tolower('E') → 'e'
  • Is 'e' in {'a','e','i','o','u'}? Yes → output: Vowel
• Input 'z':
  • lower = tolower('z') → 'z'
  • Is 'z' in {'a','e','i','o','u'}? No
  • Is isalpha('z') true? Yes → output: Consonant
• Input '3':
  • lower = tolower('3') → '3' (digit, unchanged)
  • Is '3' in {'a','e','i','o','u'}? No
  • Is isalpha('3') true? No → output: Neither vowel nor consonant

The tolower() call on a digit is harmless: it returns the digit unchanged, so the isalpha guard on Step 4 still catches all non-letter input correctly.

The switch-case Approach

The switch-case method lists all 10 vowel values as separate case labels with fall-through. No conversion is needed because both cases are written explicitly.

Algorithm for the switch-case approach

• Step 1: Read character ch.
• Step 2: Enter switch block on ch.
• Step 3: If ch matches any of 'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U' — fall through to the vowel output: print “Vowel” and break.
• Step 4: Default branch — if isalpha(ch) is true, print “Consonant”; else print “Neither vowel nor consonant”.

Fall-through works because C and C++ execute consecutive case labels until a break is hit. Listing case 'a': case 'A': without a statement between them means both values land at the same output block.

Trace for the switch-case approach

• Input 'A':
  • Enter switch with ch = 'A'
  • Matches case 'A' — falls through to vowel block → output: Vowel
• Input 'm':
  • Enter switch with ch = 'm'
  • No case matches → default branch
  • isalpha('m') is true → output: Consonant
• Input '!':
  • No case matches → default branch
  • isalpha('!') is false → output: Neither vowel nor consonant

The switch-case version is more verbose (10 case labels vs. 5 comparisons) but avoids calling tolower(). Both approaches produce identical results for all ASCII input.

Programs in C, C++, Python, and Java

The four programs below use the if-else with tolower() design. This is the version most placement test questions ask for when they specify “handle uppercase input.”

C

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

int main() {
    char ch;
    printf("Enter a character: ");
    scanf(" %c", &ch);
    char lower = tolower(ch);
    if (lower == 'a' || lower == 'e' || lower == 'i' || lower == 'o' || lower == 'u') {
        printf("Vowel\n");
    } else if (isalpha(ch)) {
        printf("Consonant\n");
    } else {
        printf("Neither vowel nor consonant\n");
    }
    return 0;
}

The scanf(" %c", &ch) uses a leading space to skip any whitespace left in the input buffer from previous reads.

C++

#include <iostream>
#include <cctype>
using namespace std;

int main() {
    char ch;
    cin >> ch;
    char lower = tolower(ch);
    if (lower == 'a' || lower == 'e' || lower == 'i' || lower == 'o' || lower == 'u')
        cout << "Vowel" << endl;
    else if (isalpha(ch))
        cout << "Consonant" << endl;
    else
        cout << "Neither vowel nor consonant" << endl;
    return 0;
}

Python 3

ch = input("Enter a character: ")
if len(ch) != 1:
    print("Please enter a single character")
else:
    lower = ch.lower()
    if lower in ('a', 'e', 'i', 'o', 'u'):
        print("Vowel")
    elif ch.isalpha():
        print("Consonant")
    else:
        print("Neither vowel nor consonant")

Python’s ch.lower() is the equivalent of tolower() for single characters. The len(ch) != 1 guard handles the case where the user types more than one character.

Java

import java.util.Scanner;

public class VowelCheck {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char ch = sc.next().charAt(0);
        char lower = Character.toLowerCase(ch);
        if (lower == 'a' || lower == 'e' || lower == 'i' || lower == 'o' || lower == 'u')
            System.out.println("Vowel");
        else if (Character.isLetter(ch))
            System.out.println("Consonant");
        else
            System.out.println("Neither vowel nor consonant");
    }
}

Java uses Character.toLowerCase() and Character.isLetter() from the java.lang.Character class. Both are Unicode-aware by default, which affects behavior for non-ASCII input.

Edge Cases: Uppercase, Digits, Special Characters, and Non-ASCII

The table below summarizes behavior across all four programs for the input types that commonly trip up early drafts of this program.

Input	tolower() result	isalpha() / isalpha	Output
'A'	'a'	true	Vowel
'E'	'e'	true	Vowel
'y'	'y'	true	Consonant
'Y'	'y'	true	Consonant
'3'	'3'	false	Neither
' '	' '	false	Neither
'!'	'!'	false	Neither
'\n'	'\n'	false	Neither

Uppercase letters

Handled cleanly by tolower() in C and C++, ch.lower() in Python, and Character.toLowerCase() in Java. After conversion, the check reduces to five comparisons regardless of the original case. This is why the if-else approach with tolower() is generally preferred over listing all 10 vowel values separately.

The letter ‘y’

Standard programs classify ‘y’ and ‘Y’ as consonants. The letter sometimes functions as a vowel in spoken English (as in “gym” or “rhythm”) but it is not in the set {a, e, i, o, u}. Unless the problem statement explicitly says to treat ‘y’ as a vowel, the consonant classification is correct.

Digits and special characters

Both pass through tolower() unchanged and then fail the isalpha() test. The output is “Neither vowel nor consonant.” Common inputs to watch for: space (ASCII 32), newline (ASCII 10), digits 0 through 9 (ASCII 48 through 57), and punctuation marks.

Non-ASCII characters

This is where the four languages diverge. In C and C++, the standard tolower() function is defined for values in the range 0 to 127 (the ASCII range) plus the value EOF. Passing a character with a value outside this range is technically undefined behavior unless you set the locale with setlocale(LC_ALL, "") first. Without locale setup, characters like ‘à’ (value 224 in Latin-1) may produce incorrect results or, on some systems, crash.

Python handles this differently. According to the Python documentation for str.isalpha(), the method returns True if all characters in the string are alphabetic. This includes Unicode alphabetic characters: 'à'.isalpha() returns True, and 'ü'.isalpha() returns True. After calling .lower(), neither ‘à’ nor ‘ü’ appears in the vowel tuple ('a','e','i','o','u'), so both are classified as consonants. That may be the intended behavior, or it may not; it depends on whether the problem specifies English-only input.

Java’s Character.isLetter() is also Unicode-aware and returns True for ‘à’ and ‘ü’. The same consonant classification applies unless the vowel check is extended.

For a placement test where the problem says “the input is a single English alphabet character,” all four programs are correct and none of these edge cases apply. The non-ASCII handling matters for production applications that process user-submitted text.

Conditional character classification (read a character, check a condition, assign a category) is the same logic structure that drives intent classifiers in LLM pipelines, just applied at the sentence level rather than the byte level. The three-bucket pattern (vowel, consonant, neither) scales directly to routing user queries to different prompt branches. If that application of the same conditional logic interests you, TinkerLLM is where that step happens; the entry point is ₹499.

For other conditional-output programs that follow the same read-check-print pattern, see the program to generate a tsunami report. Pattern programs that test similar nested-loop control skills appear in palindrome pyramid pattern programs. Both types of questions show up in the programming sections of IT fresher coding rounds.