Check If String Is Transformable With Substring Sort Operations

Check If String Is Transformable With Substring Sort Operations - Problem

Given two strings s and t, transform string s into string t using the following operation any number of times:

Choose a non-empty substring in s and sort it in place so the characters are in ascending order.

For example, applying the operation on the underlined substring in "14234" results in "12344".

Return true if it is possible to transform s into t. Otherwise, return false.

A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Transformation

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

› Output: true

💡 Note: Sort substring [1:4] "453" to get "345": "84532" → "83452". Then sort [0:2] "83" to get "38": "83452" → "38452". Finally sort [1:3] "84" to get "48": "38452" → "34852".

Example 2 — Impossible Case

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

› Output: false

💡 Note: The digit '1' at position 4 in s cannot move to position 3 in t because it would need to pass the larger digit '2', which is impossible with sorting operations.

Example 3 — Already Sorted

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

› Output: true

💡 Note: Strings are already identical, no transformation needed.

Constraints

s.length == t.length
1 ≤ s.length ≤ 200
s and t consist of only digits.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8

The key insight is that smaller digits can only move right during sorting operations, never left. The optimal greedy approach tracks digit positions and validates if each target digit can be reached from a valid source position. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(n! × n²) Space: O(n)

Generate all possible strings by trying every substring sort operation. Use backtracking to explore all transformation paths until we find the target string or exhaust all possibilities.

Greedy Position Tracking

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

Use the key insight that smaller digits can only move right during sorting. For each digit in target, find the leftmost available position in source that can reach the target position.

Brute Force with Backtracking — Algorithm Steps

Try sorting every possible substring
Recursively check if resulting string can reach target
Return true if any path leads to target

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with source string s

Try Sort

Sort every possible substring

Recurse

Continue until target found or exhausted

Code -

solution.c — C

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

void sortString(char* str, int len) {
    for (int i = 0; i < len - 1; i++) {
        for (int j = i + 1; j < len; j++) {
            if (str[i] > str[j]) {
                char temp = str[i];
                str[i] = str[j];
                str[j] = temp;
            }
        }
    }
}

bool backtrack(char* current, char* target, char visited[][1001], int* visitedCount, int len) {
    if (strcmp(current, target) == 0) return true;
    
    // Check if already visited (simplified)
    for (int v = 0; v < *visitedCount; v++) {
        if (strcmp(visited[v], current) == 0) return false;
    }
    
    if (*visitedCount < 1000) {
        strcpy(visited[*visitedCount], current);
        (*visitedCount)++;
    }
    
    // Try all possible substring sorts
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j <= len; j++) {
            char temp[1001];
            strcpy(temp, current);
            
            // Sort substring from i to j-1
            char substring[1001];
            strncpy(substring, temp + i, j - i);
            substring[j - i] = '\0';
            
            char sortedSubstring[1001];
            strcpy(sortedSubstring, substring);
            sortString(sortedSubstring, j - i);
            
            if (strcmp(sortedSubstring, substring) != 0) {
                // Create new string
                char newString[1001];
                strncpy(newString, temp, i);
                newString[i] = '\0';
                strcat(newString, sortedSubstring);
                strcat(newString, temp + j);
                
                if (backtrack(newString, target, visited, visitedCount, len)) {
                    return true;
                }
            }
        }
    }
    return false;
}

bool solution(char* s, char* t) {
    int len = strlen(s);
    if (len != strlen(t)) return false;
    if (strcmp(s, t) == 0) return true;
    
    // Check if same character frequencies
    char sSorted[1001], tSorted[1001];
    strcpy(sSorted, s);
    strcpy(tSorted, t);
    sortString(sSorted, len);
    sortString(tSorted, len);
    if (strcmp(sSorted, tSorted) != 0) return false;
    
    char visited[1000][1001];
    int visitedCount = 0;
    return backtrack(s, t, visited, &visitedCount, len);
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    bool result = solution(s, t);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

For each of n! possible permutations, we might try n² substring operations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and string storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler