Flip Columns For Maximum Number of Equal Rows

class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
        unordered_map<string, int> freq;
        int n = matrix[0].size();
        for (auto& row : matrix) {
            string key(n, '0');
            int leader = row[0];
            for (int j = 0; j < n; ++j) key[j] = ('0' + (row[j] ^ leader));
            ++freq[key];
        }
        int best = 0;
        for (auto& [_, c] : freq) best = max(best, c);
        return best;
    }
};

func maxEqualRowsAfterFlips(matrix [][]int) int {
    freq := map[string]int{}
    n := len(matrix[0])
    for _, row := range matrix {
        key := make([]byte, n)
        leader := row[0]
        for j := 0; j < n; j++ {
            key[j] = byte('0' + (row[j] ^ leader))
        }
        freq[string(key)]++
    }
    best := 0
    for _, c := range freq {
        if c > best {
            best = c
        }
    }
    return best
}

from collections import Counter
from typing import List

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        freq: Counter = Counter()
        for row in matrix:
            leader = row[0]
            key = tuple(v ^ leader for v in row)
            freq[key] += 1
        return max(freq.values())

var maxEqualRowsAfterFlips = function(matrix) {
    const freq = new Map();
    const n = matrix[0].length;
    for (const row of matrix) {
        const leader = row[0];
        let key = '';
        for (let j = 0; j < n; j++) key += (row[j] ^ leader);
        freq.set(key, (freq.get(key) || 0) + 1);
    }
    let best = 0;
    for (const c of freq.values()) {
        if (c > best) best = c;
    }
    return best;
};

class Solution {
    public int maxEqualRowsAfterFlips(int[][] matrix) {
        Map<String, Integer> freq = new HashMap<>();
        int n = matrix[0].length;
        for (int[] row : matrix) {
            int leader = row[0];
            StringBuilder sb = new StringBuilder(n);
            for (int j = 0; j < n; j++) sb.append((char) ('0' + (row[j] ^ leader)));
            String key = sb.toString();
            freq.merge(key, 1, Integer::sum);
        }
        int best = 0;
        for (int c : freq.values()) best = Math.max(best, c);
        return best;
    }
}

function maxEqualRowsAfterFlips(matrix: number[][]): number {
    const freq = new Map<string, number>();
    const n = matrix[0].length;
    for (const row of matrix) {
        const leader = row[0];
        let key = '';
        for (let j = 0; j < n; j++) key += (row[j] ^ leader);
        freq.set(key, (freq.get(key) ?? 0) + 1);
    }
    let best = 0;
    for (const c of freq.values()) {
        if (c > best) best = c;
    }
    return best;
}