Valid Number - Practice Coding Problems

Valid Number - Problem

String Hard

Determining if a string represents a valid number is a classic parsing challenge that tests your understanding of formal grammar rules and string processing.

Given a string s, return true if s is a valid number, otherwise return false.

A valid number can be:

Integer: Optional sign followed by digits (e.g., "2", "-42", "+0089")
Decimal: Optional sign + digits with decimal point (e.g., "-0.1", "4.", ".9")
Scientific notation: Integer or decimal followed by 'e'/'E' and integer exponent (e.g., "2e10", "3.14E-5")

Valid examples: "2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7"

Invalid examples: "abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3"

Input & Output

example_1.py — Valid Integer

$ Input: s = "42"

› Output: true

💡 Note: Simple integer number with digits only is valid

example_2.py — Valid Scientific Notation

$ Input: s = "-123.45e+6"

› Output: true

💡 Note: Negative decimal number with positive exponent: -123.45 × 10^6

example_3.py — Invalid Format

$ Input: s = "1e"

› Output: false

💡 Note: Exponent notation requires digits after 'e', but none provided

Visualization

Tap to expand

Understanding the Visualization

Start State

Begin parsing, expecting sign, digit, or decimal point

Process Sign

If sign found, transition to signed state, expecting digit or decimal

Handle Digits

Accumulate digits, can transition to decimal or exponent

Decimal Processing

Handle decimal point and fractional digits

Exponent Handling

Process 'e'/'E' followed by optional sign and required digits

Validate End State

Ensure we end in a valid final state

Key Takeaway

🎯 Key Insight: A finite state machine elegantly handles all number validation rules by defining clear states and valid transitions, ensuring we process the string systematically in just one pass.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Multiple passes through string, but still linear

✓ Linear Growth

Space Complexity

O(1)

Only using a few boolean flags and counters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 20
s consists of only English letters (both uppercase and lowercase), digits (0-9), plus '+', minus '-', or dot '.'.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a finite state machine approach that processes the string in O(n) time with O(1) space. By defining clear states (START, SIGNED, DIGIT, DECIMAL, etc.) and valid transitions, we can elegantly validate number format in a single pass while handling all edge cases systematically.

Common Approaches

Approach	Time	Space	Notes
✓ Multiple Validation Checks	O(n)	O(1)	Check each validation rule separately with multiple passes
Finite State Machine (Optimal)	O(n)	O(1)	Use state machine to track valid transitions in one pass

Multiple Validation Checks — Algorithm Steps

Trim whitespace and handle empty strings
Check for invalid characters (anything not digit, sign, dot, e/E)
Validate sign placement (only at start or after e/E)
Count and validate decimal points (max 1, not in exponent)
Validate exponent notation (e/E must have digits before and after)
Ensure at least one digit exists in appropriate sections

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Check

Verify all characters are valid (digits, signs, dot, e/E)

Sign Validation

Ensure signs only appear at start or after exponent

Decimal Check

Count decimal points (maximum 1 allowed)

Exponent Validation

Check exponent format and position

Code -

solution.c — C

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

bool isNumber(char* s) {
    int len = strlen(s);
    if (len == 0) return false;
    
    // Trim whitespace
    int start = 0, end = len - 1;
    while (start < len && isspace(s[start])) start++;
    while (end >= 0 && isspace(s[end])) end--;
    
    if (start > end) return false;
    
    // Check for invalid characters
    for (int i = start; i <= end; i++) {
        char c = s[i];
        if (!isdigit(c) && c != '+' && c != '-' && 
            c != '.' && c != 'e' && c != 'E') {
            return false;
        }
    }
    
    // Check sign positions
    for (int i = start; i <= end; i++) {
        if (s[i] == '+' || s[i] == '-') {
            if (i != start && tolower(s[i-1]) != 'e') {
                return false;
            }
        }
    }
    
    // Check decimal points
    int dotCount = 0;
    for (int i = start; i <= end; i++) {
        if (s[i] == '.') dotCount++;
    }
    if (dotCount > 1) return false;
    
    // Check exponent
    int eCount = 0;
    int ePos = -1;
    for (int i = start; i <= end; i++) {
        if (tolower(s[i]) == 'e') {
            eCount++;
            ePos = i;
        }
    }
    if (eCount > 1) return false;
    
    if (eCount == 1) {
        if (ePos == start || ePos == end) return false;
        for (int i = ePos; i <= end; i++) {
            if (s[i] == '.') return false;
        }
    }
    
    // Check for at least one digit
    bool hasDigit = false;
    for (int i = start; i <= end; i++) {
        if (isdigit(s[i])) {
            hasDigit = true;
            break;
        }
    }
    if (!hasDigit) return false;
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Multiple passes through string, but still linear

✓ Linear Growth

Space Complexity

O(1)

Only using a few boolean flags and counters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 20
s consists of only English letters (both uppercase and lowercase), digits (0-9), plus '+', minus '-', or dot '.'.

24.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Multiple Validation Checks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler