Rearrange K Substrings to Form Target String

Rearrange K Substrings to Form Target String - Problem

Rearrange K Substrings to Form Target String

Imagine you have a string s and need to transform it into a target string t using a specific constraint. Both strings are anagrams of each other (contain the same characters with the same frequencies).

Your task is to determine if you can:
1. Split string s into exactly k equal-sized substrings
2. Rearrange these substrings in any order
3. Concatenate them to form the target string t

Return true if this transformation is possible, false otherwise.

Key Constraints:
• All substrings must be of equal length
• You can only rearrange complete substrings, not individual characters
• The original character frequencies must be preserved

Input & Output

example_1.py — Basic Case

$ Input: {"s": "abcdef", "t": "cdefab", "k": 3}

› Output: true

💡 Note: We can split 'abcdef' into 3 chunks: ['ab', 'cd', 'ef']. Rearranging as ['cd', 'ef', 'ab'] gives 'cdefab' which matches the target.

example_2.py — Impossible Case

$ Input: {"s": "abcdef", "t": "acbdef", "k": 2}

› Output: false

💡 Note: Split 'abcdef' into 2 chunks: ['abc', 'def']. Target 'acbdef' would need chunks ['acb', 'def'], but 'acb' ≠ 'abc', so rearrangement is impossible.

example_3.py — Edge Case

$ Input: {"s": "aabb", "t": "abab", "k": 2}

› Output: true

💡 Note: Split 'aabb' into ['aa', 'bb'] and 'abab' into ['ab', 'ab']. Since we need 2 'ab' chunks but only have 'aa' and 'bb', this should return false. Wait - let me recalculate: we need chunks that can be rearranged, so 'aa','bb' vs 'ab','ab' - these are different, so false.

Constraints

1 ≤ s.length ≤ 10⁴
s.length == t.length
s.length % k == 0
1 ≤ k ≤ s.length
s and t consist of lowercase English letters only
s and t are anagrams of each other

Visualization

Tap to expand

Understanding the Visualization

Cut into pieces

Split both strings into k equal-sized chunks

Count piece types

Create inventory of what pieces you have vs what you need

Compare inventories

If inventories match exactly, rearrangement is possible

Key Takeaway

🎯 Key Insight: By comparing frequency maps of k-length chunks from both strings, we can determine in O(n) time whether rearrangement is possible, avoiding the expensive O(k!) brute force approach.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a hash table frequency count approach. Split both strings into k equal-sized chunks, then compare the frequency maps of these chunks. If both frequency maps are identical, the rearrangement is possible. This achieves O(n) time complexity compared to the O(k!) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table Frequency Count (Optimal)	O(n)	O(n)	Compare frequency maps of k-length chunks from both strings
Brute Force (Generate All Permutations)	O(k! × n)	O(n)	Generate all possible arrangements of k substrings and check each one

Hash Table Frequency Count (Optimal) — Algorithm Steps

Validate that string length is divisible by k
Calculate chunk size as len(s) / k
Extract all k-length chunks from source string s
Extract all k-length chunks from target string t
Create frequency maps for both sets of chunks
Compare the frequency maps for equality

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract chunks

Split both strings into k equal-sized chunks

Count frequencies

Create frequency maps for each set of chunks

Compare maps

Verify both frequency maps are identical

Code -

solution.c — C

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

#define MAX_CHUNKS 1000
#define MAX_CHUNK_LEN 100

typedef struct {
    char chunk[MAX_CHUNK_LEN];
    int count;
} ChunkCount;

int findChunk(ChunkCount chunks[], int size, const char* chunk) {
    for (int i = 0; i < size; i++) {
        if (strcmp(chunks[i].chunk, chunk) == 0) {
            return i;
        }
    }
    return -1;
}

bool canRearrangeSubstrings(char* s, char* t, int k) {
    int len = strlen(s);
    if (len != strlen(t) || len % k != 0) {
        return false;
    }
    
    int chunkSize = len / k;
    ChunkCount sChunks[MAX_CHUNKS] = {0};
    ChunkCount tChunks[MAX_CHUNKS] = {0};
    int sSize = 0, tSize = 0;
    
    // Process source string chunks
    for (int i = 0; i < len; i += chunkSize) {
        char chunk[MAX_CHUNK_LEN];
        strncpy(chunk, s + i, chunkSize);
        chunk[chunkSize] = '\0';
        
        int idx = findChunk(sChunks, sSize, chunk);
        if (idx == -1) {
            strcpy(sChunks[sSize].chunk, chunk);
            sChunks[sSize].count = 1;
            sSize++;
        } else {
            sChunks[idx].count++;
        }
    }
    
    // Process target string chunks
    for (int i = 0; i < len; i += chunkSize) {
        char chunk[MAX_CHUNK_LEN];
        strncpy(chunk, t + i, chunkSize);
        chunk[chunkSize] = '\0';
        
        int idx = findChunk(tChunks, tSize, chunk);
        if (idx == -1) {
            strcpy(tChunks[tSize].chunk, chunk);
            tChunks[tSize].count = 1;
            tSize++;
        } else {
            tChunks[idx].count++;
        }
    }
    
    // Compare frequency maps
    if (sSize != tSize) return false;
    
    for (int i = 0; i < sSize; i++) {
        int found = 0;
        for (int j = 0; j < tSize; j++) {
            if (strcmp(sChunks[i].chunk, tChunks[j].chunk) == 0) {
                if (sChunks[i].count != tChunks[j].count) {
                    return false;
                }
                found = 1;
                break;
            }
        }
        if (!found) return false;
    }
    
    return true;
}

int main() {
    char s[1000], t[1000];
    int k;
    printf("Enter s, t, k: ");
    scanf("%s %s %d", s, t, &k);
    
    printf("%s\n", canRearrangeSubstrings(s, t, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to extract chunks and build frequency maps

✓ Linear Growth

Space Complexity

O(n)

Storage for frequency maps of chunks, worst case all chunks are unique

⚡ Linearithmic Space

24.7K Views

Medium Frequency

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

Hash Table Frequency Count (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler