解题第一天

字符个数统计

1. 字符个数统计
   编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
   例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。

数据范围：
1
≤
�
≤
500

1≤n≤500
输入描述：
输入一行没有空格的字符串。

输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数
解题思路：拿到字符串去空放入set中去重

import java.util.Scanner;
import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
    
        // 注意 hasNext 和 hasNextLine 的区别
       Scanner sc = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String s = sc.nextLine().trim().replace(" ","");
        char[] charArray = s.toCharArray();
        Set<Object> objects = new HashSet<>();
        for (char c : charArray) {
            objects.add(c);
        }
        System.out.println(objects.size());
    }
    }

数字颠倒
描述
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

数据范围：
0
≤
�
≤
2
30
−
1

0≤n≤2
30
−1
输入描述：
输入一个int整数

输出描述：
将这个整数以字符串的形式逆序输出
解题思路：用字符串的反转方法/或者用集合的反转方法

// 注意 hasNext 和 hasNextLine 的区别
//StringBuffer stringBuffer = new StringBuffer();
// Scanner sc = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别

    //stringBuffer.append(sc.nextLine().trim().replace(" ", ""));
    //StringBuffer reverse = stringBuffer.reverse();
    //System.out.println(reverse);


    Scanner sc = new Scanner(System.in);
    // 注意 hasNext 和 hasNextLine 的区别
    String s = sc.nextLine().trim().replace(" ", "");
    char[] charArray = s.toCharArray();
    List<Object> objects = new LinkedList<>();
    for (char c : charArray) {
        objects.add(c);
    }
    Collections.reverse(objects);
    objects.stream().forEach(item-> { System.out.print(item);});

合并表记录

数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。

提示:
0 <= index <= 11111111
1 <= value <= 100000

输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开

输出描述：
输出合并后的键值对（多行）
思路：key存到map中key累加用list.sort的方法排序/或者用map的key排序

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int i = sc.nextInt();
        Map<Integer, Integer> objectObjectHashMap = new HashMap<>();
        ArrayList<Integer> list = new ArrayList<>();
        for (int j = 0; j < i; j++) {
            int key = sc.nextInt();
            int value = sc.nextInt();
            if (objectObjectHashMap.get(key) != null) {
                int addvalue = objectObjectHashMap.get(key) + value;
                objectObjectHashMap.put(key, addvalue);
            } else {
                objectObjectHashMap.put(key, value);
                list.add(key);
            }
        }
     objectObjectHashMap.keySet().stream().sorted().forEach(k -> System.out.println(
                    k + " " + objectObjectHashMap.get(k)));
        //Stream<Integer> sorted = list.stream().sorted();
        //sorted.forEach(item-> System.out.println(item + " " + objectObjectHashMap.get(item)));
    }

句子逆序
描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”

所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

数据范围：输入的字符串长度满足
1
≤
�
≤
1000

1≤n≤1000

注意本题有多组输入
输入描述：
输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。

输出描述：
得到逆序的句子
思路：单词不能直接字符串反转，切割单词反向遍历

  Scanner sc = new Scanner(System.in);
     //注意 hasNext 和 hasNextLine 的区别
        String s = sc.nextLine();
        String[] str = s.split(" ");


        for (int i = str.length - 1; i >= 0; i--) {
            System.out.print(str[i]+ " ");
        }

明明的随机数
描述
明明生成了
�
N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

数据范围：
1
≤
�
≤
1000

1≤n≤1000 ，输入的数字大小满足
1
≤
�
�
�
≤
500

1≤val≤500
输入描述：
第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。
输出描述：
输出多行，表示输入数据处理后的结果

思路：存入set去重再排序

   Scanner sc = new Scanner(System.in);
         //注意 hasNext 和 hasNextLine 的区别
        int count = sc.nextInt();
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < count; i++) {
            set.add(sc.nextInt());
        }
        set.stream().sorted().forEach(item-> System.out.println(item));

字符统计
输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。
数据范围：字符串长度满足
1
≤
�
�
�
(
�
�
�
)
≤
1000

1≤len(str)≤1000

输入描述：
一个只包含小写英文字母和数字的字符串。

输出描述：
一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。

Scanner sc = new Scanner(System.in);
        //注意 hasNext 和 hasNextLine 的区别
        String s = sc.nextLine();
        char[] charArray = s.toCharArray();
        Map<String, Integer> hashMap = new HashMap<>();
         for (char c : charArray) {
            hashMap.merge(String.valueOf(c), 1, Integer::sum);
        }
        //ArrayList<Map.Entry<String, Integer>> list =
        ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>
        (hashMap.entrySet());
        //然后通过比较器来实现排序
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

            //升序排序
            public int compare(Map.Entry<String, Integer> o1,
                               Map.Entry<String, Integer> o2) {
                return o1.getValue().compareTo(o2.getValue()) == 0 ?
                       (int)o2.getKey().charAt(0) - (int)o1.getKey().charAt(0) :
                       o1.getValue().compareTo(o2.getValue());

            }

        } .reversed());
        list.forEach(item-> System.out.print(item.getKey()));

删除字符串中出现次数最少的字符
思路：把字符串存入map找到最少次数，再遍历删除

   Scanner sc = new Scanner(System.in);
        //注意 hasNext 和 hasNextLine 的区别
        String s = sc.nextLine().toLowerCase();
        char[] charArray = s.toCharArray();
        HashMap<Object, Integer> objectObjectHashMap = new HashMap<>();
        for (char c : charArray) {
            if (objectObjectHashMap.get(c) != null) {
                objectObjectHashMap.put(c, 1 + objectObjectHashMap.get(c));
            } else {
                objectObjectHashMap.put(c, 1) ;
            }
        }
        Optional<Integer> first1 =
            objectObjectHashMap.values().stream().sorted().findFirst();
        for (Object o : objectObjectHashMap.keySet()) {
            if (first1.get() == objectObjectHashMap.get(o)) {
                s = s.replaceAll(o.toString(), "");
            }
        }

        System.out.println(s);

字符串排序

Scanner sc = new Scanner(System.in);
         //注意 hasNext 和 hasNextLine 的区别
        int k = sc.nextInt();
        List<String> strings = new ArrayList<>(k);

       for (int i = 0; i < k; i++) {
            strings.add(sc.next());
        }
       
        Collections.sort(strings, new Comparator<String>() {
            @Override
           public int compare(String o1, String o2) {
               return o1.compareTo(o2);
            }
        });

        for (String string : strings) {
            System.out.println(string);
        }
    }