字符统计及重排

题目描述

给出一个仅包含字母的字符串, 不包含空格, 统计字符串中各个字母（区分大小写）出现的次数,

并按照字母出现次数从大到小的顺序. 输出各个字母及其出现次数.

如果次数相同, 按照自然顺序进行排序, 且小写字母在大写字母之前.

输入描述

输入一行, 为一个仅包含字母的字符串.

输出描述

按照字母出现次数从大到小的顺序输出各个字母和字母次数, 用英文分号分隔, 注意末尾的分号.

字母和次数间用英文冒号分隔.

示例1

输入:

xyxyXX

输出:

x:2;y:2;X:2;

示例2

输入:

abababb

输出:

b:4;a:3;

说明: b的出现个数比a多，故b排在a之前

题解

Python

def solution1():
    # 创建计数数组
    # 读取输入, 并统计所有字母出现的次数
    # 统计出现的最多次数
    # 然后逆向遍历所有的次数, 并打印结果
    chars = [0] * 256
    for char in input().strip():
        index = ord(char)
        chars[index] += 1

    max_count = max(chars)
    out = []
    for count in range(max_count, 0, -1):
        # 遍历所有的小写字母
        for char_index in range(ord('a'), ord('z') + 1):
            if chars[char_index] == count:
                out.append("{}:{}".format(chr(char_index), count))
        
        # 再遍历所有的大写字母
        for char_index in range(ord('A'), ord('Z') + 1):
            if chars[char_index] == count:
                out.append("{}:{}".format(chr(char_index), count))

    # 打印结果
    s = ";".join(out)
    print(s)

def solution2():
    # 读取输入
    # 创建计数字典
    # 统计所有字母出现的次数
    # 然后转换成数组, 并对其进行排序

    chars = dict()
    for char in input().strip():
        if char not in chars:
            chars[char] = 0
        chars[char] += 1
    print(chars_list)

    # 打印结果
    s = ";".join(F"{char}:{count}" for (char, count) in chars_list)
    print(s)

def main():
    solution1()

if __name__ == "__main__":
    main()

Rust

use std::io::{stdin, BufRead};

fn main() {
    // 创建计数数组
    // 读取输入, 并统计所有字母出现的次数
    // 统计出现的最多次数
    // 然后逆向遍历所有的次数, 并打印结果
    let mut chars = [0_usize; 256];
    let mut line = String::new();
    let ret = stdin().lock().read_line(&mut line);
    assert!(ret.is_ok());

    for byte in line.trim().bytes() {
        let index: usize = byte as usize;
        chars[index] += 1;
    }

    let max_count: usize = chars.iter().max().copied().unwrap();
    let mut out = Vec::new();

    for count in (1..=max_count).rev() {
        // 遍历所有的小写字母
        for byte in b'a'..=b'z' {
            let index = byte as usize;
            if chars[index] == count {
                out.push(format!("{}:{count}", char::from_u32(byte as u32).unwrap()));
            }
        }

        // 遍历所有的大写字母
        for byte in b'A'..=b'Z' {
            let index = byte as usize;
            if chars[index] == count {
                out.push(format!("{}:{count}", char::from_u32(byte as u32).unwrap()));
            }
        }
    }

    // 打印结果
    let s = out.join(";");
    println!("{s}");
}

C++

#include <array>
#include <iostream>
#include <vector>

int main() {
  // 创建计数数组
  // 读取输入, 并统计所有字母出现的次数
  // 统计出现的最多次数
  // 然后逆向遍历所有的次数, 并打印结果

  const size_t kNumChars = 256;
  std::array<int, kNumChars> chars;
  for (int i = 0; i < kNumChars; ++i) {
    chars[i] = 0;
  }

  std::string line;
  std::getline(std::cin, line);
  for (char chr : line) {
    int index = static_cast<int>(chr);
    chars[index] += 1;
  }

  const int max_count = *std::max(chars.cbegin(), chars.cend());
  std::vector<std::string> out;
  const size_t kBufLen = 64;
  char buf[kBufLen];

  for (int count = max_count; count > 0; --count) {
    // 遍历所有的小写字母
    for (int char_index = static_cast<int>('a'); char_index <= static_cast<int>('z'); ++char_index) {
      if (chars[char_index] == count) {
        const int s_len = std::snprintf(buf, kBufLen, "%c:%d", static_cast<char>(char_index), count);
        out.emplace_back(buf, s_len);
      }
    }

    // 再遍历所有的大写字母
    for (int char_index = static_cast<int>('A'); char_index <= static_cast<int>('Z'); ++char_index) {
      if (chars[char_index] == count) {
        const int s_len = std::snprintf(buf, kBufLen, "%c:%d", static_cast<char>(char_index), count);
        out.emplace_back(buf, s_len);
      }
    }
  }

  // 打印结果
  for (int i = 0; i + 1 < out.size(); ++i) {
    std::cout << out[i] << ";";
  }
  std::cout << out[out.size() - 1] << std::endl;

  return 0;
}