Redistribute Characters to Make All Strings Equal

Redistribute Characters to Make All Strings Equal - Problem

You are given an array of strings words (0-indexed).

In one operation, pick two distinct indices i and j, where words[i] is a non-empty string, and move any character from words[i] to any position in words[j].

Return true if you can make every string in words equal using any number of operations, and false otherwise.

Input & Output

Example 1 — Even Distribution Possible

$ Input: words = ["abc","aabc","bc"]

› Output: true

💡 Note: We have 3 'a's, 3 'b's, and 3 'c's total. Since we have 3 strings, each can get exactly 1 of each character. Final result could be ["abc", "abc", "abc"].

Example 2 — Uneven Character Count

$ Input: words = ["ab","a"]

› Output: false

💡 Note: We have 2 'a's and 1 'b' but 2 strings. Each string should get 1 'a' and 0.5 'b', but we can't split characters.

Example 3 — Single Character Type

$ Input: words = ["a","aa","aaa"]

› Output: true

💡 Note: Total of 6 'a's can be evenly distributed among 3 strings, giving 2 'a's per string: ["aa", "aa", "aa"].

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters only

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is that characters can be freely moved between strings, so we only need to check if each character's total count can be evenly distributed. The frequency counting approach solves this optimally in O(n) time by counting each character and checking divisibility by the number of strings.

Common Approaches

✓ Brute Force - Try All Redistributions

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

Generate all possible ways to move characters between strings and check if any configuration results in all strings being equal. This involves exploring exponentially many possibilities.

Frequency Counting - Optimal Solution

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

Count the total frequency of each character across all strings. For redistribution to be possible, every character's count must be divisible by the number of strings, ensuring each string gets an equal share.

Brute Force - Try All Redistributions — Algorithm Steps

Generate all possible character movements
For each configuration, check if all strings are equal
Return true if any valid configuration is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with given strings

Try Movements

Explore all ways to move characters between strings

Check Equal

See if any configuration makes all strings equal

Code -

solution.c — C

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

bool solution(char words[][101], int wordsSize) {
    int totalChars = 0;
    for (int i = 0; i < wordsSize; i++) {
        totalChars += strlen(words[i]);
    }
    
    if (totalChars % wordsSize != 0) {
        return false;
    }
    
    // Count character frequencies
    int charCount[128] = {0}; // ASCII characters
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < strlen(words[i]); j++) {
            charCount[words[i][j]]++;
        }
    }
    
    // Check if all character counts are divisible by number of words
    for (int i = 0; i < 128; i++) {
        if (charCount[i] > 0 && charCount[i] % wordsSize != 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array of strings
    char words[1000][101];
    int wordsSize = 0;
    
    char* token = strtok(line, "[],\"");
    while (token != NULL && wordsSize < 1000) {
        if (strlen(token) > 0 && strcmp(token, "\n") != 0) {
            strcpy(words[wordsSize], token);
            wordsSize++;
        }
        token = strtok(NULL, "[],\"");
    }
    
    bool result = solution(words, wordsSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is total characters and n is number of strings - exponential combinations

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth proportional to total characters

✓ Linear Space

34.3K Views

Medium Frequency

~8 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 - Try All Redistributions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler