Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1897.html

1897. Redistribute Characters to Make All Strings Equal

Level

Easy

Description

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.

Example 1:

Input: words = [“abc”,”aabc”,”bc”]

Output: true

Explanation: Move the first ‘a’ in words[1] to the front of words[2], to make words[1] = “abc” and words[2] = “abc”. All the strings are now equal to “abc”, so return true.

Example 2:

Input: words = [“ab”,”a”]

Output: false

Explanation: It is impossible to make all the strings equal using the operation.

Constraints:

  • 1 <= words.length <= 100
  • 1 <= words[i].length <= 100
  • words[i] consists of lowercase English letters.

Solution

Loop over words and count the number of occurrences of each word. Return true if and only if for all letters, the number of occurrences is divisible by the length of array words.

  • class Solution {
    public boolean makeEqual(String[] words) {
        int[] counts = new int[26];
        for (String word : words) {
            int wordLength = word.length();
            for (int i = 0; i < wordLength; i++) {
                char c = word.charAt(i);
                counts[c - 'a']++;
            }
        }
        int length = words.length;
        for (int i = 0; i < 26; i++) {
            if (counts[i] % length != 0)
                return false;
        }
        return true;
    }
}

############

class Solution {
    public boolean makeEqual(String[] words) {
        int[] counter = new int[26];
        for (String word : words) {
            for (char c : word.toCharArray()) {
                ++counter[c - 'a'];
            }
        }
        int n = words.length;
        for (int i = 0; i < 26; ++i) {
            if (counter[i] % n != 0) {
                return false;
            }
        }
        return true;
    }
}

  • // OJ: https://leetcode.com/problems/redistribute-characters-to-make-all-strings-equal/
// Time: O(N)
// Space: O(1)
class Solution {
public:
    bool makeEqual(vector<string>& A) {
        int cnt[26] = {};
        for (auto &s : A) {
            for (char c : s) cnt[c - 'a']++;
        }
        for (int i = 0; i < 26; ++i) {
            if (cnt[i] % A.size()) return false;
        }
        return true;
    }
};

  • class Solution:
    def makeEqual(self, words: List[str]) -> bool:
        counter = Counter()
        for word in words:
            for c in word:
                counter[c] += 1
        n = len(words)
        return all(count % n == 0 for count in counter.values())

############

# 1897. Redistribute Characters to Make All Strings Equal
# https://leetcode.com/problems/redistribute-characters-to-make-all-strings-equal/

class Solution:
    def makeEqual(self, words: List[str]) -> bool:
        n = len(words)
        mp = collections.defaultdict(int)
        
        for word in words:
            for c in word:
                mp[c] += 1
        
        for key in mp:
            if not (mp[key] >= n and mp[key] % n == 0): return False
        
        return True


  • func makeEqual(words []string) bool {
	counter := [26]int{}
	for _, word := range words {
		for _, c := range word {
			counter[c-'a']++
		}
	}
	n := len(words)
	for _, count := range counter {
		if count%n != 0 {
			return false
		}
	}
	return true
}

  • function makeEqual(words: string[]): boolean {
    let n = words.length;
    let letters = new Array(26).fill(0);
    for (let word of words) {
        for (let i = 0; i < word.length; ++i) {
            ++letters[word.charCodeAt(i) - 97];
        }
    }

    for (let i = 0; i < letters.length; ++i) {
        if (letters[i] % n != 0) {
            return false;
        }
    }
    return true;
}

All Problems

All Solutions