Check if All Characters Have Equal Number of Occurrences solution and explanation

def areOccurrencesEqual(s: str) -> bool:
    from collections import Counter
    freq = Counter(s)
    return len(set(freq.values())) == 1

import java.util.HashMap;
import java.util.HashSet;

public class Solution {
    public boolean areOccurrencesEqual(String s) {
        HashMap<Character, Integer> freq = new HashMap<>();
        for (char ch : s.toCharArray()) {
            freq.put(ch, freq.getOrDefault(ch, 0) + 1);
        }
        return new HashSet<>(freq.values()).size() == 1;
    }
}

#include <unordered_map>
#include <unordered_set>
#include <string>

bool areOccurrencesEqual(std::string s) {
    std::unordered_map<char, int> freq;
    for (char c : s) {
        ++freq[c];
    }
    std::unordered_set<int> countSet;
    for (const auto& pair : freq) {
        countSet.insert(pair.second);
    }
    return countSet.size() == 1;
}

function areOccurrencesEqual(s) {
    const freq = {};
    for (const char of s) {
        if (!freq[char]) freq[char] = 0;
        freq[char]++;
    }
    const uniqueCounts = new Set(Object.values(freq));
    return uniqueCounts.size === 1;
}

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

bool areOccurrencesEqual(char * s) {
    int freq[26] = {0};
    for (int i = 0; s[i] != '\0'; i++) {
        freq[s[i] - 'a']++;
    }
    int first_count = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            if (first_count == 0) {
                first_count = freq[i];
            } else if (freq[i] != first_count) {
                return false;
            }
        }
    }
    return true;
}

using System;
using System.Collections.Generic;

public class Solution {
    public bool AreOccurrencesEqual(string s) {
        var freq = new Dictionary<char, int>();
        foreach (var ch in s) {
            if (!freq.ContainsKey(ch)) freq[ch] = 0;
            freq[ch]++;
        }
        var uniqueCounts = new HashSet<int>(freq.Values);
        return uniqueCounts.Count == 1;
    }
}

def areOccurrencesEqual(s: str) -> bool:
    from collections import Counter
    freq = Counter(s).values()
    freq_list = sorted(freq)
    return freq_list[0] == freq_list[-1]

import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collections;

public class Solution {
    public boolean areOccurrencesEqual(String s) {
        HashMap<Character, Integer> freq = new HashMap<>();
        for (char ch : s.toCharArray()) {
            freq.put(ch, freq.getOrDefault(ch, 0) + 1);
        }
        ArrayList<Integer> countList = new ArrayList<>(freq.values());
        Collections.sort(countList);
        return countList.get(0).equals(countList.get(countList.size() - 1));
    }
}

#include <unordered_map>
#include <vector>
#include <algorithm>

bool areOccurrencesEqual(std::string s) {
    std::unordered_map<char, int> freq;
    for (char c : s) {
        ++freq[c];
    }
    std::vector<int> freqValues;
    for (auto& pair : freq) {
        freqValues.push_back(pair.second);
    }
    std::sort(freqValues.begin(), freqValues.end());
    return freqValues.front() == freqValues.back();
}

function areOccurrencesEqual(s) {
    const freq = {};
    for (const char of s) {
        freq[char] = (freq[char] || 0) + 1;
    }
    const freqValues = Object.values(freq).sort((a, b) => a - b);
    return freqValues[0] === freqValues[freqValues.length - 1];
}

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

bool areOccurrencesEqual(char* s) {
    int freq[26] = {0};
    for (int i = 0; s[i] != '\0'; i++) {
        freq[s[i] - 'a']++;
    }
    int min_count = 0, max_count = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            if (min_count == 0) min_count = freq[i];
            if (freq[i] != min_count) return false;
        }
    }
    return true;
}

using System;
using System.Collections.Generic;
using System.Linq;

public class Solution {
    public bool AreOccurrencesEqual(string s) {
        var freq = new Dictionary<char, int>();
        foreach (var ch in s) {
            if (!freq.ContainsKey(ch)) freq[ch] = 0;
            freq[ch]++;
        }
        var freqValues = freq.Values.ToList();
        freqValues.Sort();
        return freqValues.First() == freqValues.Last();
    }
}

function areOccurrencesEqual(s: string): boolean {
    const cnt: number[] = Array(26).fill(0);
    for (const c of s) {
        ++cnt[c.charCodeAt(0) - 'a'.charCodeAt(0)];
    }
    const v = cnt.find(v => v);
    return cnt.every(x => !x || v === x);
}

func areOccurrencesEqual(s string) bool {
	cnt := [26]int{}
	for _, c := range s {
		cnt[c-'a']++
	}
	v := 0
	for _, x := range cnt {
		if x == 0 {
			continue
		}
		if v > 0 && v != x {
			return false
		}
		v = x
	}
	return true
}

class Solution {
    /**
     * @param String $s
     * @return Boolean
     */
    function areOccurrencesEqual($s) {
        $cnt = array_fill(0, 26, 0);
        for ($i = 0; $i < strlen($s); $i++) {
            $cnt[ord($s[$i]) - ord('a')]++;
        }
        $v = 0;
        foreach ($cnt as $x) {
            if ($x == 0) {
                continue;
            }
            if ($v && $v != $x) {
                return false;
            }
            $v = $x;
        }
        return true;
    }
}