数据分类处理

let I=readline().split(" ").map(Number)
let ni=I.slice(0,1)
I=I.slice(1)
let R=readline().split(" ").map(Number)
let nr=I.slice(0,1)
R=R.slice(1).sort((a,b)=>a-b)
R=Array.from(new Set(R))
let res=[]
for(let i=0;i<R.length;i++){
    let r=R[i]
    let temp=[]
    for(let j=0;j<I.length;j++){
        if(I[j].toString().includes(r)){
            temp.push(j)
            temp.push(I[j])
        }
    }
    if(temp.length>0){
        res.push(r)
        res.push(temp.length/2)
        res=res.concat([...temp])
    }
}
res.unshift(res.length)
console.log(res.join(" "))

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)

let line = readline()
let arr = line.split(' ')
IN = arr.shift()
I = arr

let line2 = readline()
let arr2 = line2.split(' ')
RN = arr2.shift();


var stat = {}
new Set(arr2).forEach(RI=>{
    if(isNaN(stat[RI])) stat[RI] = [];
    I.forEach(function(v, k){
        if(v.indexOf(RI) != -1){
            stat[RI].push([k, v])
        }
    })
})

var outN = 0
var out = [];
for(var RI in stat){
    if(stat[RI].length>0){
        outN += 2
        outN += 2 * stat[RI].length
        out.push(RI, stat[RI].length)
        stat[RI].forEach(v=>{
            out.push(v[0], v[1]);
        })
    }
}
out.unshift(outN)
console.log(out.join(' '))

const IArr = readline().split(' ').slice(1)
let RArr = readline().split(' ').slice(1)
let NewRArr = Array.from(new Set(RArr)).sort((a,b)=>Number(a)-Number(b)) //R序列去重并按从小到大的顺序排列
let NewIArr = [] //存放满足条件的I
NewRArr.forEach(R=>{//遍历去重后的R序列
    let forArr = [R] //用于存放该次循环满足条件的I
    let num = 0 //声明有多少个I满足条件
    IArr.forEach((I,index)=>{
        if(I.indexOf(R)!==-1){//在I序列中的某个数满足条件（I包含了R）
            forArr.push(index.toString()) //push满足条件的下标
            forArr.push(I) //push满足条件的I
            num ++ //每有一个满足的I(num就加1)
        }
    })
    if(num!=0){   //当满足的数大于0时
        forArr.splice(1,0,num.toString())//将num插入到下标为1的位置（代表满足的I的个数）
        NewIArr = NewIArr.concat(forArr)//将每次循环生成的数组合并到最终结果数组内
    }
})
console.log(`${NewIArr.length} ${NewIArr.join(' ')}`)

let line;
while(line = readline()){
line = line.split(' ').slice(1)
var R = readline().split(' ').slice(1).sort((a,b)=>{return a - b});
var result = [];
let cf = '';
R.forEach(item=>{
    if(cf == item){
        return;
    }
    cf = item;
    var temp = [];
    line.forEach((str,index)=>{
        if(str.indexOf(item) != -1){
            temp.push(index,str);
        }
    })
    if(temp.length>0){
        temp.unshift(item,temp.length/2);
    }
    result = result.concat(temp);
})
length = result.length;
result.unshift(length);
 
console.log(result.join(' '));
}