2026-02-20：众数频率字符。用go语言，给定一个只含小写字母的字符串 s。 把所有在 s 中出现次数相同的字母归为一类：对于某个整数 k，出

ab

package main

import (
    "fmt"
)

func majorityFrequencyGroup(s string)string {
    cnt := [26]int{}
    for _, b := range s {
        cnt[b-'a']++
    }

    groups := map[int][]byte{}
    mx := 0
    for i, c := range cnt {
        if c == 0 {
            continue
        }
        groups[c] = append(groups[c], 'a'+byte(i))
        iflen(groups[c]) > len(groups[mx]) || len(groups[c]) == len(groups[mx]) && c > mx {
            mx = c
        }
    }

    returnstring(groups[mx])
}

func main() {
    s := "aaabbbccdddde"
    result := majorityFrequencyGroup(s)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

def majority_frequency_group(s: str) -> str:
    # 统计每个字符的出现频率
    cnt = [0] * 26
    for ch in s:
        cnt[ord(ch) - ord('a')] += 1
    
    # 按频率分组存储字符
    groups = {}
    mx = 0  # 记录当前最大频率
    
    for i, c in enumerate(cnt):
        if c == 0:
            continue
        
        # 将字符添加到对应频率的分组中
        if c not in groups:
            groups[c] = []
        groups[c].append(chr(ord('a') + i))
        
        # 更新最大频率的选择标准：
        # 1. 当前分组的字符数量大于最大频率分组的字符数量
        # 2. 或者字符数量相等但当前频率值更大
        if mx not in groups:
            mx = c
        elif len(groups[c]) > len(groups[mx]):
            mx = c
        elif len(groups[c]) == len(groups[mx]) and c > mx:
            mx = c
    
    # 返回最大频率分组中的所有字符组成的字符串
    return''.join(sorted(groups[mx]))  # 排序以保证输出顺序一致

# 测试
if __name__ == "__main__":
    s = "aaabbbccdddde"
    result = majority_frequency_group(s)
    print(result)

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

string majorityFrequencyGroup(string s) {
    // 统计每个字符的出现频率
    vector<int> cnt(26, 0);
    for (char ch : s) {
        cnt[ch - 'a']++;
    }

    // 按频率分组存储字符
    unordered_map<int, vector<char>> groups;
    int mx = 0;  // 记录当前最大频率

    for (int i = 0; i < 26; i++) {
        int c = cnt[i];
        if (c == 0) {
            continue;
        }

        // 将字符添加到对应频率的分组中
        groups[c].push_back('a' + i);

        // 更新最大频率的选择标准：
        // 1. 当前分组的字符数量大于最大频率分组的字符数量
        // 2. 或者字符数量相等但当前频率值更大
        if (groups.count(mx) == 0) {
            mx = c;
        } elseif (groups[c].size() > groups[mx].size()) {
            mx = c;
        } elseif (groups[c].size() == groups[mx].size() && c > mx) {
            mx = c;
        }
    }

    // 对结果中的字符排序，保证输出顺序一致
    vector<char>& result_chars = groups[mx];
    sort(result_chars.begin(), result_chars.end());

    // 将字符向量转换为字符串
    returnstring(result_chars.begin(), result_chars.end());
}

int main() {
    string s = "aaabbbccdddde";
    string result = majorityFrequencyGroup(s);
    cout << result << endl;
    return0;
}