Maximum Palindromes After Operations solution and explanation

def max_palindromes(words):
    from collections import Counter
    total_count = Counter()
    for word in words:
        total_count.update(word)

    odd_count = sum(count % 2 for count in total_count.values())
    return len(words) - odd_count // 2

# Example usage
words = ['abbb', 'ba', 'aa']
print(max_palindromes(words))  # Output: 3

function maxPalindromes(words) {
    let totalCount = Array(26).fill(0);
    for (let word of words) {
        for (let char of word) {
            totalCount[char.charCodeAt(0) - 'a'.charCodeAt(0)]++;
        }
    }
    let oddCount = totalCount.reduce((count, frequency) => count + (frequency % 2), 0);
    return words.length - Math.floor(oddCount / 2);
}

// Example usage
const words = ['abbb', 'ba', 'aa'];
console.log(maxPalindromes(words)); // Output: 3

import java.util.*;

public class MaxPalindromes {
    public static int maxPalindromes(String[] words) {
        int n = words.length;
        int res = 0;
        Map<Character, Integer> freqMap = new HashMap<>();
        for (String word: words) {
            boolean isPalindrome = true;
            for (int i = 0; i < word.length() / 2; i++) {
                if (word.charAt(i) != word.charAt(word.length() - 1 - i)) {
                    isPalindrome = false;
                    break;
                }
            }
            if (isPalindrome) {
                res++;
            }
            for (char ch: word.toCharArray()) {
                freqMap.put(ch, freqMap.getOrDefault(ch, 0) + 1);
            }
        }
        int oddCount = 0;
        for (int freq: freqMap.values()) {
            if (freq % 2 != 0) oddCount++;
        }
        return res + (n - res - oddCount / 2);
    }

    public static void main(String[] args) {
        String[] words = {"abbb", "ba", "aa"};
        System.out.println(maxPalindromes(words)); // Output: 3
    }
}

#include <iostream>
#include <unordered_map>
using namespace std;

int maxPalindromes(vector<string>& words) {
    unordered_map<char, int> freqMap;
    int res = 0;
    for (string word : words) {
        bool isPalindrome = true;
        for (int i = 0; i < word.size() / 2; i++) {
            if (word[i] != word[word.size() - 1 - i]) {
                isPalindrome = false;
                break;
            }
        }
        if (isPalindrome) {
            res++;
        }
        for (char ch : word) {
            freqMap[ch]++;
        }
    }
    int oddCount = 0;
    for (auto const &pair : freqMap) {
        if (pair.second % 2 != 0) oddCount++;
    }
    return res + (words.size() - res - oddCount / 2);
}

int main() {
    vector<string> words = {"abbb", "ba", "aa"};
    cout << maxPalindromes(words) << endl; // Output: 3
    return 0;
}

function maxPalindromesAfterOperations(words: string[]): number {
    let s: number = 0;
    let mask: number = 0;
    for (const w of words) {
        s += w.length;
        for (const c of w) {
            mask ^= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
        }
    }
    s -= (mask.toString(2).match(/1/g) || []).length;
    words.sort((a, b) => a.length - b.length);
    let ans: number = 0;
    for (const w of words) {
        s -= Math.floor(w.length / 2) * 2;
        if (s < 0) {
            break;
        }
        ans++;
    }
    return ans;
}

func maxPalindromesAfterOperations(words []string) (ans int) {
	var s, mask int
	for _, w := range words {
		s += len(w)
		for _, c := range w {
			mask ^= 1 << (c - 'a')
		}
	}
	s -= bits.OnesCount(uint(mask))
	sort.Slice(words, func(i, j int) bool {
		return len(words[i]) < len(words[j])
	})
	for _, w := range words {
		s -= len(w) / 2 * 2
		if s < 0 {
			break
		}
		ans++
	}
	return
}