返回目录

给定一个字符串，仅含英文字母和数字，请按如下规则对其进行排序：
排序后，原位置是数字的，排序后仍然是数字；原位置是字母的，排序后仍然是字母
数字：按 0-9 升序
英文字母：大写字母大于小写字母，小写字母按a-z升序，大写字母按A-Z升序

1）示例1：
输入：a2CB1c 输出：a1cB2C
2）示例2：
输入：ab12C4Ac3B 输出：ab12c3AB4C

Python源码

public class Main {
    public static void main(String[] args) {
        String str = "ab12C4Ac3B";
        System.out.println(solution(str));
    }

    /**
     * Rearranges the characters in the given string such that:
     * - Digits are sorted in ascending order.
     * - Letters are sorted in non-descending order, with uppercase letters coming before lowercase letters.
     * @param str the input string
     * @return the rearranged string
     */
    private static String solution(String str) {
        char[] array = str.toCharArray();  // 将输入的字符串转换为字符数组
        ArrayList<Integer> indexs = new ArrayList<>();  // 存储数字的索引
        ArrayList<Character> integers = new ArrayList<>();  // 存储数字字符

        ArrayList<Integer> charIndexs = new ArrayList<>();  // 存储字母的索引
        LinkedList<Character> characters = new LinkedList<>();  // 存储字母字符
        // 将数字和字母分别存储到不同的列表中
        for (int i = 0; i < array.length; i++) {
            if (array[i] >= '0' && array[i] <= '9') {
                indexs.add(i);
                integers.add(array[i]);
            } else {
                charIndexs.add(i);
                characters.add(array[i]);
            }
        }
        // 对数字按升序排列
        integers.sort((a, b) -> a - b);
        // 对字母按非降序排列，大写字母排在小写字母之前
        characters.sort(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                int temp1 = o1;
                int temp2 = o2;
                if (o1 >= 'A' && o1 <= 'Z') {
                    temp1 = o1 + 'z';  // 大写字母转换为对应小写字母的ASCII码加上'z'（这样可以保证大写字母排在小写字母之前）
                }
                if (o2 >= 'A' && o2 <= 'Z') {
                    temp2 = o2 + 'z';
                }
                return temp1 - temp2;
            }
        });
        // 将排序后的数字和字母替换原始字符串中的对应位置
        for (int i = 0; i < indexs.size(); i++) {
            array[indexs.get(i)] = integers.get(i);
        }
        for (int i = 0; i < charIndexs.size(); i++) {
            array[charIndexs.get(i)] = characters.get(i);
        }
        // 将字符数组转换回字符串并返回
        StringBuilder builder = new StringBuilder();
        for (char c : array) {
            builder.append(c);
        }
        return builder.toString();
    }
}

C语言源码

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

// 函数原型
char* solution(char* str);

int main() {
    char str[] = "ab12C4Ac3B";
    printf("%s\n", solution(str));
    return 0;
}

/**
 * 将给定字符串的字符重新排列，使得：
 * - 数字按升序排列。
 * - 字母按非降序排列，大写字母排在小写字母之前。
 * @param str 输入字符串
 * @return 重新排列后的字符串
 */
char* solution(char* str) {
    int length = strlen(str);
    char* array = (char*)malloc((length + 1) * sizeof(char));
    strcpy(array, str);

    // 存储数字和字母的索引
    int indexs[length];
    char integers[length];
    int charIndexs[length];
    char characters[length];
    int intCount = 0, charCount = 0;

    // 将数字和字母分别存储到不同的数组中
    for (int i = 0; i < length; i++) {
        if (array[i] >= '0' && array[i] <= '9') {
            indexs[intCount] = i;
            integers[intCount] = array[i];
            intCount++;
        } else {
            charIndexs[charCount] = i;
            characters[charCount] = array[i];
            charCount++;
        }
    }

    // 对数字按升序排列
    qsort(integers, intCount, sizeof(char), strcmp);

    // 对字母按非降序排列，大写字母排在小写字母之前
    qsort(characters, charCount, sizeof(char), strcmp);

    // 将排序后的数字和字母替换原始字符串中的对应位置
    for (int i = 0; i < intCount; i++) {
        array[indexs[i]] = integers[i];
    }
    for (int i = 0; i < charCount; i++) {
        array[charIndexs[i]] = characters[i];
    }

    return array;
}

Java源码

import java.util.Arrays;

public class Main {

public static void main(String[] args) {
    String str = "ab12C4Ac3B";
    System.out.println(solution(str));
}

/**
 * 重新排列给定字符串中的字符，使得：
 * - 数字按升序排列。
 * - 字母按非降序排列，大写字母排在小写字母前面。
 * @param str 输入字符串
 * @return 重新排列后的字符串
 */
public static String solution(String str) {
    char[] array = str.toCharArray();
    int length = array.length;

    // 将数字和字符分别放入不同的数组
    char[] integers = new char[length];
    char[] characters = new char[length];
    int intCount = 0, charCount = 0;

    for (int i = 0; i < length; i++) {
        if (Character.isDigit(array[i])) {
            integers[intCount++] = array[i];
        } else {
            characters[charCount++] = array[i];
        }
    }

    // 将数字按升序排列
    Arrays.sort(integers, 0, intCount);

    // 将字符按非降序排列，大写字母优先
    Arrays.sort(characters, 0, charCount);

    // 将排序后的数字和字符合并到一个数组中
    char[] result = new char[length];
    int i = 0, j = 0, k = 0;

    while (i < intCount && j < charCount) {
        if (Character.isDigit(integers[i])) {
            result[k++] = integers[i++];
        } else {
            result[k++] = characters[j++];
        }
    }

    while (i < intCount) {
        result[k++] = integers[i++];
    }

    while (j < charCount) {
        result[k++] = characters[j++];
    }

    return new String(result);
}

}