DI String Match - Practice Coding Problems

DI String Match - Problem

DI String Match - Reconstruct a Permutation from Instructions

You're given a string s of length n containing only characters 'I' (Increase) and 'D' (Decrease). Your task is to construct a permutation of integers from [0, 1, 2, ..., n] that satisfies the given pattern.

Rules:
• If s[i] == 'I', then perm[i] < perm[i+1] (next number should be larger)
• If s[i] == 'D', then perm[i] > perm[i+1] (next number should be smaller)

Example: For s = "IDID", one valid permutation is [0,4,1,3,2]
• Position 0: 0 < 4 ✓ (I)
• Position 1: 4 > 1 ✓ (D)
• Position 2: 1 < 3 ✓ (I)
• Position 3: 3 > 2 ✓ (D)

Return any valid permutation that matches the pattern.

Input & Output

example_1.py — Basic Pattern

$ Input: s = "IDID"

› Output: [0,4,1,3,2]

💡 Note: We need a permutation where positions follow I-D-I-D pattern. Using greedy approach: I→use min(0), D→use max(4), I→use min(1), D→use max(3), last→remaining(2). Verification: 0<4✓, 4>1✓, 1<3✓, 3>2✓

example_2.py — All Increasing

$ Input: s = "III"

› Output: [0,1,2,3]

💡 Note: All characters are 'I' (increase), so we need strictly increasing sequence. Greedy approach always picks minimum available: 0,1,2,3. This is the natural ascending order.

example_3.py — All Decreasing

$ Input: s = "DDI"

› Output: [3,2,0,1]

💡 Note: Pattern is D-D-I. Start with max for decreasing: D→3, D→2, I→0 (need room to increase), last→1. Verification: 3>2✓, 2>0✓, 0<1✓

Visualization

Tap to expand

Understanding the Visualization

Setup Trail Markers

You have elevation markers 0,1,2,3,4 and path instructions I-D-I-D

Smart Placement Strategy

Keep lowest and highest unused markers ready for strategic placement

Handle Uphill (I)

When trail goes uphill, use lowest marker to maximize future options

Handle Downhill (D)

When trail goes downhill, use highest marker to ensure room for drops

Complete the Trail

Place final marker and verify the path follows all requirements

Key Takeaway

🎯 Key Insight: By strategically choosing extreme values (minimum for increases, maximum for decreases), we guarantee that future constraints can always be satisfied, leading to an optimal O(n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables plus output array

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'I' or 'D'
The permutation must contain all integers from 0 to n exactly once

Asked in

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

The optimal solution uses a greedy two-pointer approach in O(n) time. Maintain low and high pointers for available min/max values. For 'I', use the minimum available number to leave room for future increases. For 'D', use the maximum available number to allow future decreases. This strategy guarantees a valid permutation while being optimal in both time and space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Greedy (Optimal)	O(n)	O(1)	Use two pointers to greedily assign minimum and maximum available numbers
Brute Force (Generate All Permutations)	O((n+1)! × n)	O(n)	Generate all possible permutations and check which one satisfies the DI pattern

Two Pointers Greedy (Optimal) — Algorithm Steps

Initialize low = 0 and high = n (representing available number range)
For each character in the string:
If current char is 'I': assign low to result, increment low
If current char is 'D': assign high to result, decrement high
For the last position, assign the remaining number (low == high)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

low=0, high=4 for string "IDID"

Process 'I'

Need increase → use low=0, update low=1

Process 'D'

Need decrease → use high=4, update high=3

Continue Pattern

Final result: [0,4,1,3,2]

Code -

solution.c — C

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

int* diStringMatch(char* s, int* returnSize) {
    int n = strlen(s);
    *returnSize = n + 1;
    int* result = (int*)malloc((*returnSize) * sizeof(int));
    
    int low = 0, high = n;
    int index = 0;
    
    for (int i = 0; i < n; i++) {
        if (s[i] == 'I') {
            result[index++] = low;
            low++;
        } else { // s[i] == 'D'
            result[index++] = high;
            high--;
        }
    }
    
    // Add the last remaining number
    result[index] = low; // low == high at this point
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* clean_s = malloc(strlen(s) + 1);
    int j = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != '"' && s[i] != '\n') {
            clean_s[j++] = s[i];
        }
    }
    clean_s[j] = '\0';
    
    int returnSize;
    int* result = diStringMatch(clean_s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(clean_s);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables plus output array

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'I' or 'D'
The permutation must contain all integers from 0 to n exactly once

28.4K Views

Medium Frequency

~12 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler