哈希-01-数据分类处理

1. 题目描述

信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、 QQ 用户、手机号码、银行帐号等信息及活动记录。

采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。

数据范围：$1\le I,R\le 100$ ，输入的整数大小满足 $0\le val\le 2^{31}-1$。

输入描述：
一组输入整数序列$I$和一组规则整数序列$R$，$I$和$R$序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0 ~ $2^{31}-1$，序列个数不限

输出描述：
从$R$依次中取出$R<i>$，对I进行处理，找到满足条件的$I$：

$I$整数对应的数字需要连续包含$R<i>$对应的数字。比如$R<i>$为23，$I$为231，那么$I$包含了$R<i>$，条件满足 。

按$R<i>$从小到大的顺序:

(1) 先输出$R<i>$；
(2) 再输出满足条件的$I$的个数；
(3) 然后输出满足条件的$I$在$I$序列中的位置索引（从0开始）；
(4) 最后再输出$I$。

附加条件：
(1) $R<i>$需要从小到大排序。相同的$R<i>$只需要输出索引小的以及满足条件的I，索引大的需要过滤掉
(2) 如果没有满足条件的$I$，对应的$R<i>$不用输出
(3) 最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)

输入：
15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123
5 6 3 6 3 0

输出：
30 3 6 0 123 3 453 7 3 9 453456 13 453 14 123 6 7 1 456 2 786 4 46 8 665 9 453456 11 456 12 786

说明：
将序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）排序去重后，可得0,3,6。
序列I没有包含0的元素。
序列I中包含3的元素有：I[0]的值为123、I[3]的值为453、I[7]的值为3、I[9]的值为453456、I[13]的值为453、I[14]的值为123。
序列I中包含6的元素有：I[1]的值为456、I[2]的值为786、I[4]的值为46、I[8]的值为665、I[9]的值为453456、I[11]的值为456、I[12]的值为786。
最后按题目要求的格式进行输出即可。

说明：
30----后续有30个整数
3----从小到大排序，第一个R为0，但没有满足条件的I，不输出0，而下一个R是3
6— 存在6个包含3的I
0— 123所在的原序号为0
123— 123包含3，满足条件

2. 思路

虽然题目有些长，但本质并不难。抓住核心：
1）R中的数据需要排序、去重，可以使用TreeSet结构。
2）需要对I中的数据判断，是否包含R中的元素，运用String.contains()即可。
3）注意输出的第一个数字是后面跟着的数字的总和，不是I中有多少元素符合条件。

3. 代码

代码1： 利用TreeSet结构可以实现数据去重和排序，但是注意如果存储的是String类型的数据，数字26和4，会比较2和4的ASCII码值，导致大小比较错误。因此，TreeSet在运用于排序时，应存Integer类型的数据。如代码1所示，存在用例不通过的情况，在代码2中进行了改进。

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

    String s1 = in.nextLine();
    String s2 = in.nextLine();

    String[] split1 = s1.split(" ");
    String[] split2 = s2.split(" ");

    ArrayList<String> I = new ArrayList<>(Arrays.asList(split1).subList(1, split1.length));
    TreeSet<String> R = new TreeSet<>(Arrays.asList(split2).subList(1, split2.length));

    String out = "";
    int sum = 0;
    for (String r : R) {
        int times = 0;
        String s = "";
        for (int i = 0; i < I.size(); i++) {
            if (I.get(i).contains(r)){
                times ++;
                s = s + " " + i + " " + I.get(i);
                sum +=2;
            }
        }
        if (times > 0){
            out = out + " " + r + " " + times + s;
            sum += 2;
        }
    }
    System.out.println(sum + out);

}

代码2：

public static void method2() {
        Scanner in = new Scanner(System.in);

        while (in.hasNext()){
            int i_size = in.nextInt();
            ArrayList<String> I = new ArrayList<>(i_size);
            for (int i = 0; i < i_size; i++) {
                I.add(String.valueOf(in.nextInt()));
            }
            int r_size = in.nextInt();
            TreeSet<Integer> R = new TreeSet<>();
            for (int i = 0; i < r_size; i++) {
                R.add(in.nextInt());
            }

            String out = "";
            int sum = 0;
            for (int r : R) {
                int times = 0;
                String s = "";
                for (int i = 0; i < I.size(); i++) {
                    if (I.get(i).contains(String.valueOf(r))){
                        times ++;
                        s = s + " " + i + " " + I.get(i);
                        sum +=2;
                    }
                }
                if (times > 0){
                    out = out + " " + r + " " + times + s;
                    sum += 2;
                }
            }
            System.out.println(sum + out);
        }
    }

另外：如果想进一步减少耗时，可以使用StringBuilder来拼接字符串。

以上为个人学习分享，如有问题，欢迎指出：）