数据分类处理

const line1 = readline().split(' ') //获取第一行输入的值并转为数组
const line2 = readline().split(' ') //获取第二行输入的值并转为数组
line1.shift() //分别去除第一个和第二个数组第一项
line2.shift()
const IArr = [...line1] //处理生成要对比的数组
const RArr = [...new Set(line2)].sort((a,b)=>a-b) //去重并排序
let res = [] //存储结果的数组
RArr.forEach(item=>{ //遍历数组I和R，查找数组I中的某项字符串是否包含数组R中的某项字符串
    let flag = false  //标志是否查到，查不到则不输出0
    let hasArr = [] //存储从I中查找到的索引和值
    let hasArrLen = 0 //存储查找到的数据数量
    IArr.forEach((item1,index1)=>{
        if( item1.indexOf(item) !== -1){
            flag = true
            hasArrLen++
            hasArr.push(index1,item1)
        }
    })
    if(flag){
        res.push(item,hasArrLen,...hasArr)
    }
})
console.log(res.length,...res)

#include<string>
#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

bool IsHave(string str1, string str)
{
	if (str.find(str1) == str.npos) // 没有时返回的是 npos。下标
	{
		return false;
	}
	return true;
}

int main()
{
	vector<string>vecI;  // 主序列
	vector<int>vecR_i;  // 子序列
	int m = 0, n = 0, R_i = 0;
	while (cin >> m)
	{
		string str;
		for (int i = 0; i < m; ++i)
		{
			cin >> str;
			vecI.push_back(str);
		}
		cin >> n;
		for (int i = 0; i < n; ++i)
		{
			cin >> R_i;
			vecR_i.push_back(R_i);
		}
	}

	sort(vecR_i.begin(), vecR_i.end()); // 对子序列进行排序
	vecR_i.erase(unique(vecR_i.begin(), vecR_i.end()), vecR_i.end()); // 快排之后，去除相同元素.
	vector<string>vec;
	vector<int>num;
	int N = 0, M = 0;


	bool flag = false;
	for (int j = 0; j < vecR_i.size(); ++j)  // 子序列
	{
		vec.push_back(to_string(vecR_i[j])); // 推入
		for (int i = 0; i < vecI.size(); ++i)  //主序列
		{
			if (IsHave(to_string(vecR_i[j]), vecI[i]))
			{
				string s = to_string(i);
				vec.push_back(s);  // 保存下标
				vec.push_back(vecI[i]); // 保存对应字符串
				flag = true;  // 为true代表的是该子序列在主序列中有值，vec更新
				N++;  // 保存主序列中有几个数包含子序列的值
			}
		}
		if(N != 0)
			num.push_back(N);  // 更新子序列的数值

		if (!flag)  // vec未更新，推出最后一个元素
			vec.pop_back();
		else
		{
			flag = false;
			N = 0;

		}
	}
	vector<int>num1;  // 记录
	int a = 0;
	for (int i = 0; i < num.size(); ++i)
	{
		a  += num[i];
		num1.push_back(a);
	}
	vec.insert(vec.begin() + 1, to_string(num[0]));
	for (int i = 1; i < num.size(); i++)
	{
		vec.insert(vec.begin() + 2 * num1[i - 1] +  2 * i +  1, to_string(num[i])); // 更新vec,合并vector，插入对应数值
	}
	cout << vec.size() << " ";
	for (int i = 0; i < vec.size(); ++i)
	{
		cout << vec[i] << " ";
	}
	return 0;
}

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

/**
 * @author Yuliang.Lee
 * @version 1.0
 * @date 2021/9/3 11:41
 * 数据分类处理：
    https://www.nowcoder.com/practice/9a763ed59c7243bd8ab706b2da52b7fd?tpId=37&&tqId=21248&rp=1&ru=/ta/huawei&qru=/ta/huawei/question-ranking

 * 数据结构定义：
    输入： 一个TreeSet<Integer>、String[]
    输出：一个结果List<Object>、一个临时List<Object>
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            // 初始化输入数据
            int numL = in.nextInt();
            String[] arrayL = new String[numL];
            for (int i = 0; i < numL; i++) {
                arrayL[i] = in.next();
            }
            int numR = in.nextInt();
            Set<Integer> setR = new TreeSet<>();
            for (int i = 0; i < numR; i++) {
                setR.add(in.nextInt());
            }

            // 定义输出数据结构
            List<Object> tmpList = new ArrayList<>();
            List<Object> resultList = new ArrayList<>();

            // 数据分类处理
            for (Integer e : setR) {
                String str = String.valueOf(e);
                for (int i = 0; i < numL; i++) {
                    if (arrayL[i].contains(str)) {
                        tmpList.add(i);
                        tmpList.add(arrayL[i]);
                    }
                }
                if (tmpList.size() > 0) {
                    resultList.add(e);
                    resultList.add(tmpList.size() / 2);
                    resultList.addAll(tmpList);
                    tmpList.clear();
                }
            }

            // 结果输出
            System.out.print(resultList.size() + " ");
            for (Object o : resultList) {
                System.out.print(o + " ");
            }
            System.out.println();
        }
    }
}

这个人太笨了，写了百多行………………
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int GetIntsNum(int num)
{
    if(num == 0) return 1;
    int count = 0; //计数器
    while (num != 0) //当不是0就循环
    {
        count++;  //计数器加1
        num = num / 10; //去掉个位赋值给自己
    }
    return count;
}

bool isConclude(int a, int b)  //a是否包含b
{
    int b_num = GetIntsNum(b);
    int modnum = 1;
    while(b_num > 0)
    {
        modnum *= 10;
        b_num--;
    }
    while(a > 0)
    {
        int tmp = a % modnum;
        if(tmp == b)
            return true;
        a /= 10;
    }
    return false;
}

vector<int> ClassifyProcess(vector<int> R, vector<int> I)
{
    int i_size = I.size();
    int r_size = R.size();
    int pre;
    vector<int> res;
    vector<int> vec;
    for(int & i : I)
    {
        vector<int> tmp;
        int flag = 1;
        if(pre != i)
        {
            pre = i;
            for(int r = 0; r < r_size; ++r)
            {
                if(isConclude(R[r], i))
                {
                    if(flag)
                    {
                        vec.push_back(i);
                        flag = 0;
                    }
                    tmp.push_back(r);
                    tmp.push_back(R[r]);
                }
            }
            if(tmp.size() > 0)
            {
                vec.push_back(tmp.size() / 2);
                for(int & p : tmp)
                {
                    vec.emplace_back(p);
                }
            }

        }
    }
    res.push_back(vec.size());
    for(int & p : vec)
    {
        res.emplace_back(p);
    }
    return res;
}

int main()
{
    int r_num;
    while(scanf("%d", &r_num) != EOF)
    {
        vector<int> R(r_num);
        for(int & a : R)
        {
            scanf("%d", &a);
        }
        int i_num;
        scanf("%d", &i_num);
        vector<int> I(i_num);
        for(int & a : I)
        {
            scanf("%d", &a);
        }
        sort(I.begin(), I.end());

        vector<int> ans = ClassifyProcess(R, I);

        for(int & p : ans)
        {
            cout<<p<<" ";
        }
        cout<<endl;
    }
    return 0;
}

a=input().split()[1:]
b=map(int,input().split()[1:])
b=sorted(set(b))
res=[]
for i in b:
    count =0
    x=[]
    for j in range(0,len(a)):
        if str(i) in a[j]:
            count +=1
            x.append(str(j))
            x.append(a[j])
    if count!=0:
        res.append(str(i))
        res.append(str(count))
        res.extend(x)
res.insert(0, str(len(res)))
print(' '.join(res))

while True:
    try:
        I = input().strip().split(' ')[1:]
        R = input().strip().split(' ')[1:]  # R=['6','3','6','3','0']
        # 此处排序一定要注意是将字符对应的整型数排序，而不是单纯靠字符排序，
        # 避免出现'4'比'26'大的情况
        R = sorted(set(R), key=int)  # R = ['0','3','6']
        rm = []  # R列表中应该移除的值
        for R_i in R:
            flag = 0  # 对于R中的某个元素R_i，假设列表I中的每个元素都不包含R_i
            for I_i in I:
                if R_i in I_i:
                    flag = 1
            if flag == 0:  # 说明R_i应该从R中移除
                rm.append(R_i)
        for rm_i in rm:
            R.remove(rm_i)

        # 至此，列表R已经处理完毕，可以开始与I的匹配运算，R = ['3','6']
        L = []
        for R_i in R:
            L.append(R_i)
            count = 0
            index_value = []
            # 此处一定不能直接迭代I中的元素，即for I_i in I，因为循环
            # 内部需要使用到列表元素的角标，若元素ele出现多次，靠方法
            # L.index(ele)只能返回ele第一次出现时的角标，而不是ele在
            # 列表L中的实际角标位置。
            for index in range(len(I)):
                if R_i in I[index]:
                    count += 1
                    index_value.extend([str(index), I[index]])
            L.append(str(count))
            L.extend(index_value)
        # 至此，3和6的相关输出已经全部在列表L中
        L_len = str(len(L))
        L.insert(0, L_len)
        print(' '.join(L))
    except:
        break

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

// 判断是否是子串
bool isSubStr(string sSub, int Str)
{
    string sStr = to_string(Str);
    return sStr.find(sSub) != string::npos;
}

// 判断序列I中的元素i是否包含的子串sub，并返回下标和值
vector<int> getSubstr(int sub, vector<int> I)
{
    vector<int> result;
    int is = I.size();
    for (int pos = 0; pos < is; pos++)
    {
        string sSub = to_string(sub);
        int i = I[pos];
        if(isSubStr(sSub, i))
        {
            result.push_back(pos);
            result.push_back(i);
        }
    }

    return result;
}

// 获取序列I中所有满足规则序列R的元素下标、数值，以及个数
vector<int> dataClassify(vector<int> I, vector<int> R)
{
    vector<int> Result;
    // 遍历R，对R中的每一个规则整数r，遍历序列I，获取满足的数据
    for (vector<int>::iterator ri = R.begin(); ri != R.end(); ri++)
    {
        int r = *ri;
        vector<int> sv = getSubstr(r, I);
        int ss = sv.size();

        if (ss > 0)
        {
            Result.push_back(r);
            Result.push_back(ss/2);
            Result.insert(Result.end(), sv.begin(), sv.end());
        }
    }

    return Result;
}

int main()
{
    // 循环处理
    int in,rn;
    while(cin>>in)
    {
        // 读取输入数据序列I和R；
        vector<int> I, R;
        int temp;
        for (size_t i = 0; i < in; i++)
        {
            cin>>temp;
            I.push_back(temp);
        }
        cin>>rn;
        for (size_t i = 0; i < rn; i++)
        {
            cin>>temp;
            R.push_back(temp);
        }

        // 排序和去重序列R；
        sort(R.begin(), R.end());
        R.erase(unique(R.begin(), R.end()), R.end());

        // 对数据进行分类
        vector<int> Result = dataClassify(I, R);
        
        // 输出结果
        cout<< Result.size() << " ";
        for (vector<int>::iterator Ri = Result.begin(); Ri != Result.end(); Ri++)
        {
            cout << *Ri << " ";
        }
        cout << endl;
    }

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
//将结果放到2个 vector中，num 中放 序列数字I 和 该数字在R序列中出现的次数
//res 中放 具体的 索引和 对应的数字
//代码中定义的I和R与题目说明的I和R相反
using namespace std;

int main()
{
    int m,n;
    while(cin>>m)
    {
        vector<int> R;
        for(int i = 0;i<m;i++)
        {
            int tmp;
            cin>>tmp;
            R.push_back(tmp);
        }
        cin>>n;
        vector<int> I;
        for(int i = 0;i<n;i++)
        {
            int tmp;
            cin>>tmp;
            I.push_back(tmp);
        }
        sort(I.begin(),I.end());//排序序列I
        vector<int> res,num;
        for(int i = 0;i<n;i++)
        {
            if(i !=0  && I[i] == I[i-1])    continue;//对I去重
            int count = 0,flag = 0;
            for(int j = 0;j<m;j++)
            {
                int tmp = R[j];
                while(tmp)
                {
                    if(tmp%10 == I[i] || tmp%100 == I[i] || tmp%1000 == I[i])//判断I中的数字是否在R中
                    {
                        if(flag == 0)//第一次找到对应的数字
                        {
                            flag = 1;
                            count++;
                            num.push_back(I[i]);//把I中具体的数字加入num
                            res.push_back(j);//把具体的索引加入res
                            res.push_back(R[j]);//把具体的数字加入res
                        }
                        else
                        {
                            count++;
                            res.push_back(j);
                            res.push_back(R[j]);
                        }
                        break;
                    }
                    tmp/=10;
                }
            }
            if(count != 0) // 如果I中对应的数字在R中可以找到，则在num中加入count
                 num.push_back(count);
        }
        
        int start = 0,j;
        cout<<num.size()+res.size()<<" ";//输出num和res的和，即输出总数
        for(int i = 0;i<num.size();i++)
        {
            cout<<num[i]<<" "<<num[++i]<<" ";
            for(j = start;j<start+num[i]*2;j++)//因为是要输出索引和对应的数字，因此此处是num[i]*2
            {
                cout<<res[j]<<" ";
            }
            start = j;
        }
        cout<<endl;
    }
    return 0;
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            //输入I<j>
            int n = sc.nextInt();
            int[] num = new int[n];
            for(int i=0; i<n; ++i){
                num[i] = sc.nextInt();
            }
            //输入R<i>：使用TreeSet去重并排序
            int m = sc.nextInt();
            Set<Integer> rule = new TreeSet<>();
            for(int i=0; i<m; ++i){
               rule.add(sc.nextInt());
            }
            
            int total = 0;//记录后续整数序列的个数
            StringBuffer res = new StringBuffer();//记录将要输出的字符串
            
            //遍历R<i>
            for(Integer r:rule){
                int count = 0; //存储包含R<i>的I<j>元素的个数
                ArrayList<Integer> arr = new ArrayList<>();//存储包含R<i>的I<j>元素的原序号
                //遍历I<j>
                for(int i=0; i<n; ++i){
                    String tmp = num[i]+"";
                    if(tmp.contains(r.toString())){
                        count++;
                        arr.add(i);
                    }
                }
                //如果没有满足条件的I<j>，对应的R<i>不用输出 
                if(count!=0){
                    total += 2*count + 2;
                    res.append(r+" "+count+" ");
                    for(int i:arr){
                        res.append(i+" "+num[i]+" ");
                    }
                }
            }
            //在输出序列的第一个整数位置记录total，并去掉输出末尾的空格
            res.insert(0, total+" ").deleteCharAt(res.length()-1);
            System.out.println(res);
            
        }
        sc.close();
    }
}

while True:
    try:
        I=list(input().split(' '))
        R=list(map(int,input().split(' ')))        
        Rs=list(set(R[1:]))
        I=I[1:]
        Rs.sort()
        
        Rs=[str(i) for i in Rs]
        string=[]
        for i in range(len(Rs)):
            temp=[];count=0
            for j in range(len(I)):
                if Rs[i] in I[j]: 
                    temp.append(j)
                    temp.append(I[j])
                    count=count+1
            if count!=0:
                string.append(Rs[i])
                string.append(count)
                string=string+temp        
        num=[len(string)]
        num=num+string
        out=' '.join(map(str,num))
        print(out)
    except:
        break

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct{
    int number;        //R在I<>中有对应数字的个数
    int index[50];     //R在I中对对应数字的下标
}data;

char* Int2Str(int num,char *str){  //将数字转化为字符串,反序，这里不影响
    int i = 0,j=0;
    do{
        str[i++] = num%10+48; //0的ASCII码为48
        num /= 10;
    }while(num); 
    str[i] = '\0'; 
    return str;
}

int main(){
    int Inum;
    while(scanf("%d",&Inum)!=EOF){
        int i,j,k,I[1000],Rnum,R[500],temp,q,talnum=0;
        char aI[10],aR[10];//存储字符串
		data *Rinfo[500]={NULL};
        for(i=0;i<Inum;i++) scanf("%d",&I[i]);//输入I
        scanf("%d",&Rnum);
        for(i=0;i<Rnum;i++) scanf("%d",&R[i]);//输入R
        for(i=0;i<Rnum-1;i++)
            for(j=0;j<Rnum-1-i;j++){
                if(R[j]>R[j+1]){
                    temp=R[j];
                    R[j]=R[j+1];
                    R[j+1]=temp;
                }
                else if(R[j]==R[j+1]){
                    for(k=j;k<Rnum;k++)
                        R[k]=R[k+1];
                    j--;
                    Rnum--;
                }
            }                     //R中的数据已排序好并删除了重复的数
        for(i=0;i<Rnum;i++){
            q=0;
            for(j=0;j<Inum;j++){
                if(strstr(Int2Str(I[j],aI),Int2Str(R[i],aR))){//R[i]是I[j]的子串
                    if(!Rinfo[i]){
                    Rinfo[i]=(data*)malloc(sizeof(data));
                        memset(Rinfo[i],0,sizeof(data));
                    }
                    Rinfo[i]->number++;
                    Rinfo[i]->index[q++]=j;
				}
            }
        }                                         //获取完数据
        for(i=0;i<Rnum;i++)
            if(Rinfo[i])
                talnum+=2+2*Rinfo[i]->number;
        printf("%d ",talnum);             //共有多少个数字
        for(i=0;i<Rnum;i++){
            if(Rinfo[i]){
                printf("%d %d ",R[i],Rinfo[i]->number);//输出R和个数
                for(j=0;j<Rinfo[i]->number;j++)
                    printf("%d %d ",Rinfo[i]->index[j],I[Rinfo[i]->index[j]]);//下标和I
            }
        }
        printf("\n");
    }
    return 0;
}

来一个超级复杂的，纯C



#include<stdio.h>
#include<string.h>
typedef struct {
    int index;
    int num;
    unsigned long int I_st;
}stOut;

int atoi_my(unsigned long int x, char *out)
{
    int i = 0;
    unsigned long int in = x;
    while (in/10 !=0) {
        out[i] = in%10 + '0';
        in = in/10;
        ++i;
    }
    out[i] = in%10 + '0';
    out[i + 1] = '\0';
}

int main()
{
    char I_list[1024][32]={};
    char R_list[1024][32]={};
    unsigned long int I_list_i[1024];
    unsigned long int R_list_i[1024];
    char base_I[32];
    char base_R[32];
    
    //while(scanf("%d",&I_num) != EOF) {
   // int l = 2;
   // while(l)
    //{
    //    l--;
    int I_num = 0;
    int R_num = 0;
    while(scanf("%d",&I_num) != EOF) {
    //{
    int q = 0;
    stOut last_out[1024][64] = {0};
    //scanf("%d",&I_num);
    for (int i = 0; i < I_num; ++i) {
        scanf("%d",&I_list_i[i]);
    }
    
    scanf("%d",&R_num);
    for (int i = 0; i< R_num; ++i) {
        scanf("%d",&R_list_i[i]);
    }
    
    unsigned long int real_R_list_i[1024];
    for (int i = 0; i < R_num; ++i) {
        unsigned long int base = R_list_i[i];
        for ( int j = i + 1; j < R_num; ++j ) {
            if (base > R_list_i[j]) {
                R_list_i[i] = R_list_i[j];
                R_list_i[j] = base;
                base = R_list_i[i];
            }
        }
        //printf("%d-",base);
    }
    int k = 0;
    for (int i = 0; i < R_num; ++i) {
        int flag = 0;
        for ( int j = i + 1; j < R_num; ++j ) {
            if (R_list_i[j] == R_list_i[i]) {
                flag = 1;
            }
        }
        if (flag == 0) {
            real_R_list_i[k] = R_list_i[i];
            k++;
        }
    }
    /*for (int i = 0; i < k; ++i) {
        printf("%d-",real_R_list_i[i]);
    }*/
    for (int i = 0; i < k; ++i) {
        atoi_my(real_R_list_i[i], base_R);
        strcpy(R_list[i], base_R);
    }
        //printf("%d-",I_num);
    for (int i = 0; i < I_num; ++i) {
        atoi_my(I_list_i[i], base_I);
        strcpy(I_list[i], base_I);
    }
        //printf("%d-",I_num);
    for (int i = 0; i < k; ++i) {
        int m = 0;
        atoi_my(real_R_list_i[i], base_R);
        for (int j = 0; j < I_num; ++j) {
            atoi_my(I_list_i[j], base_I);
            for (int n = 0; n < strlen(base_I) - strlen(base_R) + 1; ++n) {
                if (strncmp(base_I + n,base_R,strlen(base_R)) == 0) {
                    last_out[i][m].index = j;
                    last_out[i][m].I_st = I_list_i[j];
                    m++;
                    break;
                }
            }
        }
        last_out[i][0].num = m;
    }
    int total = 0;
    for (int i = 0; i < k; ++i) {
        total += last_out[i][0].num;
        total += last_out[i][0].num;
        if (last_out[i][0].num != 0) {
            total++;
            total++;
        }
    }
    printf("%d ",total);
    for (int i = 0; i < k; ++i) {
        if (last_out[i][0].num != 0) {
            printf("%d %d ",real_R_list_i[i], last_out[i][0].num);
            for (int j = 0; j < last_out[i][0].num; ++j) {
                printf("%d %d ",last_out[i][j].index,last_out[i][j].I_st);
            }
        }
    }
    printf("\n");
    }
}

import java.util.*;
import java.io.*;

public class Main {
    public static void main (String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            // get I Array
            int iNums = scanner.nextInt();
            String[] iArray = new String[iNums];
            for (int i = 0; i < iNums; i++) {
                iArray[i] = scanner.next();
            }
            scanner.nextLine();
            // get R Array
            int rNums = scanner.nextInt();
            int[] rArray = new int[rNums];
            for (int i = 0; i < rNums; i++) {
                rArray[i] = scanner.nextInt();
            }
            scanner.nextLine();
            dataMacher(iArray, rArray);
        }
    }
    
    public static void dataMacher(String[] iArray, int[] rArrayInt) {
        // sort int R Array
        Arrays.sort(rArrayInt);
        // convert R Array to String Array
        String[] rArray = new String[rArrayInt.length];
        for (int i = 0; i < rArrayInt.length; i++) {
            rArray[i] = rArrayInt[i] + "";
        }
        StringBuffer sBuffer = new StringBuffer();
        HashMap<String, Integer> map = new HashMap<>();
        // loop rArray
        for (int i = 0; i < rArray.length; i++) {
            String curR = rArray[i];
            // test if curR used
            if (map.containsKey(curR)) {
                continue;
            }
            map.put(curR, 1);
            // search if any match. and count it;
            int counter = 0;
            for (int j = 0; j < iArray.length; j++) {
                String curI = iArray[j];
                if (curI.indexOf(curR) >= 0) {
                    counter++;
                }
            }
            // there are one or more match
            if (counter > 0) {
                sBuffer.append(curR + " " + counter + " ");
                for (int j = 0; j < iArray.length; j++) {
                    String curI = iArray[j];
                    if (curI.indexOf(curR) >= 0) {
                        sBuffer.append(j + " " + curI + " ");
                    }
                }
            }
        }
        int length = sBuffer.toString().split(" ").length;
        sBuffer.insert(0, length + " ");
        System.out.println(sBuffer);
    }
}