首页 > 试题广场 >

数据分类处理

[编程题]数据分类处理

热度指数：164098 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M
算法知识视频讲解

信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、 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)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
 
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数） 
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数） 
输出：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
说明：
30----后续有30个整数
3----从小到大排序，第一个R<i>为0，但没有满足条件的I，不输出0，而下一个R<i>是3
6--- 存在6个包含3的I 
0--- 123所在的原序号为0 
123--- 123包含3，满足条件

示例1

输入

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。
最后按题目要求的格式进行输出即可。

算法知识视频讲解

Java

不再crud

import java.util.*;
import java.util.stream.Collectors;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    static List<Integer> l = new ArrayList();

    static List<Integer> r = new ArrayList();

    static List<Integer> ans = new ArrayList();

    static class Item {
        int dx;
        int val;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            for (int i = 0; i < n; ++ i) l.add(in.nextInt());
            n = in.nextInt();
            for (int i = 0; i < n; ++ i) r.add(in.nextInt());
            r = r.stream().distinct().sorted().collect(Collectors.toList());

            for (int a : r) {
                List<Item> t = new ArrayList();
                for (int i = 0; i < l.size(); ++ i) {
                    String str = l.get(i) + "";
                    if (str.contains(a + "")) {
                        Item it = new Item();
                        it.dx = i; it.val = l.get(i);
                        t.add(it);
                    }
                }
                if (t.size() > 0) {
                    ans.add(a);
                    ans.add(t.size());
                    for (Item it : t) {
                        ans.add(it.dx);
                        ans.add(it.val);
                    }
                }
            }

            System.out.print(ans.size() + " ");
            for (int a : ans) System.out.print(a + " ");
        }
    }
}

编辑于 2024-03-24 13:59:29 回复(0)

Java

NOoOo0B

难度其实不大，关键要读懂题意，选择合适的数据结构

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //处理第一行
        int n = in.nextInt();
        String[] str = in.nextLine().split(" ");
        //处理第二行
        int m = in.nextInt();
        Set<Integer> set = new TreeSet<>();//排序+去重
        for (int j = 0; j < m; j++) {
            set.add(in.nextInt());
        }
        //寻找符合各个要求的元素
        List<List<String>> list = new ArrayList<>();
        for (int i : set) {
            List<String> temp = new ArrayList<>();
            for (int k = 1; k < n + 1; k++) {
                if (str[k].contains(Integer.toString(i))) {
                    temp.add(Integer.toString(k - 1) + " " + str[k]);
                }
            }
            list.add(temp);
        }
        //计算待输出的元素个数
        int total = 0;
        for (int i = 0; i < list.size(); i++) {
            int size=list.get(i).size();
            total += 2 * size;
            if (size != 0) {
                total += 2;//如果没有满足条件的就不+2
            }
        }
        //按格式输出元素
        List<Integer> nums=new ArrayList<>(set);
        System.out.print(total);
        for (int i = 0; i < list.size(); i++) {
            int size=list.get(i).size();
            if (size != 0) {
                System.out.print(" "+nums.get(i)+" "+size);
            }
            for(int j=0;j<size;j++){
                System.out.print(" "+list.get(i).get(j));
            }
        }
    }
}

编辑于 2024-03-22 14:49:57 回复(0)

Java

牛客309616969号

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int ni = in.nextInt();

int[] nis = new int[ni];

for (int i = 0; i < ni; i++) {

nis[i] = in.nextInt();

}

int nr = in.nextInt();

int[] nrs = new int[nr];

for (int i = 0; i < nr; i++) {

nrs[i] = in.nextInt();

}

List<Integer> res = new ArrayList<>();

Arrays.sort(nrs);

nrs = Arrays.stream(nrs).distinct().toArray();

for (int i = 0; i < nrs.length; i++) {

int sum = 0;

List<Integer> res2 = new ArrayList<>();

for (int j = 0; j < nis.length; j++) {

if (String.valueOf(nis[j]).contains(String.valueOf(nrs[i]))) {

res2.add(j);

res2.add(nis[j]);

sum++;

}

if (sum != 0) {

res.add(nrs[i]);

res.add(sum);

res.addAll(res2);

}

System.out.print(res.size() + " ");

res.forEach(i->System.out.print(i + " "));

}

编辑于 2024-01-20 16:16:43 回复(0)

Java

今生能进大厂吗

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            //储存R
            int rnum = in.nextInt();
            ArrayList<String> rarr = new ArrayList<>();
            for (int i = 0; i < rnum; i++) {
                rarr.add(in.nextInt() + "");
            }
            //储存I
            int inum = in.nextInt();
            TreeSet<Integer> treeSet = new TreeSet<>();//去重且排序
            for (int i = 0; i < inum; i++) {
                treeSet.add(in.nextInt());
            }

            int count = 0;//记录每个I在R中的次数
            String res = "";//记录I出现在R中的索引+R值  形如:0 123 3 453 7 3 9 453456 13 453 14 123
            LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
            int num = 0;//num记录res 中非空格的数量 
            for (Integer i : treeSet) {
                String stringI = i.toString();
                for (int j = 0; j < rarr.size(); j++) {
                    if (rarr.get(j).contains(stringI)) {
                        count++;
                        res += "".equals(res) ? j + " " + rarr.get(j) : " " + j + " " + rarr.get(j);
                    }
                }
                res = stringI + " " + count + " " + res;//这里拼接上对应的I值与R中出现次数 形如:3 6 0 123 3 453 7 3 9 453456 13 453 14 123
                if (count == 0) {
                    res = "";//count为0时 要重置res
                    continue;
                }
                linkedHashSet.add(res);
                num += count * 2;
                count = 0;
                res = "";
            }
            num = num + linkedHashSet.size() * 2;
            String out = "";
            for (String s : linkedHashSet) {
                out += s+" ";
            }
            System.out.println(num + " " + out);
        }
    }
}

发表于 2023-12-12 15:51:58 回复(0)

Java

牛客74807299号

import java.util.*;

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

        // 得到序列I的数量
        int iNum;
        if (in.hasNextInt()) {
            iNum = in.nextInt();
        } else {
            return;
        }
        if (iNum <= 0) {
            return;
        }
        // 得到序列I的内容
        Map<Integer, Integer> iMap = new HashMap<>();
        for (int i = 0; i < iNum; i++) {
            if (in.hasNextInt()) {
                iMap.put(i, in.nextInt());
            } else {
                return;
            }
        }

        // 得到序列R的数量
        int rNum;
        if (in.hasNextInt()) {
            rNum = in.nextInt();
        } else {
            return;
        }
        if (rNum <= 0) {
            return;
        }
        // 得到序列R的内容
        TreeSet<Integer> rSet = new TreeSet<>();
        for (int i = 0; i < rNum; i++) {
            if (in.hasNextInt()) {
                rSet.add(in.nextInt());
            } else {
                return;
            }
        }

        StringBuilder allSb = new StringBuilder();
        // 计算序列I中满足包含R内容的部分
        for (Integer r : rSet) {
            String rStr = String.valueOf(r);
            int count = 0;
            StringBuilder rSb = new StringBuilder();
            for (Map.Entry<Integer, Integer> entry : iMap.entrySet()) {
                if (String.valueOf(entry.getValue()).contains(rStr)) {
                    count++;
                    rSb.append(entry.getKey())
                    .append(" ")
                    .append(entry.getValue())
                    .append(" ");
                }
            }
            if (count > 0) {
                rSb.insert(0, r + " " + count + " ");
                allSb.append(rSb.toString());
            }
        }

        // 计算总数量
        String all = allSb.toString();
        int count = all.split(" ").length;

        // 输出
        System.out.println(count + " " + all);
    }
}

发表于 2023-11-10 12:11:30 回复(0)

Java

butt

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) { 
            //记录输入
            int I_num = in.nextInt();
            Integer[] I=new Integer[I_num];
            List<Integer> list=new ArrayList<Integer>();
            for (int i = 0; i < I_num; i++) {
                I[i]=in.nextInt();
            }
            int R_num = in.nextInt();
            Integer[] R=new Integer[R_num];
            TreeSet<Integer> treeSet=new TreeSet<>();
            for (int i = 0; i < R_num; i++) {
                R[i]=in.nextInt();
                treeSet.add(R[i]);
            }
            //记录总输出个数，每一个R对应的I个数
            int[] R_I_num=new int[treeSet.size()];
            int num=0;
            int count=0;
            for (Integer integer : treeSet) {
                for (int i = 0; i < I_num; i++) {
                    list.clear();
                    if(I[i].toString().contains(integer.toString())&&list.contains(I[i])!=true)
                    {
                        R_I_num[count]+=1;
                        num+=2;
                        list.add(I[i]);
                    }
                }
                if(R_I_num[count]!=0)
                {
                    num+=2;
                }
                count++;

            }
            //打印
            System.out.print(num);
            count=0;
            for (Integer integer : treeSet) {
                if (R_I_num[count]!=0){
                    System.out.print(" "+integer+" "+R_I_num[count]);
                for (int i = 0; i < I_num; i++) {
                    list.clear();
                    if(I[i].toString().contains(integer.toString())&&list.contains(I[i])!=true)
                    {
                        System.out.print(" "+i+" "+I[i]);
                        list.add(I[i]);
                    }
                }
                }
                count++;

            }
        }
    }
}

发表于 2023-09-07 14:37:41 回复(0)

Java

一个杠杆

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

// 注意类名必须为 Main, 不要有任何 package xxx 信息

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// 注意 hasNext 和 hasNextLine 的区别

while (in.hasNextInt()) { // 注意 while 处理多个 case

int inum = in.nextInt();

int[] iarray = new int[inum];

for(int i = 0; i < inum; i++){

iarray[i] = in.nextInt();

}

int rnum = in.nextInt();

int[] rarray = new int[rnum];

for(int i = 0; i < rnum; i++){

rarray[i] = in.nextInt();

}

function(iarray, rarray);

}

public static void function(int[] iarray, int[] rarray){

Map<Integer, Map<Integer, Integer>> map = new TreeMap<>();

Arrays.sort(rarray);

TreeSet<Integer> rset = new TreeSet<>((o1, o2) -> o1.compareTo(o2));

for(int i = 0; i < rarray.length; i++){

rset.add(rarray[i]);

}

int n = iarray.length;

int count = 0;

for(int num : rset){

Map<Integer, Integer> submap = new TreeMap<>();

for(int i = 0; i < n; i++){

if(isMatch(num, iarray[i])){

submap.put(i, iarray[i]);

count++;

}

if(!submap.isEmpty()){

map.put(num, submap);

}

System.out.print((count * 2 + map.size() * 2)+ " ");

for(Integer it : map.keySet()){

System.out.print(it + " " + map.get(it).size() + " ");

map.get(it).forEach((key, value) ->{

System.out.print(key + " " + value + " ");

});

}

public static boolean isMatch(int num, int num2){

String s1 = num + "";

String s2 = num2 + "";

return s2.contains(s1) ? true : false;

}

// 数据结构算是被用明白了

发表于 2023-08-19 17:03:48 回复(0)

Java

naivortang

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int [] i=new int[a];
            for(int k=0;k<a;k++){
                i[k]=in.nextInt();
            }
            
            int b = in.nextInt();
            HashSet<Integer> set=new HashSet();
            for(int k=0;k<b;k++){
                set.add(in.nextInt());
            }

            List<Integer> list=new ArrayList(set);
            Collections.sort(list);

            HashMap<Integer,List<Integer>> map=new HashMap();
           
            for(int k:list){
                List<Integer> indexes=new ArrayList();
                for(int j=0;j<a;j++){
                   boolean contain= String.valueOf(i[j]).contains(k+"");
                   if(contain){
                        indexes.add(j);
                   }
                }
                map.put(k,indexes);
            }

            List<Integer> result=new ArrayList();
             for(int k:list){
                List<Integer> data=map.get(k);
                if(data.size()>0){
                    result.add(k);
                    result.add(data.size());

                    for(int m=0;m<data.size();m++){
                         int index=data.get(m);
                        result.add(index);
                       
                        result.add(i[index]);
                    }
                }
             }

           
            System.out.print(result.size());
            for(int n:result){
                System.out.print(" "+n);
            }


           
        }
    }
}

发表于 2023-08-07 23:16:17 回复(0)

Java

DKdragon

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

//  I   15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123
//  R    5 6 3 6 3 0
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String iLIne = in.nextLine();
        String rLIne = in.nextLine();

        String[] iArr = iLIne.split(" ");
        String[] rArr = rLIne.split(" ");

        // 存放 R<i>
        Map<Integer, Integer> Ri = new LinkedHashMap<>();
        // 存放 R<i> 和 索引 <==> I
        Map<Integer, LinkedHashMap<Integer, Integer>> index = new LinkedHashMap<>();
        // 存放 R<i> 和 索引的顺序
        Map<Integer, List<Integer>> sx = new HashMap<>();

        String R = "";
        String I = "";
        for (int i = 1; i <= Integer.parseInt(rArr[0]); i++) {
            R = rArr[i];
            for (int j = 1; j <= Integer.parseInt(iArr[0]); j++) {
                I = iArr[j];
                if (I.contains(R)) {
                    Integer key = Integer.valueOf(R);
                    LinkedHashMap<Integer, Integer> map = index.get(key);
                    if (map == null) {
                        
                        Ri.put(key, Ri.getOrDefault(key, 0) + 1);
                        map = new LinkedHashMap<>();
                        map.put(j - 1, Integer.valueOf(I));
                        index.put(key, map);
                        List<Integer> sxList = new ArrayList<>();
                        sxList.add(j - 1);
                        sx.put(key, sxList);
                    } else {
                        if (map.get(j - 1) == null) {
                            Ri.put(key, Ri.getOrDefault(key, 0) + 1);
                            map.put(j - 1, Integer.valueOf(I));
                            index.put(key, map);
                            List<Integer> sxList = sx.get(key);
                            sxList.add(j - 1);
                            sx.put(key, sxList);
                        }
                    }
                }

            }
        }

        List<Integer> list =  new ArrayList<>();
        List<Integer> ketSet = new ArrayList<>(Ri.keySet());
        ketSet.sort((a, b) -> a.compareTo(b));

        for (Integer key : ketSet) {
            list.add(key);
            LinkedHashMap<Integer, Integer> map = index.get(key);
            List<Integer> sxList = sx.get(key);
            list.add(Ri.get(key));
            sxList.forEach(index1 -> {
                list.add(index1);
                list.add(map.get(index1));
            });
        }


        StringBuilder builder = new StringBuilder();
        builder.append(list.size());
        for (int i=0; i<list.size(); i++) {
            builder.append(" ").append(list.get(i));
        }

        System.out.print(builder.toString());
        
        // 这个会导致格式不对
        // String result = list.toString().replace("[", "").replace("]", "").replace(",", " ");
        // System.out.print(list.size() + " " + result);

    }
}

发表于 2023-07-14 19:18:47 回复(1)

Java

在泡池子的小饼干很想被叫靓仔

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int ILength = in.nextInt();
            int[] IArr = new int[ILength];
            for (int i = 0; i < ILength; i++) {
                IArr[i] = in.nextInt();
            }
            int RLength = in.nextInt();
            int[] RArr = new int[RLength];
            for (int i = 0; i < RLength; i++) {
                RArr[i] = in.nextInt();
            }

            int[] newRArr = getRArr(RArr);

            ArrayList<String> output = new ArrayList<String>();

            output = getResult(IArr, newRArr);

            for (int i = 0; i < output.size(); i++) {
                if (i < output.size() - 1) {
                    System.out.print(output.get(i));
                    System.out.print(" ");
                } else {
                    System.out.print(output.get(i));
                }
            }
        }
    }

    //返回去重排序的R序列
    public static int[] getRArr(int[] input) {
        int length = input.length;
        TreeSet<Integer> TS = new TreeSet<Integer>();
        for (int i = 0; i < length; i++) {
            TS.add(Integer.valueOf(input[i]));
        }
        int size = TS.size();
        int[] result = new int[size];
        int n = 0;
        for (Integer i : TS) {
            result[n] = i.intValue();
            n++;
        }
        return result;
    }

    //输入IArr和去重排序后的RArr，返回目标ArrayList
    public static ArrayList<String> getResult(int[] I, int[] R) {
        ArrayList<String> result = new ArrayList<String>();
        int Ilength = I.length;
        int Rlength = R.length;
        for (int i = 0; i < Rlength; i++) {
            int count = 0;
            String Rnum = String.valueOf(R[i]);
            for (int j = 0; j < Ilength; j++) {
                String Inum = String.valueOf(I[j]);
                if (Inum.contains(Rnum)) {
                    if (count == 0) {
                        result.add(Rnum);
                    }
                    count++;
                    result.add(String.valueOf(j));
                    result.add(Inum);
                }
            }
            if (count != 0) {
                result.add(result.size() - count * 2,
                           String.valueOf(count)); //插入符合个数
            }
        }

        result.add(0, String.valueOf(result.size()));

        return result;
    }


}

发表于 2023-07-03 20:58:47 回复(0)

Java

真的会谢的小狐狸很胖墩墩

import java.util.*;

public class Main {

public static void main(String[] args){

Scanner in = new Scanner(System.in);

StringBuilder print = new StringBuilder();

while (in.hasNext()) {

int len = in.nextInt();

List<Integer> i = new ArrayList<>();

for (int j = 0; j < len; j++) {

i.add(in.nextInt());

}

len = in.nextInt();

TreeSet<Integer> r = new TreeSet<>();

for (int j = 0; j < len; j++) {

r.add(in.nextInt());

}

for(int v : r){

int count = 0;

StringBuilder ap = new StringBuilder();

for (int j = 0; j < i.size(); j++) {

if(String.valueOf(i.get(j)).contains(v + "")){

count++;

ap.append(j).append(" ").append(i.get(j)).append(" ");

}

if(count > 0){

print.append(v).append(" ").append(count).append(" ")

.append(ap);

}

print = print.deleteCharAt(print.length() - 1);

int size = print.toString().split(" ").length;

System.out.println(size + " " + print);

}

发表于 2023-04-25 11:29:03 回复(0)

Java

孤独方程式

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String I = scanner.nextLine();

String[] splitI = I.split(" ");

int INum = Integer.parseInt(splitI[0]);

ArrayList<String> IarrayList = new ArrayList<>();

for (int i = 1; i <= INum; i++) {

IarrayList.add(splitI[i]);

}

int RNum = scanner.nextInt();

HashSet<Integer> Rset = new HashSet<>();

for (int i = 0; i < RNum; i++) {

Rset.add(scanner.nextInt());

}

// Collections.sort(set);Hashset排序的四种方法

// 1.放到ArrayList中，利用ArrayList.sort来排序

// 2.放到TreeSet中，会自动升序排序。也可以类似于array.sort中的new Comparator<String>()

// 来对TreeSet排序

TreeSet<Integer> set = new TreeSet<>(new Comparator<Integer>() {

@Override

public int compare(Integer o1, Integer o2) {

return o1 - o2;

}

});

set.addAll(Rset);

HashMap<Integer, List<Integer>> map = new HashMap<>();

int countNum = 0;

for (int i : set) {

ArrayList<Integer> IndexArr = new ArrayList<>();

String s = String.valueOf(i);

for (int j = 0; j < IarrayList.size(); j++) {

// StringBuilder stringBuilder = new StringBuilder();

// StringBuilder append = stringBuilder.append(arrayList.get(j));

// append.re

String s1 = IarrayList.get(j);

// String replaceAll = s1.replaceAll(s, "");

if (s1.contains(s)) {

IndexArr.add(j);

map.put(i, IndexArr);

countNum++;

}

ArrayList<Integer> resArr = new ArrayList<>();

for (int i : set) {

if (map.get(i) != null) {

resArr.add(i);

resArr.add(map.get(i).size());

for (int j = 0; j < map.get(i).size(); j++) {

List<Integer> integers = map.get(j);

resArr.add(map.get(i).get(j));

resArr.add(Integer.parseInt(IarrayList.get( map.get(i).get(j))));

}

System.out.print(resArr.size() + " ");

for (int i = 0; i < resArr.size(); i++) {

System.out.print(resArr.get(i) + " ");

}

发表于 2023-04-24 21:52:14 回复(0)

Java

牛客604637229号

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// 注意 hasNext 和 hasNextLine 的区别

while (in.hasNext()) { // 注意 while 处理多个 case

int iCount = in.nextInt();

List<Integer> listI = new ArrayList<Integer>();

for(int i=0;i<iCount;i++){

int num = in.nextInt();

listI.add(num);

}

in.nextLine();

int rCount = in.nextInt();

TreeSet<Integer> listR = new TreeSet<Integer>();

for(int i=0;i<rCount;i++){

int num = in.nextInt();

listR.add(num);

}

TreeMap<Integer,List<String>> map = new TreeMap<Integer,List<String>>();

Iterator it = listR.iterator();

while(it.hasNext()){

int currVal = (int)it.next();

int jishu = 0;

List<String> tempList = new ArrayList<String>();

for(int i=0;i<listI.size();i++){

int iVal = listI.get(i);

if(String.valueOf(iVal).contains(String.valueOf(currVal))){

jishu++;

tempList.add(i+" "+iVal);

}

if(jishu>0){

map.put(currVal,tempList);

}

int flag = 0;

int totalNum = 0;

StringBuffer bf = new StringBuffer();

for(Map.Entry<Integer,List<String>> entry:map.entrySet()){

int kVal = entry.getKey();

List<String> temp =entry.getValue();

bf.append(kVal).append(" ").append(temp.size()).append(" ");

totalNum = totalNum+2;

for(int i=0;i<temp.size();i++){

bf.append(temp.get(i));

totalNum = totalNum+2;

if(i!=temp.size()-1){

bf.append(" ");

}

if(flag !=map.size()-1){

bf.append(" ");

}

flag++;

}

String retStr = String.valueOf(totalNum)+" ";

retStr = retStr.concat(bf.toString());

System.out.println(retStr);

}

发表于 2023-04-22 15:05:47 回复(0)

Java

韩琰

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

public class Main {
    public static void main(String[] args) {
        //输入处理
        Scanner sc = new Scanner(System.in);
        int I_num = sc.nextInt();
        String[] I = new String[I_num];
        for (int i = 0; i < I_num; i++) {
            Integer n = sc.nextInt();
            I[i] = n.toString();
        }
        //使用TreeSet去重并排序
        int R_num = sc.nextInt();
        TreeSet<Integer> R_set = new TreeSet<>();
        for (int i = 0; i < R_num; i++) {
            Integer n = sc.nextInt();
            R_set.add(n);
        }
        String[] R = new String[R_num];
        int len = 0;
        for (Integer i : R_set) {
            R[len++] = i.toString();
        }

        //开始数据处理
        Integer[] regular = new Integer[I_num];     //该数组放置一次符合一个R集合元素的所有I集合元素的下标
        Integer regex_len = 0;  //记录下标个数
        Integer count = 0;      //记录总数据个数
        ArrayList<String> outStrings = new ArrayList<>();   //存放所有数据的容器
        outStrings.add("0");    //开头防止count，先置为0，统计完后再修改，用于占位置
        for (int i = 0; i < len; i++) {
            regex_len = 0;      //每匹配一次R集合元素，下标重置为0
            for (int j = 0; j < I_num; j++) {
                if (I[j].contains(R[i])) {
                    regular[regex_len++] = j;
                }
            }
            if (regex_len != 0) {   //符合规则的个数不得为0，否则不添加
                count += regex_len * 2 + 2; //总数=R集合元素+符合个数+(下标+数据)*符合个数
                outStrings.add(R[i]);   
                outStrings.add(regex_len.toString());
                for (int k = 0; k < regex_len; k++) {
                    outStrings.add(regular[k].toString());
                    outStrings.add(I[regular[k]].toString());
                }
                Arrays.fill(regular, 0);    //清零
            }
        }
        outStrings.set(0, count.toString());    //修改总个数

        outStrings.forEach(t -> {
            System.out.print(t + " ");
        });
        sc.close();
    }
}

发表于 2023-04-13 18:01:48 回复(0)

Java

牛客311951287号

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.TreeSet;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别

        int numI = in.nextInt();
        int[] arrI = new int[numI];
        for (int i = 0; i < numI; i++) {
            arrI[i] = in.nextInt();
        }

        int numR = in.nextInt();
        TreeSet<Integer> setR = new TreeSet<Integer>();
        for (int i = 0; i < numR; i++) {
            setR.add(in.nextInt());
        }

        LinkedHashMap<Integer, Integer> lSetR = new LinkedHashMap<Integer, Integer>();
        ArrayList<Integer> arrR = new ArrayList<Integer>();
        for (Integer nR : setR) {
            int cord = 0;
            for (int i = 0; i < numI; i++) {
                int aaa = arrI[i];
                if (String.valueOf(aaa).contains(String.valueOf(nR))) {
                    cord++;
                    arrR.add(i);
                }
            }
            if (cord != 0) {
                lSetR.put(nR, cord);
            }
        }

        
        int sum = lSetR.size()*2+arrR.size()*2;
        System.out.print(sum+" ");
        
        int aaa = 0;
        for(Integer bbb: lSetR.keySet()){
            System.out.print(bbb+" "+lSetR.get(bbb)+" ");
            int ccc = lSetR.get(bbb);
            
            for(;ccc>0;ccc--){
                System.out.print(arrR.get(aaa)+" "+arrI[arrR.get(aaa)]+" ");
                aaa++;
            }
        }
    }
}

发表于 2023-04-12 11:00:24 回复(0)