Codestin Search App

Construct Smallest Number From DI String - Problem

🎯 Construct the Smallest Number From DI String

You're given a pattern string consisting of 'I' (increasing) and 'D' (decreasing) characters. Your mission is to construct the lexicographically smallest number string that follows this pattern perfectly!

The Rules:

Use digits 1-9, each digit at most once
If pattern[i] == 'I', then num[i] < num[i+1] (increasing)
If pattern[i] == 'D', then num[i] > num[i+1] (decreasing)
Return the smallest possible result

Example: Pattern "IIDD" → Result "12543"
✅ 1<2 (I), 2<5 (I), 5>4 (D), 4>3 (D)

Input & Output

example_1.py — Basic Pattern

$ Input: pattern = "IIDD"

› Output: "12543"

💡 Note: Start with 1, increase twice (1→2→5), then decrease twice (5→4→3). This gives us the smallest possible numbers while following the pattern.

example_2.py — All Decreasing

$ Input: pattern = "DDD"

› Output: "54321"

💡 Note: Since we need to decrease 4 times starting from the smallest possible number, we start with 5 and go down: 5→4→3→2→1.

example_3.py — Single Character

$ Input: pattern = "I"

› Output: "12"

💡 Note: Simple increase pattern: start with 1, increase to 2. This is the lexicographically smallest solution.

Visualization

Tap to expand

Understanding the Visualization

Scan Pattern

Read the DI pattern and identify segments

Use Stack

Stack holds positions waiting for number assignment

Handle 'I'

Pop stack and assign consecutive numbers

Handle 'D'

Push position onto stack (delay assignment)

Final Assignment

Assign remaining numbers to positions in stack

Key Takeaway

🎯 Key Insight: Use a stack to defer number assignment during decreasing sequences, then assign the smallest possible consecutive numbers when the sequence ends. This guarantees the lexicographically smallest valid result.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the pattern, each element pushed and popped once

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n elements in worst case (all decreasing)

⚡ Linearithmic Space

Constraints

1 ≤ pattern.length ≤ 8
pattern contains only 'I' and 'D'
The result will have pattern.length + 1 digits
Each digit from 1 to 9 can be used at most once

Asked in

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

The optimal solution uses a stack-based greedy approach to handle decreasing sequences efficiently. Key insight: when we encounter consecutive 'D's, we delay number assignment until we know the full length of the decreasing sequence, then assign the smallest possible consecutive numbers in reverse order. This ensures the lexicographically smallest result in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-based Greedy Approach (Optimal)	O(n)	O(n)	Use a stack to handle decreasing sequences efficiently, assigning minimal numbers

Stack-based Greedy Approach (Optimal) — Algorithm Steps

Initialize result array and a stack
Push indices onto stack as we scan the pattern
When we see 'I' or reach end, pop stack and assign consecutive numbers
This ensures we use minimal numbers for each segment
The stack naturally handles decreasing sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Push index 0 onto stack

Process 'D'

For decreasing pattern, just push next index

Process 'I'

For increasing pattern, pop stack and assign consecutive numbers

Final Assignment

Assign remaining numbers to indices in stack

Code -

solution.c — C

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

char* smallestNumber(char* pattern) {
    int n = strlen(pattern);
    int* result = (int*)malloc((n + 1) * sizeof(int));
    int* stack = (int*)malloc((n + 1) * sizeof(int));
    int stackSize = 0;
    
    stack[stackSize++] = 0;
    
    for (int i = 0; i < n; i++) {
        if (pattern[i] == 'I') {
            int num = i + 1 - stackSize + 1;
            while (stackSize > 0) {
                result[stack[--stackSize]] = num++;
            }
            stack[stackSize++] = i + 1;
        } else {
            stack[stackSize++] = i + 1;
        }
    }
    
    int num = n + 1 - stackSize + 1;
    while (stackSize > 0) {
        result[stack[--stackSize]] = num++;
    }
    
    static char res[10];
    for (int i = 0; i <= n; i++) {
        res[i] = '0' + result[i];
    }
    res[n + 1] = '\0';
    
    free(result);
    free(stack);
    return res;
}

int main() {
    char pattern[10];
    scanf("%s", pattern);
    
    int len = strlen(pattern);
    if (pattern[0] == '"') {
        for (int i = 1; i < len - 1; i++) {
            pattern[i-1] = pattern[i];
        }
        pattern[len-2] = '\0';
    }
    
    printf("%s\n", smallestNumber(pattern));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the pattern, each element pushed and popped once

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n elements in worst case (all decreasing)

⚡ Linearithmic Space

Constraints

1 ≤ pattern.length ≤ 8
pattern contains only 'I' and 'D'
The result will have pattern.length + 1 digits
Each digit from 1 to 9 can be used at most once

42.3K Views

Medium Frequency

~18 min Avg. Time

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

🎯 Construct the Smallest Number From DI String

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-based Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler