Rearrange Characters to Make Target String

Rearrange Characters to Make Target String - Problem

Imagine you have a collection of letter tiles from a word game, and you want to form as many copies of a specific target word as possible!

You are given two strings: s (your available letters) and target (the word you want to form). Your goal is to determine the maximum number of complete copies of the target string you can create by rearranging the letters from s.

Key Rules:

You can use each letter from s only once
You can rearrange letters in any order
You must form complete copies of the target string

Example: If s = "ilovecodingsomuchthatticouldcodeallday" and target = "code", you need to count how many times you can spell "code" using the available letters.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can form "code" twice. Available letters: i(3), l(3), o(4), v(1), e(2), c(4), d(4), n(1), g(1), s(1), m(1), u(4), h(3), t(5), a(4), y(1). For "code" we need: c(1), o(1), d(1), e(1). Ratios: c(4/1=4), o(4/1=4), d(4/1=4), e(2/1=2). Minimum is 2.

example_2.py — No Possible Formation

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

› Output: 0

💡 Note: We cannot form "code" even once because we're missing the letter 'o' in the source string. When a required letter is missing, the result is 0.

example_3.py — Single Character Target

$ Input: s = "aaaaaa", target = "a"

› Output: 6

💡 Note: Simple case where target is a single character. We have 6 'a's available and need 1 'a' per target, so we can form 6 copies of the target "a".

Visualization

Tap to expand

Understanding the Visualization

Count Your Tiles

First, count how many of each letter you have available

Check Requirements

Count how many of each letter you need for one target word

Find the Bottleneck

Calculate available÷needed for each letter - the smallest ratio is your answer

Verify Result

The limiting character determines maximum possible complete words

Key Takeaway

🎯 Key Insight: The character with the smallest available-to-needed ratio determines how many complete target strings you can form. This bottleneck approach gives us the optimal O(n + m) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is length of s and m is length of target. We iterate through target once to count, then through s once to calculate.

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters in target (at most 26 for English alphabet).

✓ Linear Space

Constraints

1 ≤ s.length ≤ 100
1 ≤ target.length ≤ 10
s and target consist of lowercase English letters only
target.length ≤ s.length (otherwise answer would always be 0)

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses hash tables to count character frequencies in both strings, then finds the bottleneck character - the one with the smallest ratio of available/needed. This approach runs in O(n + m) time and O(k) space, where k is the number of unique characters in the target string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate Tile Removal)	O(n * m * k)	O(n)	Repeatedly try to form target strings by removing letters from s
One-Pass Optimized (Optimal)	O(n + m)	O(k)	Count target characters first, then check source string in one pass
Two-Pass Hash Table	O(n + m)	O(1)	Count character frequencies, then calculate maximum possible target strings

Brute Force (Simulate Tile Removal) — Algorithm Steps

Start with the original string s
For each attempt to form target, iterate through target characters
For each character in target, search through remaining characters in s
If found, mark that character as used; if not found, stop
If we successfully form a complete target, increment counter
Repeat until we can't form another complete target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with all characters from string s available

Form Target #1

Search and remove each character needed for first target string

Form Target #2

Try to form another target string with remaining characters

Cannot Form More

Stop when we can't find all required characters

Code -

solution.c — C

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

int rearrangeCharacters(char* s, char* target) {
    int count = 0;
    int sLen = strlen(s);
    int tLen = strlen(target);
    char* available = (char*)malloc((sLen + 1) * sizeof(char));
    strcpy(available, s);
    int availableLen = sLen;
    
    while (1) {
        // Try to form one copy of target
        int targetFormed = 1;
        char* tempAvailable = (char*)malloc((availableLen + 1) * sizeof(char));
        strcpy(tempAvailable, available);
        int tempLen = availableLen;
        
        for (int i = 0; i < tLen; i++) {
            int found = 0;
            for (int j = 0; j < tempLen; j++) {
                if (tempAvailable[j] == target[i]) {
                    // Remove this character by shifting
                    for (int k = j; k < tempLen - 1; k++) {
                        tempAvailable[k] = tempAvailable[k + 1];
                    }
                    tempLen--;
                    tempAvailable[tempLen] = '\0';
                    found = 1;
                    break;
                }
            }
            if (!found) {
                targetFormed = 0;
                break;
            }
        }
        
        if (targetFormed) {
            count++;
            strcpy(available, tempAvailable);
            availableLen = tempLen;
        } else {
            free(tempAvailable);
            break;
        }
        free(tempAvailable);
    }
    
    free(available);
    return count;
}

int main() {
    char s[1001], target[1001];
    fgets(s, sizeof(s), stdin);
    fgets(target, sizeof(target), stdin);
    
    // Remove newlines and quotes
    s[strcspn(s, "\n")] = 0;
    target[strcspn(target, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    if (target[0] == '"') {
        memmove(target, target + 1, strlen(target));
        target[strlen(target) - 1] = '\0';
    }
    
    printf("%d\n", rearrangeCharacters(s, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

Where n is length of s, m is length of target, and k is the number of target strings we can form. For each of k formations, we do m searches through remaining characters.

✓ Linear Growth

Space Complexity

O(n)

We need to track which characters have been used, requiring a copy or modification of the original string.

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
1 ≤ target.length ≤ 10
s and target consist of lowercase English letters only
target.length ≤ s.length (otherwise answer would always be 0)

28.6K Views

Medium Frequency

~15 min Avg. Time

1.2K 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 (Simulate Tile Removal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler