Find Permutation - Practice Coding Problems

Find Permutation - Problem

Imagine you're a detective decoding a secret message! You have a cryptic string that describes the relationship between consecutive numbers in a hidden permutation.

Given a string s of length n-1 containing only characters 'I' (Increasing) and 'D' (Decreasing), you need to reconstruct the lexicographically smallest permutation of integers from [1, n] that matches this pattern.

The Rules:

s[i] == 'I' means perm[i] < perm[i+1] (next number is larger)
s[i] == 'D' means perm[i] > perm[i+1] (next number is smaller)

Example: If s = "DI", you need a 3-number permutation where the first number is greater than the second, and the second is less than the third. The answer is [2,1,3] because it's the lexicographically smallest valid permutation.

Input & Output

example_1.py — Basic case

$ Input: s = "I"

› Output: [1, 2]

💡 Note: We need perm[0] < perm[1]. The lexicographically smallest is [1, 2].

example_2.py — Mixed pattern

$ Input: s = "DI"

› Output: [2, 1, 3]

💡 Note: We need perm[0] > perm[1] and perm[1] < perm[2]. The pattern D-I creates a valley shape, so we get [2, 1, 3].

example_3.py — All decreasing

$ Input: s = "DDI"

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

💡 Note: Three consecutive D's followed by I. We place largest numbers first (3,2,1) then the final ascending number (4).

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with an empty result array and a stack

Process Each Position

For each position, push its index to the stack

Handle 'I' or End

When we see 'I' or reach the end, pop indices from stack and assign ascending numbers

Result

The stack ensures we assign the smallest possible numbers while satisfying the pattern

Key Takeaway

🎯 Key Insight: The stack-based approach elegantly handles the constraint that we need the lexicographically smallest permutation by delaying number assignments during decreasing sequences and then assigning them in the optimal order.

Time & Space Complexity

Time Complexity

⏱️

O(n! * n)

Generate n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and result

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters 'D' and 'I'
The result should be lexicographically smallest among all valid permutations

Asked in

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

The optimal approach uses a greedy strategy with a stack to achieve O(n) time complexity. The key insight is that when we see 'D', we delay number assignment using a stack, and when we see 'I' or reach the end, we pop from the stack and assign the smallest available numbers. This naturally creates the lexicographically smallest valid permutation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! * n)	O(n)	Generate all possible permutations and find the lexicographically smallest valid one
Greedy with Stack (Optimal)	O(n)	O(n)	Use a greedy approach with stack to handle decreasing sequences efficiently

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of numbers [1, 2, ..., n]
For each permutation, check if it matches the pattern string s
Keep track of the lexicographically smallest valid permutation
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate First Permutation

Start with [1,2,3] for s="DI"

Check Pattern

Check if 1<2 (should be D), fails immediately

Try Next Permutation

Try [1,3,2], check if 1>3 (D) and 3<2 (I), fails

Continue Until Valid

Eventually find [2,1,3] which satisfies D(2>1) and I(1<3)

Code -

solution.c — C

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

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

int isValid(int* nums, char* s, int n) {
    for (int i = 0; i < n - 1; i++) {
        if (s[i] == 'I' && nums[i] >= nums[i + 1]) return 0;
        if (s[i] == 'D' && nums[i] <= nums[i + 1]) return 0;
    }
    return 1;
}

int* permute(int* nums, char* s, int start, int n) {
    if (start == n) {
        if (isValid(nums, s, n)) {
            int* result = (int*)malloc(n * sizeof(int));
            for (int i = 0; i < n; i++) result[i] = nums[i];
            return result;
        }
        return NULL;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        int* result = permute(nums, s, start + 1, n);
        if (result) return result;
        swap(&nums[start], &nums[i]);
    }
    return NULL;
}

int* findPermutation(char* s) {
    int n = strlen(s) + 1;
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) nums[i] = i + 1;
    
    int* result = permute(nums, s, 0, n);
    free(nums);
    return result;
}

int main() {
    char s[1000];
    scanf("%s", s);
    
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    
    int* result = findPermutation(s);
    printf("[");
    for (int i = 0; i < strlen(s) + 1; i++) {
        printf("%d", result[i]);
        if (i < strlen(s)) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! * n)

Generate n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and result

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters 'D' and 'I'
The result should be lexicographically smallest among all valid permutations

41.2K Views

Medium Frequency

~18 min Avg. Time

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