Introduction

If a number arrives as English words such as "forty two" or "one hundred five", you should solve the problem in two phases: parse the words into an integer, then compare that integer against the target range. The range check is easy. The real challenge is building a parser that accepts the specific vocabulary and grammar you care about.

Parse First, Compare Second

Trying to decide whether a spelled-out number is "between" two values without converting it first makes the code much harder than necessary. Once you convert the phrase into an integer, the range logic becomes ordinary integer comparison.

That means the implementation should look like this:

1. normalize the input text,
2. parse the number words,
3. return an integer,
4. check min <= value <= max.

A Small English Number Parser

For common values, a direct word-to-number parser is enough. The example below supports basic units, tens, hundreds, and thousands.

1#include <iostream>
2#include <sstream>
3#include <stdexcept>
4#include <string>
5#include <unordered_map>
6
7int parse_spelled_number(const std::string& text) {
8    static const std::unordered_map<std::string, int> words{
9        {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4},
10        {"five", 5}, {"six", 6}, {"seven", 7}, {"eight", 8}, {"nine", 9},
11        {"ten", 10}, {"eleven", 11}, {"twelve", 12}, {"thirteen", 13},
12        {"fourteen", 14}, {"fifteen", 15}, {"sixteen", 16}, {"seventeen", 17},
13        {"eighteen", 18}, {"nineteen", 19}, {"twenty", 20}, {"thirty", 30},
14        {"forty", 40}, {"fifty", 50}, {"sixty", 60}, {"seventy", 70},
15        {"eighty", 80}, {"ninety", 90}
16    };
17
18    std::istringstream in(text);
19    std::string token;
20    int current = 0;
21    int total = 0;
22
23    while (in >> token) {
24        if (token == "hundred") {
25            current *= 100;
26        } else if (token == "thousand") {
27            total += current * 1000;
28            current = 0;
29        } else {
30            auto it = words.find(token);
31            if (it == words.end()) {
32                throw std::invalid_argument("unsupported token: " + token);
33            }
34            current += it->second;
35        }
36    }
37
38    return total + current;
39}
40
41bool spelled_number_in_range(const std::string& text, int min_value, int max_value) {
42    int value = parse_spelled_number(text);
43    return value >= min_value && value <= max_value;
44}
45
46int main() {
47    std::cout << std::boolalpha
48              << spelled_number_in_range("forty two", 40, 50) << '\n'
49              << spelled_number_in_range("one hundred five", 1, 100) << '\n';
50}

This keeps parsing and range-checking responsibilities separate.

Normalize Input Before Parsing

Real input is often messier than simple examples. You may encounter:

• hyphenated words such as "twenty-one",
• uppercase input such as "Ninety",
• filler words such as "and" in "one hundred and five".

Normalize before tokenizing.

1#include <algorithm>
2
3std::string normalize(std::string s) {
4    std::replace(s.begin(), s.end(), '-', ' ');
5    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
6        return static_cast<char>(std::tolower(c));
7    });
8    return s;
9}

If your domain allows "and", strip it during normalization or treat it as a token that does nothing.

Range Checking Is Trivial Once Parsed

After conversion, the range test is ordinary numeric logic.

1int value = parse_spelled_number(normalize("Seventy"));
2if (value >= 50 && value <= 100) {
3    std::cout << "in range\n";
4}

That is why correctness depends mostly on the parser, not the comparison.

Define Your Supported Grammar Explicitly

Do not pretend the parser handles all English number phrases unless it truly does. Requirements can expand quickly:

• negative numbers,
• decimals,
• millions or billions,
• ordinals such as "first" or "twentieth".

For production code, document the supported forms and reject the rest clearly. A strict parser is safer than a permissive one that guesses wrong.

Common Pitfalls

• Comparing word strings directly instead of converting them first.
• Ignoring normalization for hyphens and capitalization.
• Accepting unsupported tokens silently and producing wrong values.
• Forgetting that "hundred" and "thousand" modify the running value rather than add like normal words.
• Expanding input requirements without updating grammar rules deliberately.

Summary

• Parse the spelled-out number into an integer before doing any range logic.
• Normalize input so token matching stays simple and reliable.
• Keep the vocabulary and grammar explicit.
• Reject unsupported input clearly rather than guessing.
• Most of the problem is language parsing, not numeric comparison.