数据分类处理

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();
        }
    }
}

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);
    }
}

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

bool comparator(const string &a, const string &b) {
    return atoi(a.c_str()) < atoi(b.c_str())? true : false;
}

vector<string> str_retrive(string *str_in, int num_s) {
    vector <string> str_rs;
    sort(str_in, str_in + num_s, comparator);
    str_rs.push_back(str_in[0]);
    for(int i = 1; i < num_s; i++) {
        if(str_in[i] != str_in[i - 1]) {
            str_rs.push_back(str_in[i]);
        }
    }
    return str_rs;
}

int main() {
    int i_s;
    while(cin >> i_s) {
        string *i_arrary = new string [i_s];
        for(int i = 0; i < i_s; i++) {
            cin >> i_arrary[i];
        }
        int r_s; cin >> r_s;
        string *r_arrary = new string [r_s];
        for(int i = 0; i < r_s; i++) {
            cin >> r_arrary[i];
        }

        vector<string> r_arrs = str_retrive(r_arrary, r_s);

        vector<string> print_out;
        for(int i = 0; i < r_arrs.size(); i++) {
            bool finds = false;
            int temps = 0;
            for(int ii = 0; ii < i_s; ii++) {
                if(i_arrary[ii].find(r_arrs[i]) != string :: npos) {
                    if(!finds) {
                        print_out.push_back(r_arrs[i]);
                        finds = true;
                    }
                    print_out.push_back(to_string(ii));
                    print_out.push_back(i_arrary[ii]);
                    temps = temps + 1;
                }
            }
            if(temps != 0) {
                print_out.insert(print_out.begin() + print_out.size() - 2 * temps, to_string(temps));
            }
        }
        print_out.insert(print_out.begin(), to_string(print_out.size()));

        for(int i = 0; i < print_out.size(); i++) {
            cout << print_out[i] << ' ';
        }
        cout << endl;
    }
    system("pause");
    return 0;
}
//写成字符串数组好处理一点
//去重用vector + sort
//用sort之前要重载运算符
//最后的输出也放在vector里面 用push_back 和 insert

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            List<Integer> list = new LinkedList<Integer>();
            int ii = sc.nextInt();
            Integer[] is = new Integer[ii];
            for(int i=0; i<ii; i++) {
                is[i] = sc.nextInt();
            }
            int ri = sc.nextInt();
            Integer[] rs = new Integer[ri];
            for(int j=0; j<ri; j++) {
                boolean flag = true;
                rs[j] = sc.nextInt();
            }
            Arrays.sort(rs);
            List<Integer> exists = new ArrayList<Integer>();
            for(int k=0; k<ri; k++) {
                if(!exists.contains(rs[k])) {
                    exists.add(rs[k]);
                    int innercnt = 0;
                    List<Integer> innerlist = new LinkedList<Integer>();
                    for(int m=0; m<ii; m++) {
                        if(String.valueOf(is[m]).contains(String.valueOf(rs[k]))) {
                            innercnt++;
                            innerlist.add(m);
                            innerlist.add(is[m]);
                        }
                    }
                    if(innercnt != 0) {
                        list.add(rs[k]);
                        list.add(innercnt);
                        for(int n=0; n<innerlist.size(); n++) {
                            list.add(innerlist.get(n));
                        }
                    }
                }
            }
            System.out.print(list.size()+ " ");
            for(int k=0; k<list.size(); k++) {
                System.out.print(list.get(k)+ " ");
            }
            System.out.println();
        }
    }
}

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

int isinclude(string s1 ,string s2){ //判断字符串s1是否包含字符串s2，若包含返回1，若不包含返回0
    if(s1.size()<s2.size()) return 0;
    int len1=s1.size(),len2=s2.size();
    for(int i=0;i<=len1-len2;i++)
        if(s1.substr(i,len2)==s2)
            return 1;
    return 0;
}

int main(){
    int n;
    while(cin>>n)
    {
        vector<int> in;
        for(int i=0;i<n;i++)
        {
            int a;
            cin>>a;
            in.push_back(a);
        }
        int m;
        cin>>m;
        vector<int> ru;
        for(int i=0;i<m;i++)
        {
            int a;
            cin>>a;
            ru.push_back(a);
        }
        /*数据输入结束，进行数据处理，将ru递增排序并去重*/
        sort(ru.begin(),ru.end());
        for(int i=0;i<ru.size()-1;i++)
            if(ru[i]==ru[i+1])
            {
                ru.erase(ru.begin()+i,ru.begin()+i+1);
                i--;
            }
        /*遍历ru一次，找出in中元素包含ru的某元素的情况（个数、在in中点下标以及值）并存储：  
          对于ru的每个元素都需要遍历in一次
          如果in中元素均不包含ru的某元素ru[i]，则ru[i]的情况不存储*/
        vector<int> vcout;
        for(int i=0;i<ru.size();i++)
        {
            stringstream stream;
            string rus;
            stream<<ru[i];
            stream>>rus;
            int sum=0;
            vector<int> index;
            vector<int> content;
            for(int j=0;j<n;j++)
            {
                string ins;
                stream.clear();
                stream<<in[j];
                stream>>ins;
                if(isinclude(ins,rus)) 
                {
                    sum++;
                    index.push_back(j);
                    content.push_back(in[j]);
                }
            }
            if(sum)
            {
                vcout.push_back(ru[i]);
                vcout.push_back(sum);
                for(int k=0;k<sum;k++)
                {
                    vcout.push_back(index[k]);
                    vcout.push_back(content[k]);
                }
            }
        }
        /*输出*/
        cout<<vcout.size()<<' ';
        for(int i=0;i<vcout.size()-1;i++) 
            cout<<vcout[i]<<' ';
        cout<<vcout.back()<<endl;
    }
    return 0;
}