T1437，T1149，T1199，T1128

T1437

给定一个数组 a ，求出这个数组的最大值和次大值（严格的，即次大值一定比最大值小）

解析：使用 TreeSet 接受数据去重，使用定制排序是数据从大到小排列，将TreeSet转化为List，输出第一个和第二个位置的元素

package com.java3.ch5;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class T1437 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();
        TreeSet<Integer> set = new TreeSet<>(new Comparator<Integer>() {
            //从大到小排列
            @Override
            public int compare(Integer o1, Integer o2) {
                return -(o1 - o2);
            }
        });

        //接受数据 并去重
        for(int i = 0;i < n;i++){
            set.add(scan.nextInt());
        }
        //将Set转化为List,可以使用下标索引
        ArrayList<Integer> list = new ArrayList<>(set);

        System.out.println(list.get(0) + " " + list.get(1));
    }
}

5
1 2 3 4 5
5 4

T1149

给定一个字符串，在字符串中找到第一个连续出现至少 k 次的字符

解析：使用 charList 存储新字符，使用 countList 记录每个字符连续出现的位置 index 标记新字符的索引位置

比较前一个字符和现在的字符是否相等，相等，countList[index] 加1，index不变，不等，index +1，charList 添加新字符，countList 添加1

注：本课求连续出现的字符，不能使用 indexof() 方法来统计字符的数量

package com.java3.ch5;

import java.util.ArrayList;
import java.util.Scanner;

public class T1149 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        int k = scan.nextInt();
        String string = scan.next();
        ArrayList<Character> charList = new ArrayList<>();
        ArrayList<Integer> countList = new ArrayList<>();
        //使用index记录每次索引的位置
        int index = 0;
        //添加字符及其数量
        for(int i = 0;i < string.length();i++) {
            // 后一个字符与前一个字符进行比较 相等 数量加1 不相等 添加新字符

            //第一个字符直接添加 不用判断
            if( i == 0){
                charList.add(string.charAt(i));
                countList.add(1);
            }else{
                char tempLast = string.charAt(i - 1);
                char tempNow = string.charAt(i);
                boolean isEquals = (tempLast == tempNow);

                //上一个字符与下一个字符比较结果
                if(isEquals){
                    //相等 索引位置不变 数量+1
                    int tempCount = countList.get(index) + 1;
                    countList.set(index,tempCount);
                }else{
                    //不等 索引位置+1 添加新字符
                    charList.add(tempNow);
                    countList.add(1);
                    index++;
                }
            }
        }

//        for(int i = 0;i < charList.size();i++){
//            System.out.println(charList.get(i) + " "+ countList.get(i));
//        }


        //判断有无大于k的字符数量
        //初始定义没有大于k的字符数量
        boolean isFlag = false;
        for(int i = 0;i < countList.size();i++){

            if(countList.get(i) >= k){
                isFlag = true;
                System.out.print(charList.get(i) );
                break;
            }
        }
        if(!isFlag){
            System.out.println("No");
        }
    }
}

3
abcccaaab
c

T1199

小蒜有一个长度为n(n ≤ 1000) 的整数序列，判断是否存在某两个元素之和为k( k ≤ 100)

解析：使用dataList来存储数据，使用双重循环遍历 dataList 的数据

注意：是否存在某两个元素之和 ，所以 j = i + 1

package com.java3.ch5;

import java.util.ArrayList;
import java.util.Scanner;

public class T1199 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();
        int k = scan.nextInt();
        ArrayList<Integer> dataList = new ArrayList<>();
        //ArrayList<Integer> sumList = new ArrayList<>();

        for(int i = 0;i < n;i++){
            dataList.add(scan.nextInt());
        }
        //isFlag :没有找到
        boolean isFlag = true;
        for(int i = 0;i < dataList.size();i++){
            for(int j = i + 1;j < dataList.size();j++){
                int temp = dataList.get(i) + dataList.get(j);
                if(temp == k){
                    System.out.println("yes");
                    isFlag = false;
                    break;
                }

            }
            if(!isFlag){
                break;
            }
        }

        if(isFlag){
            System.out.println("no");
        }
    }
}

9 10
1 2 3 4 5 6 7 8 9
yes

T1128

给定一个完全由数字字符（‘0’，‘1’，‘2’，…，‘9’）构成的字符串 str，请写出 str 的 p 型编码串

例如：字符串122344111可被描述为“11 个 11、22 个 22、11 个 33、22 个 44、33 个 11”，因此我们说 122344111 的 p 型编码串为1122132431；类似的道理，编码串101可以用来描述1111111111；00000000000可描述为“1111 个 00”，因此它的 p 型编码串即为110；100200300可描述为“11 个 11、22 个 00、11 个 22、22 个 00、11 个 33、22 个 00”，因此它的 p 型编码串为112012201320

解析：本题与 T1149 很相似，主要就是统计连续字符及其出现的数量，最后按照给定的要求输出

注：int 型 不能直接与 char型做 ‘+’ 运算，会导致自动类型提升

package com.java3.ch5;

import java.util.ArrayList;
import java.util.Scanner;

public class T1128 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        String string = scan.next();

        ArrayList<Character> charList = new ArrayList<>();
        ArrayList<Integer> countList = new ArrayList<>();
        //使用index记录每次索引的位置
        int index = 0;
        //添加字符及其数量
        for(int i = 0;i < string.length();i++) {
            // 后一个字符与前一个字符进行比较 相等 数量加1 不相等 添加新字符

            //第一个字符直接添加 不用判断
            if( i == 0){
                charList.add(string.charAt(i));
                countList.add(1);
            }else{
                char tempLast = string.charAt(i - 1);
                char tempNow = string.charAt(i);
                boolean isEquals = (tempLast == tempNow);

                //上一个字符与下一个字符比较结果
                if(isEquals){
                    //相等 索引位置不变 数量+1
                    int tempCount = countList.get(index) + 1;
                    countList.set(index,tempCount);
                }else{
                    //不等 索引位置+1 添加新字符
                    charList.add(tempNow);
                    countList.add(1);
                    index++;
                }
            }
        }

        for(int i = 0;i < charList.size();i++){
            String tempCount = String.valueOf(countList.get(i));
            System.out.print(tempCount +charList.get(i));
        }
    }
}

122344111
1122132431