Next Greater Element III - Practice Coding Problems

Next Greater Element III - Problem

Imagine you have a positive integer n, and you want to find the very next larger number that can be formed using the exact same digits. This is like rearranging the digits of a number to get the smallest possible number that's still greater than the original.

For example, if you have n = 123, the next greater number using the same digits would be 132. If you have n = 321, there's no way to rearrange the digits to make a larger number, so we return -1.

Key Requirements:

Use the exact same digits as the input number
Find the smallest number greater than n
Return -1 if no such number exists
Return -1 if the result doesn't fit in a 32-bit integer

This problem is essentially about finding the next permutation of digits in lexicographical order!

Input & Output

example_1.py — Basic Case

$ Input: n = 12

› Output: 21

💡 Note: The digits are [1,2]. The next greater permutation is [2,1], which gives us 21.

example_2.py — Multiple Digits

$ Input: n = 123

› Output: 132

💡 Note: The digits are [1,2,3]. The next greater permutation is [1,3,2], giving us 132.

example_3.py — No Solution

$ Input: n = 321

› Output: -1

💡 Note: The digits [3,2,1] are in descending order, so no greater permutation exists.

Visualization

Tap to expand

Understanding the Visualization

Find the Pivot

Scan from right to find the first digit that's smaller than its right neighbor

Find Swap Target

From right, find the smallest digit that's larger than the pivot

Swap Digits

Exchange the pivot with the target digit

Reverse Suffix

Reverse all digits to the right of the original pivot position

Key Takeaway

🎯 Key Insight: The next permutation is found by making the smallest possible change from right to left, ensuring we get the lexicographically next arrangement of digits.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to generate and process

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storing all n! permutations, each of length n

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 2³¹ - 1
The input n is a positive integer
Return -1 if no valid answer exists or result exceeds 32-bit integer limit

Asked in

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

The optimal solution uses the classic next permutation algorithm which runs in O(n) time. The key insight is to find the rightmost digit that can be increased (pivot), swap it with the smallest larger digit to its right, then reverse the remaining suffix to get the lexicographically next permutation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n! × n)	Generate all permutations and find the next greater one
Optimal Next Permutation Algorithm	O(n)	O(n)	Find pivot point and rearrange digits optimally using two-pointer technique

Brute Force (Generate All Permutations) — Algorithm Steps

Convert the number to a string to work with individual digits
Generate all possible permutations of the digits
Convert each permutation back to an integer
Sort all permutations and find the current number's position
Return the next permutation if it exists and fits in 32-bit integer

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to String

Convert number 123 to string '123'

Generate All Permutations

Create: 123, 132, 213, 231, 312, 321

Filter Valid Results

Keep only numbers > 123: 132, 213, 231, 312, 321

Find Minimum

Return the smallest: 132

Code -

solution.c — C

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

void swap(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

void generatePermutations(char* digits, int start, int len, int* result, int original) {
    if (start == len) {
        long long num = atoll(digits);
        if (num > original && num <= INT_MAX) {
            if (*result == -1 || num < *result) {
                *result = (int)num;
            }
        }
        return;
    }
    
    for (int i = start; i < len; i++) {
        swap(&digits[start], &digits[i]);
        generatePermutations(digits, start + 1, len, result, original);
        swap(&digits[start], &digits[i]);
    }
}

int nextGreaterElement(int n) {
    char digits[12];
    sprintf(digits, "%d", n);
    int len = strlen(digits);
    int result = -1;
    
    generatePermutations(digits, 0, len, &result, n);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to generate and process

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storing all n! permutations, each of length n

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 2³¹ - 1
The input n is a positive integer
Return -1 if no valid answer exists or result exceeds 32-bit integer limit

86.0K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler