牛客网刷题第一天 | HJ23 删除字符串中出现次数最少的字符、HJ26 字符串排序、

HJ23 删除字符串中出现次数最少的字符

本题的思路就是先统计出每个字母出现的次数，同时记录最少次数，再遍历一遍数组用空字符串取代出现次数最少的字符

Java中可以使用字符类型 `char` 作为字母的key，也可以使用字符串类型 `String` 作为字母的key。如果选择使用字符类型 `char`，则需要将每个字母转换成对应的ASCII码值。例如，字母a对应的ASCII码值是97，因此可以使用以下代码创建包含所有26个字母作为key的map：

Map<Character, Object> map = new HashMap<>();
for(char c='a'; c<='z'; c++){
    map.put(c, null);
}

如果选择使用字符串类型 `String` 作为字母的key，则直接使用每个字母即可。例如：

Map<String, Object> map = new HashMap<>();
for(char c='a'; c<='z'; c++){
    String key = Character.toString(c);
    map.put(key, null);
}

注意，这里使用了Object作为value的类型，实际使用时需要根据需求进行替换。

要将字符串中的某些字符替换为空字符串，可以使用 Java 中的 `replace()` 方法或者正则表达式。具体实现方式如下：

// 使用 replace() 方法
String str = "Hello World!";
str = str.replace("l", "");
System.out.println(str); // 输出：Heo Word!

// 使用正则表达式
String str2 = "Hello World!";
str2 = str2.replaceAll("[lL]", "");
System.out.println(str2); // 输出：Heo Word!

在上述代码中，我们首先定义了一个包含一些字符的字符串。然后，我们分别使用 `replace()` 和 `replaceAll()` 方法将其中的 "l" 字符替换为空字符串。需要注意的是，`replace()` 方法只能替换确定的字符序列，而 `replaceAll()` 方法可以使用正则表达式进行匹配和替换。

在第二个示例中，我们使用了 `[lL]` 的正则表达式来匹配字符串中的 "l" 和 "L" 字符。如果想要替换多个字符，可以使用类似的正则表达式进行匹配。

本题中可以采用遍历字符串，将子串中字符出现次数等于目标值的字符去掉

我采用的是将新建字符串将字符串中不足的添加至新字符串结尾
 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        Map<Character, Integer> map = new HashMap<>();
        //统计字母出现的次数
        for (int i = 0; i < str.length(); i++) {
            map.put(str.charAt(i), map.getOrDefault(str.charAt(i), 0) + 1);
        }
        //找出最小次数
        int min = map.values().stream().min(Comparator.naturalOrder()).get();
        StringBuilder sb = new StringBuilder();
        for (char c : str.toCharArray()) {
            if (map.get(c) != min) {
                sb.append(c);
            }
        }
        System.out.print(sb);
    }
}

HJ26 字符串排序

本题是针对字符串中的字母进行排序，小写字母在大写字母前面；同一个英文字母的大小写同时存在时，按照输入顺序排列；非英文字母的其它字符保持原来的位置。

思路：先将字符串中字母取出，对字母进行排序，将排序后的数组与原数组结合进行插入

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        List<Character> list = new ArrayList<>();
        for (char c : str.toCharArray()) {
            if (Character.isLetter(c)) {
                list.add(c);
            }
        }
        list.sort(new Comparator<Character>() {
            public int compare(Character c1, Character c2) {
                return Character.toLowerCase(c1) - Character.toLowerCase(c2);
            }
        });
        StringBuilder sb = new StringBuilder();
        for (int i = 0, j = 0; i < str.length(); i++) {
            if (Character.isLetter(str.charAt(i))) {
                sb.append(list.get(j++));
            } else {
                sb.append(str.charAt(i));
            }
        }
        System.out.println(sb);
    }
}

1. 定义一个函数，接收一个字符串作为参数。
2. 初始化一个和输入字符串同样大小的数组，用于记录非英文字母的位置。
3. 遍历字符串中的每个字符，如果该字符不是英文字母，则将其位置记录到数组中。
4. 将字符串中的英文字母转换为小写字母。
5. 使用稳定排序算法对字符串中的英文字母进行排序，比较两个字符时，如果它们相同且一个是大写字母而另一个是小写字母，则按照它们在原始字符串中出现的顺序进行比较。
6. 按照记录下来的非英文字母位置，将它们插入到已排序的字符串中。
7. 返回排序后的字符串。

public static String sortString(String inputStr) {
    ArrayList<Integer> nonAlphaIndices = new ArrayList<>();
    for (int i = 0; i < inputStr.length(); i++) {
        if (!Character.isLetter(inputStr.charAt(i))) {
            nonAlphaIndices.add(i);
        }
    }
    inputStr = inputStr.toLowerCase();
    char[] sortedStr = inputStr.toCharArray();
    for (int i = 0; i < sortedStr.length - 1; i++) {
        for (int j = i + 1; j < sortedStr.length; j++) {
            if (sortedStr[i] > sortedStr[j]) {
                char temp = sortedStr[i];
                sortedStr[i] = sortedStr[j];
                sortedStr[j] = temp;
            }
        }
    }
    StringBuilder resultStr = new StringBuilder();
    for (int i = 0; i < inputStr.length(); i++) {
        if (nonAlphaIndices.contains(i)) {
            resultStr.append(inputStr.charAt(i));
        } else {
            resultStr.append(sortedStr[0]);
            sortedStr = Arrays.copyOfRange(sortedStr, 1, sortedStr.length);
        }
    }
    return resultStr.toString();
}