Check If String Is Transformable With Substring Sort Operations

Check If String Is Transformable With Substring Sort Operations - Problem

Check If String Is Transformable With Substring Sort Operations

You are given two strings s and t, and your task is to determine if you can transform string s into string t using a specific operation.

The Operation: You can choose any non-empty substring in s and sort it in ascending order in place. You can perform this operation any number of times.

Example: If you have the string "14234" and choose the substring "423" (positions 1-3), sorting it gives you "234", resulting in "12344".

Your goal is to return true if the transformation is possible, or false otherwise.

Key Insight: This problem involves understanding how sorting operations affect the relative positions of characters and whether we can achieve the desired final arrangement.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "84532", t = "34852"

› Output: true

💡 Note: We can transform s to t by: 1) Sort substring "845" to get "34532", 2) Sort substring "532" to get "34852" which equals t.

example_2.py — Impossible Transformation

$ Input: s = "34521", t = "23415"

› Output: true

💡 Note: We can sort substring "345" to get "33521", then sort other substrings to eventually reach the target.

example_3.py — Same Strings

$ Input: s = "12345", t = "12345"

› Output: true

💡 Note: Since s and t are already identical, no transformation is needed.

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of only digits
Both strings have the same length

Visualization

Tap to expand

Understanding the Visualization

Character Frequency Check

Verify both strings contain the same characters

Position Mapping

Create lists of positions for each digit in source string

Greedy Processing

For each character in target, choose leftmost available position

Constraint Validation

Ensure no smaller digit is blocked by current choice

Key Takeaway

🎯 Key Insight: The greedy approach works because if we can place each character in the target order while respecting the constraint that smaller digits cannot jump over larger digits, then the transformation is always possible through appropriate substring sorting operations.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a greedy approach with position tracking. The key insight is that a smaller digit cannot "jump over" a larger digit that appears later in the target. We track positions of each digit in the source and process the target greedily, ensuring no constraint violations occur.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Position Tracking	O(n)	O(n)	Use greedy approach with position tracking to check if transformation is possible
Brute Force (Try All Substring Sorts)	O(2^n)	O(2^n)	Try all possible substring sort operations until target is reached or proven impossible

Greedy Position Tracking — Algorithm Steps

First check if both strings have same character frequencies
Create position lists for each digit 0-9 in source string
For each character in target, find leftmost available position in source
Check if this character can reach target position without violating constraints
A smaller digit cannot move past a larger digit that appears later in target

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Position Lists

Map each digit to its positions in source string

Process Target

For each character in target, find leftmost available position

Check Constraints

Ensure no smaller digit is blocked by current choice

Update State

Remove used position and continue

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

bool isTransformable(char* s, char* t) {
    int len = strlen(s);
    if (len != strlen(t)) return false;
    
    // Check character frequency
    char sortedS[len + 1], sortedT[len + 1];
    strcpy(sortedS, s);
    strcpy(sortedT, t);
    qsort(sortedS, len, sizeof(char), compare);
    qsort(sortedT, len, sizeof(char), compare);
    
    if (strcmp(sortedS, sortedT) != 0) return false;
    
    // Create position arrays for each digit
    int pos[10][len];
    int posCount[10] = {0};
    int posIndex[10] = {0};
    
    for (int i = 0; i < len; i++) {
        int d = s[i] - '0';
        pos[d][posCount[d]++] = i;
    }
    
    // Process each character in target
    for (int i = 0; i < len; i++) {
        int d = t[i] - '0';
        if (posIndex[d] >= posCount[d]) return false;
        
        int currPos = pos[d][posIndex[d]++];
        
        // Check if any smaller digit appears before this position
        for (int smaller = 0; smaller < d; smaller++) {
            if (posIndex[smaller] < posCount[smaller] && 
                pos[smaller][posIndex[smaller]] < currPos) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    char s[] = "84532";
    char t[] = "34852";
    printf("%s\n", isTransformable(s, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through target string, with constant time operations for each character

✓ Linear Growth

Space Complexity

O(n)

Storage for position lists of each digit

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

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

Check If String Is Transformable With Substring Sort Operations

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Position Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler