Monotone Increasing Digits - Practice Coding Problems

Monotone Increasing Digits - Problem

Math Greedy Medium

A number has monotone increasing digits if each digit is less than or equal to the next digit when reading from left to right. For example, 1234 and 1333 have monotone increasing digits, but 4321 and 1232 do not.

Given an integer n, your task is to find the largest number that is less than or equal to n and has monotone increasing digits. This is a classic greedy algorithm problem where we need to make optimal local choices to achieve the global maximum.

Key Challenge: When we encounter a digit that violates the monotone property (i.e., a digit is greater than the next digit), we need to strategically reduce it and set all subsequent digits to 9 to maximize the result.

Input & Output

example_1.py — Python

$ Input: n = 10

› Output: 9

💡 Note: The number 10 has digits [1, 0], where 1 > 0, so it doesn't have monotone increasing digits. The largest number ≤ 10 with monotone increasing digits is 9.

example_2.py — Python

$ Input: n = 1332

› Output: 1299

💡 Note: The number 1332 has digits [1, 3, 3, 2]. Since 3 > 2, we need to fix this. We decrement the first 3 to get 2, then set all following digits to 9, resulting in 1299.

example_3.py — Python

$ Input: n = 54321

› Output: 49999

💡 Note: This number has multiple violations (5>4>3>2>1). Starting from right, we find 2>1, fix it to get 54319. Then 3>1, fix to get 54299. Continue this process until we get 49999.

Constraints

0 ≤ n ≤ 10⁹
The result will always fit in a 32-bit integer
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Inspect the Blueprint

Start with your target staircase design (the input number)

Scan for Problems

Check from right to left for steps that violate the height rule

Fix Violations

When you find a step that's too high, lower it by one unit

Maximize Remaining

Set all steps to the right to maximum height (9) to get the tallest valid staircase

Key Takeaway

🎯 Key Insight: Work backwards from right to left. When you find a violation, make the minimal fix (decrement by 1) and maximize everything to the right (set to 9). This greedy approach guarantees the largest possible valid result.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses a greedy approach with O(d) time complexity. Convert the number to a string, scan from right to left to find violations where digits[i] > digits[i+1], then decrement the violating digit and set all subsequent digits to 9. This ensures we get the largest possible number with monotone increasing digits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Decrement and Check)	O(n * d)	O(1)	Start from n and check each number downward until we find one with monotone increasing digits
Greedy Algorithm (Optimal)	O(d)	O(d)	Convert to string, find violations from right to left, and fix them greedily

Brute Force (Decrement and Check) — Algorithm Steps

Start with the given number n
Check if current number has monotone increasing digits
If yes, return the current number
If no, decrement by 1 and repeat
Continue until we find a valid number

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n=1332

Check if 1332 has monotone increasing digits

Find violation

3 > 2 violates monotone property

Decrement to 1331

Check if 1331 has monotone increasing digits

Success

1331 satisfies monotone increasing property

Code -

solution.c — C

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

int isMonotone(int num) {
    char s[12];
    sprintf(s, "%d", num);
    int len = strlen(s);
    for (int i = 0; i < len - 1; i++) {
        if (s[i] > s[i + 1]) {
            return 0;
        }
    }
    return 1;
}

int monotoneIncreasingDigits(int n) {
    while (n >= 0) {
        if (isMonotone(n)) {
            return n;
        }
        n--;
    }
    return 0;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", monotoneIncreasingDigits(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

In worst case, we might check O(n) numbers, and each check takes O(d) time where d is number of digits

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

42.0K Views

Medium Frequency

~18 min Avg. Time

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

Brute Force (Decrement and Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler