Rearrange Characters to Make Target String

Rearrange Characters to Make Target String - Problem

You are given two 0-indexed strings s and target. You can take some letters from s and rearrange them to form new strings.

Return the maximum number of copies of target that can be formed by taking letters from s and rearranging them.

Note: Each character from s can only be used once across all copies of target.

Input & Output

Example 1 — Basic Case

$ Input: s = "ilovecodingonleetcode", target = "code"

› Output: 2

💡 Note: We can form "code" twice: first using c,o,d,e from positions, then using remaining c,o,d,e. Characters c and d each appear twice in s, limiting us to 2 copies.

Example 2 — Limited by One Character

$ Input: s = "abcba", target = "abc"

› Output: 1

💡 Note: s has a:2, b:2, c:1. Target needs a:1, b:1, c:1. Character 'c' appears only once in s, so we can form "abc" only 1 time.

Example 3 — Missing Character

$ Input: s = "abbaccaddaeea", target = "aaaaa"

› Output: 1

💡 Note: s has 5 'a' characters and target needs 5 'a' characters, so we can form "aaaaa" exactly 1 time.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ target.length ≤ 10⁴
s and target consist of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to count character frequencies and find the bottleneck character. Best approach is frequency counting which determines how many copies each character can support. Time: O(n + m), Space: O(1)

Common Approaches

✓ Brute Force Character Removal

⏱️ Time: O(n × m × k) Space: O(n)

For each attempt to form target, scan through s to find and remove required characters. Continue until we can't form another complete target string.

Frequency Count Approach

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

Count the frequency of each character in both strings. For each character in target, divide its count in s by its count in target to find how many copies that character can support. The minimum ratio determines the answer.

Brute Force Character Removal — Algorithm Steps

Step 1: Try to form one copy of target by finding each character in s
Step 2: Remove used characters from s
Step 3: Repeat until target cannot be formed
Step 4: Return count of successfully formed copies

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Characters

Search s for each character needed in target

Remove Used

Remove found characters from s

Repeat

Continue until target cannot be formed

Code -

solution.c — C

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

int solution(char* s, char* target) {
    int copies = 0;
    int sLen = strlen(s);
    int targetLen = strlen(target);
    char* sCopy = malloc(sLen + 1);
    strcpy(sCopy, s);
    int currentLen = sLen;
    
    while (1) {
        int targetFormed = 1;
        int usedIndices[1000];
        int usedCount = 0;
        
        for (int t = 0; t < targetLen; t++) {
            int found = 0;
            for (int i = 0; i < currentLen; i++) {
                if (sCopy[i] == target[t]) {
                    int alreadyUsed = 0;
                    for (int u = 0; u < usedCount; u++) {
                        if (usedIndices[u] == i) {
                            alreadyUsed = 1;
                            break;
                        }
                    }
                    if (!alreadyUsed) {
                        usedIndices[usedCount++] = i;
                        found = 1;
                        break;
                    }
                }
            }
            if (!found) {
                targetFormed = 0;
                break;
            }
        }
        
        if (targetFormed) {
            // Sort indices in descending order
            for (int i = 0; i < usedCount - 1; i++) {
                for (int j = i + 1; j < usedCount; j++) {
                    if (usedIndices[i] < usedIndices[j]) {
                        int temp = usedIndices[i];
                        usedIndices[i] = usedIndices[j];
                        usedIndices[j] = temp;
                    }
                }
            }
            
            // Remove characters
            for (int i = 0; i < usedCount; i++) {
                int idx = usedIndices[i];
                for (int j = idx; j < currentLen - 1; j++) {
                    sCopy[j] = sCopy[j + 1];
                }
                currentLen--;
            }
            copies++;
        } else {
            break;
        }
    }
    
    free(sCopy);
    return copies;
}

int main() {
    char s[1001], target[1001];
    fgets(s, sizeof(s), stdin);
    fgets(target, sizeof(target), stdin);
    s[strcspn(s, "\n")] = 0;
    target[strcspn(target, "\n")] = 0;
    
    int result = solution(s, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

For each of k possible copies, scan s (length n) for each character in target (length m)

✓ Linear Growth

Space Complexity

O(n)

Need to modify or copy string s to track used characters

✓ Linear Space

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

Brute Force Character Removal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler