Valid Number - Practice Coding Problems

Valid Number - Problem

String Hard

Given a string s, return whether s is a valid number.

For example, all the following are valid numbers: "2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789", while the following are not valid numbers: "abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53".

Formally, a valid number is defined using one of the following definitions:

An integer number followed by an optional exponent.
A decimal number followed by an optional exponent.

An integer number is defined with an optional sign '-' or '+' followed by digits.

A decimal number is defined with an optional sign '-' or '+' followed by one of the following definitions:

Digits followed by a dot '.'.
Digits followed by a dot '.' followed by digits.
A dot '.' followed by digits.

An exponent is defined with an exponent notation 'e' or 'E' followed by an integer number.

The digits are defined as one or more digits.

Input & Output

Example 1 — Valid Scientific Notation

$ Input: s = "3.14e-2"

› Output: true

💡 Note: Valid decimal number 3.14 followed by valid exponent e-2, representing 3.14 × 10^(-2) = 0.0314

Example 2 — Invalid Letter Character

$ Input: s = "1a"

› Output: false

💡 Note: Contains invalid character 'a' - only digits, signs, decimal point, and e/E are allowed

Example 3 — Valid Decimal Only

$ Input: s = ".5"

› Output: true

💡 Note: Valid decimal number - decimal point followed by digits is allowed

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input String

String to validate like "3.14e-2"

Parse Components

Identify sign, integer, decimal, exponent parts

Validation Result

Return true if all components are valid

Key Takeaway

🎯 Key Insight: A valid number follows predictable patterns that can be efficiently validated using a finite state machine

Asked in

F Facebook 35 G Google 28 a Amazon 22

Brief HTML summary: The key insight is to recognize that a valid number follows specific patterns that can be modeled as a finite state machine. Best approach is the state machine method which cleanly handles all transitions. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ State Machine Approach	O(n)	O(1)	Use a finite state machine to track valid transitions between number components
Character-by-Character Validation	O(n)	O(1)	Check each character against all possible rules and constraints

State Machine Approach — Algorithm Steps

Step 1: Define states (start, signed, integer, decimal, exponent, etc.)
Step 2: Process each character and transition between states
Step 3: Check if final state is accepting

Visualization

Tap to expand

Step-by-Step Walkthrough

Start State

Begin parsing, accept sign, digit, or decimal

Integer State

Processing integer part, can go to decimal or exponent

Final States

Valid ending states: integer, decimal, or exponent integer

Code -

solution.c — C

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

bool solution(char* s) {
    int len = strlen(s);
    if (len == 0) return false;
    
    int state = 0;
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        switch (state) {
            case 0: // start
                if (c == '+' || c == '-') {
                    state = 1;
                } else if (isdigit(c)) {
                    state = 2;
                } else if (c == '.') {
                    state = 3;
                } else {
                    return false;
                }
                break;
            case 1: // signed
                if (isdigit(c)) {
                    state = 2;
                } else if (c == '.') {
                    state = 3;
                } else {
                    return false;
                }
                break;
            case 2: // integer
                if (isdigit(c)) {
                    state = 2;
                } else if (c == '.') {
                    state = 4;
                } else if (c == 'e' || c == 'E') {
                    state = 5;
                } else {
                    return false;
                }
                break;
            case 3: // decimal_point
                if (isdigit(c)) {
                    state = 4;
                } else {
                    return false;
                }
                break;
            case 4: // decimal
                if (isdigit(c)) {
                    state = 4;
                } else if (c == 'e' || c == 'E') {
                    state = 5;
                } else {
                    return false;
                }
                break;
            case 5: // exp
                if (c == '+' || c == '-') {
                    state = 6;
                } else if (isdigit(c)) {
                    state = 7;
                } else {
                    return false;
                }
                break;
            case 6: // exp_signed
                if (isdigit(c)) {
                    state = 7;
                } else {
                    return false;
                }
                break;
            case 7: // exp_integer
                if (isdigit(c)) {
                    state = 7;
                } else {
                    return false;
                }
                break;
        }
    }
    
    return state == 2 || state == 4 || state == 7;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    
    bool result = solution(s);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant time state transitions

✓ Linear Growth

Space Complexity

O(1)

Only storing current state and a few variables

✓ Linear Space

28.0K 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

Constraints

Visualization

Related Problems

Common Approaches

State Machine Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler