Redistribute Characters to Make All Strings Equal

Redistribute Characters to Make All Strings Equal - Problem

Imagine you're a librarian with a collection of books, and you want to reorganize the letters in their titles to make all book titles identical. You have the power to move any character from one book title to any position in another book title.

Given an array of strings words, you need to determine if it's possible to make all strings equal by redistributing characters between them. In each operation, you can:

Pick two different strings (at indices i and j)
Remove any character from words[i] (as long as it's not empty)
Insert that character at any position in words[j]

Return true if you can make all strings identical, false otherwise.

Example: ["abc", "aabc", "bc"] can become ["abc", "abc", "abc"] by moving one 'a' from the second string to the third string.

Input & Output

example_1.py — Basic redistribution

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

› Output: true

💡 Note: We have 3 a's, 3 b's, and 3 c's total. Since 3 is divisible by 3 (number of strings), each string can have exactly 1 of each character, making them all equal to "abc".

example_2.py — Impossible redistribution

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

› Output: false

💡 Note: We have 2 a's and 1 b total. With 2 strings, we'd need an even number of each character. Since we have an odd number of b's (1), it's impossible to distribute evenly.

example_3.py — Single string edge case

$ Input: ["a"]

› Output: true

💡 Note: With only one string, no redistribution is needed - it's already equal to itself.

Constraints

1 ≤ words.length ≤ 100
0 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters only
Sum of all string lengths ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Count Total Chips

Count all chocolate chips across all conveyor belts

Check Distribution

Verify if chips can be evenly distributed among all belts

Redistribute

If possible, each belt gets the same pattern of chips

Key Takeaway

🎯 Key Insight: If every character count is divisible by the number of strings, perfect redistribution is always possible!

Asked in

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

The optimal solution uses character counting with a hash map. The key insight is that for all strings to become equal, each character must appear a number of times that's divisible by the number of strings. We count all characters in O(n×m) time and check the divisibility condition, making this an elegant and efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Character Counting (Optimal)	O(n × m)	O(k)	Count all characters in one pass and check if counts are divisible by number of strings
Brute Force (Try All Redistributions)	O(n! × m)	O(n × m)	Generate all possible ways to redistribute characters and check if any results in equal strings

One-Pass Character Counting (Optimal) — Algorithm Steps

Create a hash map to count character frequencies
Iterate through all strings and count each character
For each character, check if its count is divisible by the number of strings
Return true if all characters satisfy the divisibility condition

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counter

Create hash map to track character frequencies

Count All Characters

Iterate through all strings, counting each character

Check Divisibility

Verify each character count is divisible by number of strings

Return Result

Return true if all characters can be evenly distributed

Code -

solution.c — C

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

bool makeEqual(char words[][100], int wordCount) {
    int charCount[26] = {0};
    
    // Count all characters (assuming lowercase a-z)
    for (int i = 0; i < wordCount; i++) {
        for (int j = 0; words[i][j] != '\0'; j++) {
            charCount[words[i][j] - 'a']++;
        }
    }
    
    // Check divisibility
    for (int i = 0; i < 26; i++) {
        if (charCount[i] % wordCount != 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char words[3][100] = {"abc", "aabc", "bc"};
    printf("%s\n", makeEqual(words, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is number of strings and m is average string length - we visit each character once

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters (at most 26 for lowercase letters)

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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

One-Pass Character Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler