DI String Match

DI String Match - Problem

A permutation perm of n + 1 integers of all the integers in the range [0, n] can be represented as a string s of length n where:

s[i] == 'I' if perm[i] < perm[i + 1]
s[i] == 'D' if perm[i] > perm[i + 1]

Given a string s, reconstruct the permutation perm and return it. If there are multiple valid permutations perm, return any of them.

Input & Output

Example 1 — Basic Pattern

$ Input: s = "IDID"

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

💡 Note: For 'I', use smallest available (0). For 'D', use largest (4). Continue: 'I'→1, 'D'→3, final→2. Result: 0<4, 4>1, 1<3, 3>2 matches IDID.

Example 2 — All Increasing

$ Input: s = "III"

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

💡 Note: All 'I' means strictly increasing sequence. Use numbers 0,1,2,3 in order: 0<1<2<3 matches III.

Example 3 — All Decreasing

$ Input: s = "DDI"

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

💡 Note: For 'D', use largest available. 'D'→3, 'D'→2, 'I'→0, final→1. Result: 3>2>0<1 matches DDI.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of 'I' and 'D' only

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use a greedy two-pointer approach. For 'I', assign the smallest available number. For 'D', assign the largest. This ensures we always have valid choices remaining. Best approach is Two Pointers. Time: O(n), Space: O(1)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Permutations

⏱️ Time: O((n+1)!) Space: O(n)

Generate all (n+1)! permutations of numbers 0 to n, then for each permutation check if it produces the given DI string pattern. Return the first valid permutation found.

Greedy - Stack-Based Construction

⏱️ Time: O(n) Space: O(n)

Process the DI string and use a stack to handle sequences of decreasing patterns. When we see 'I' after 'D's, we can resolve the stack by assigning numbers in the correct order.

Two Pointers - Greedy Assignment

⏱️ Time: O(n) Space: O(1)

Maintain two pointers (low, high) representing available range [0, n]. For 'I', assign the smallest available number. For 'D', assign the largest available number. This greedy approach ensures we always have valid choices.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int employee_id;
    char name[100];
    char department[100];
    int salary;
} Employee;

typedef struct {
    Employee* data;
    int size;
    int capacity;
} EmployeeArray;

EmployeeArray* createArray() {
    EmployeeArray* arr = malloc(sizeof(EmployeeArray));
    arr->capacity = 10;
    arr->size = 0;
    arr->data = malloc(sizeof(Employee) * arr->capacity);
    return arr;
}

void addEmployee(EmployeeArray* arr, Employee emp) {
    if (arr->size >= arr->capacity) {
        arr->capacity *= 2;
        arr->data = realloc(arr->data, sizeof(Employee) * arr->capacity);
    }
    arr->data[arr->size++] = emp;
}

char* extractString(const char* json, const char* key, char* buffer) {
    char pattern[200];
    sprintf(pattern, "\"%s\":\"", key);
    char* start = strstr(json, pattern);
    if (!start) return NULL;
    start += strlen(pattern);
    char* end = strchr(start, '"');
    if (!end) return NULL;
    int len = end - start;
    strncpy(buffer, start, len);
    buffer[len] = '\0';
    return buffer;
}

int extractInt(const char* json, const char* key) {
    char pattern[200];
    sprintf(pattern, "\"%s\":", key);
    char* start = strstr(json, pattern);
    if (!start) return 0;
    start += strlen(pattern);
    return atoi(start);
}

EmployeeArray* parseEmployees(const char* input) {
    EmployeeArray* employees = createArray();
    if (strcmp(input, "[]") == 0) return employees;
    
    const char* pos = input + 1; // Skip opening [
    
    while (*pos && *pos != ']') {
        const char* objStart = strchr(pos, '{');
        if (!objStart) break;
        
        const char* objEnd = strchr(objStart, '}');
        if (!objEnd) break;
        
        int objLen = objEnd - objStart + 1;
        char* objStr = malloc(objLen + 1);
        strncpy(objStr, objStart, objLen);
        objStr[objLen] = '\0';
        
        Employee emp;
        emp.employee_id = extractInt(objStr, "employee_id");
        extractString(objStr, "name", emp.name);
        extractString(objStr, "department", emp.department);
        emp.salary = extractInt(objStr, "salary");
        
        addEmployee(employees, emp);
        free(objStr);
        pos = objEnd + 1;
    }
    
    return employees;
}

EmployeeArray* solution(EmployeeArray* employees) {
    // C equivalent of head(3)
    EmployeeArray* result = createArray();
    int limit = employees->size < 3 ? employees->size : 3;
    for (int i = 0; i < limit; i++) {
        addEmployee(result, employees->data[i]);
    }
    return result;
}

void printEmployees(EmployeeArray* employees) {
    printf("[");
    for (int i = 0; i < employees->size; i++) {
        if (i > 0) printf(", ");
        printf("{\"employee_id\": %d, \"name\": \"%s\", \"department\": \"%s\", \"salary\": %d}",
               employees->data[i].employee_id,
               employees->data[i].name,
               employees->data[i].department,
               employees->data[i].salary);
    }
    printf("]\n");
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    EmployeeArray* employees = parseEmployees(input);
    EmployeeArray* result = solution(employees);
    printEmployees(result);
    
    free(employees->data);
    free(employees);
    free(result->data);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

67.5K Views

Medium Frequency

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