Check if Numbers Are Ascending in a Sentence

Check if Numbers Are Ascending in a Sentence - Problem

String Easy

Imagine you're reading a sentence and need to verify that any numbers mentioned are in strictly ascending order from left to right. This is exactly what this problem asks you to do!

Given a string s representing a sentence, you need to check if all the numbers in the sentence are strictly increasing from left to right. A sentence consists of tokens separated by single spaces, where each token is either:

A positive number (digits 0-9, no leading zeros)
A word (lowercase English letters)

Example: In the sentence "a puppy has 2 eyes 4 legs", we have numbers 2 and 4. Since 2 < 4, the numbers are in ascending order, so we return true.

Goal: Return true if all numbers in the sentence are in strictly ascending order, false otherwise. If there's only one number or no numbers, return true.

Input & Output

example_1.py — Basic Ascending

$ Input: s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles"

› Output: true

💡 Note: The numbers are 1, 3, 4, 6, 12 which are in strictly ascending order: 1 < 3 < 4 < 6 < 12

example_2.py — Not Ascending

$ Input: s = "hello world 5 x 1"

› Output: false

💡 Note: The numbers are 5 and 1. Since 5 > 1, they are not in ascending order

example_3.py — No Numbers

$ Input: s = "sunset is at seven forty five pm"

› Output: true

💡 Note: There are no numeric tokens in this sentence, so we return true by default

Constraints

3 ≤ s.length ≤ 200
s consists of lowercase English letters, spaces, and digits from 0 to 9
The number of tokens in s is between 2 and 100
The tokens are separated by a single space
No leading or trailing spaces
Numbers have no leading zeros

Visualization

Tap to expand

Understanding the Visualization

Start Scanning

Begin with last_number = -1 and scan tokens left to right

Find Number

When a numeric token is found, compare it with the last seen number

Validate Order

If current ≤ last, return false immediately; otherwise update last number

Continue or Return

Continue scanning or return true if all numbers are processed

Key Takeaway

🎯 Key Insight: We only need O(1) space by tracking just the last number seen, not storing all numbers!

Asked in

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

The optimal solution uses a single-pass approach with O(1) space complexity. We track only the last number seen and compare each new number with it. This allows for early termination when a violation is found, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Extract All Numbers Then Compare	O(n)	O(k)	Extract all numbers first, then check if they're in ascending order
One-Pass Tracking (Optimal)	O(n)	O(1)	Track only the last number seen while parsing the sentence once

Extract All Numbers Then Compare — Algorithm Steps

Split the sentence into tokens
Extract all numeric tokens and convert to integers
Store all numbers in a list
Iterate through the list comparing adjacent numbers
Return false if any number is not greater than the previous

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Sentence

Split sentence into tokens and identify numbers

Extract Numbers

Store all numbers in a separate list

Compare Adjacent

Check each pair of adjacent numbers

Code -

solution.c — C

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

bool areNumbersAscending(char* s) {
    int numbers[1000];
    int count = 0;
    char* token = strtok(s, " ");
    
    // Extract all numbers
    while (token != NULL) {
        if (isdigit(token[0])) {
            numbers[count++] = atoi(token);
        }
        token = strtok(NULL, " ");
    }
    
    // Check if numbers are strictly ascending
    for (int i = 1; i < count; i++) {
        if (numbers[i] <= numbers[i-1]) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the sentence once to extract numbers, then once through the numbers list

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of numeric tokens, we store them in a list

✓ Linear Space

24.5K Views

Medium Frequency

~8 min Avg. Time

890 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

Extract All Numbers Then Compare — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler