返回目录

Python源码

def solution(s):
    # 将字符串转换为字符列表
    char_list = list(s)
    # 对字符列表进行排序
    char_list.sort()
    # 使用列表构建排序后的字符串
    sorted_str = ''.join(char_list)
    # 使用字典统计字符及其出现次数
    char_count = {}
    for char in char_list:
        char_count[char] = char_count.get(char, 0) + 1
    # 构建每个字符及其出现次数的统计信息
    count_info = ''.join([f"{char}{count}" for char, count in char_count.items()])
    # 返回排序后的字符串及统计信息
    return sorted_str + "\n" + count_info

# 测试主函数
if __name__ == "__main__":
    # 输入测试字符串
    test_str = "indepe11nd2e2nt"
    # 调用解决方案并打印结果
    print(solution(test_str))

C语言源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 比较字符以进行排序的函数
int compare(const void *a, const void *b) {
    return (*(char *)a - *(char *)b);
}

// 处理字符串的函数
char* solution(char *str) {
    // 将字符串转换为字符数组
    char *sorted_str = (char *)malloc(strlen(str) * sizeof(char));
    strcpy(sorted_str, str);
  
    // 对字符串中的字符进行排序
    qsort(sorted_str, strlen(sorted_str), sizeof(char), compare);

    // 打印排序后的字符串
    printf("%s\n", sorted_str);

    // 统计并打印每个字符的出现次数
    int count = 1;
    char *count_info = (char *)malloc(strlen(str) * sizeof(char));
    int index = 0;
    for (int i = 1; i <= strlen(sorted_str); i++) {
        if (sorted_str[i] == sorted_str[i - 1]) {
            count++;
        } else {
            count_info[index++] = sorted_str[i - 1];
            count_info[index++] = count + '0';
            count = 1;
        }
    }
    count_info[index] = '\0';

    // 拼接排序后的字符串和统计信息
    char *result = (char *)malloc((strlen(sorted_str) + strlen(count_info) + 2) * sizeof(char));
    strcpy(result, sorted_str);
    strcat(result, "\n");
    strcat(result, count_info);

    // 释放动态分配的内存
    free(sorted_str);
    free(count_info);

    return result;
}

int main() {
    // 输入测试字符串
    char str[] = "indepe11nd2e2nt";
  
    // 调用处理函数
    char *result = solution(str);
    printf("%s\n", result);

    // 释放动态分配的内存
    free(result);

    return 0;
}

Java源码

public class Main {
    public static void main(String[] args) {
        // 输入测试字符串
        String str = "indepe11nd2e2nt";
        // 调用解决方案并打印结果
        System.out.println(solution(str));
    }

    /**
     * 对给定字符串进行处理，将字符按升序排列，并输出每个字符及其出现次数。
     * @param str 输入字符串
     * @return 排序后的字符串及每个字符及其出现次数的统计信息
     */
    private static String solution(String str) {
        // 将字符逐个添加到 ArrayList 中
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < str.toCharArray().length; i++) {
            list.add(str.charAt(i));
        }
        // 对字符进行排序
        list.sort((a, b) -> a - b);
        // 使用 StringBuilder 构建排序后的字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (Character character : list) {
            stringBuilder.append(character);
        }
        // 使用 TreeMap 统计字符及其出现次数
        TreeMap<Character, Integer> map = new TreeMap<>();
        for (Character character : list) {
            map.put(character, map.getOrDefault(character, 0) + 1);
        }
        // 使用 StringBuilder 构建每个字符及其出现次数的统计信息
        StringBuilder builder = new StringBuilder();
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            builder.append(entry.getKey()).append(entry.getValue());
        }
        // 返回排序后的字符串及统计信息
        return stringBuilder + "\n" + builder;
    }
}