数据分类处理

a = input().split()[1:]
s = ' '.join(a)

#要按照从小到大排列
b = list(map(int, input().split()))[1:] 
b = sorted(set(b))

inclu = [str(i) for i in b if str(i) in s]

dic ={}
res_lst = []
for i in inclu:
    dic[i]=0
    sub_lst = []
    for j in range(len(a)):
        if i in a[j]:
            sub_lst.append(str(j))
            sub_lst.append(a[j])
            dic[i] += 1
    res_lst.append(sub_lst)

fnl =''
for i in range(len(res_lst)):
    key = inclu[i]
    fnl += key+' '+str(dic[key])+' '
    fnl += ' '.join(res_lst[i])+' '

result  = (str(len(fnl.split())) +' '+ fnl).split()
print(' '.join(result))

a=input().split()
b=input().split()
N=a[0]
c=[]
for i in set(b[1:]):
    c.append(int(i))
M=len(c)
c=sorted(c)
path=[]
for i in range(M):
    stuck=[]
    for j in range(1,int(N)+1):
        if str(c[i]) in a[j]:
            stuck.extend([j-1,int(a[j])])
    if len(stuck)>0:
        path.append(c[i])
        path.append(int(len(stuck)/2))
        path.extend(stuck)
if len(path)>0:
    ans=[len(path)]
    ans.extend(path)
for i in ans:
    print(i,end=' ')

i = input().split(' ')[1:]
r = sorted(list(set(input().split(' ')[1:])),key=lambda x:int(x))
d = {x:['',0] for x in r}
for index in range(len(i)):
    for value in r:
        if value in i[index]:
            d[value][1] += 1
            d[value][0] += ' ' + str(index) + ' ' + i[index]
fin_str = ''
count = 0
for index in r:
    if d[index][1] != 0:
        count += (d[index][1]+1) * 2
        fin_str += ' ' + index + ' ' + str(d[index][1]) + d[index][0]
        
print(str(count)+fin_str)

# 感觉我的方法简单点
R = input().split(' ')[1:]
I = list(map(int,input().split(' ')))[1:]
I = list(set(I))
I.sort()
data = []
for i in I:
    l = []
    for j in range(len(R)):
        if str(i) in R[j]:
            l.extend([str(j),R[j]])
    if len(l)>0:
        data.extend([str(i),str(int(len(l)/2))])
        data.extend(l)
data.insert(0,str(len(data)))
print(' '.join(data))

arr_i = input().split()[1:]
arr_r = map(int,input().split()[1:])
arr_r = sorted(list(set(arr_r)))
arr_r = list(map(str,arr_r))
res = []
for i in arr_r:
    tmp = [i]
    for j, ele in enumerate(arr_i):
        if i in ele:
            tmp.extend([str(j),ele])
    num = len(tmp)//2
    if num:
        tmp.insert(1,str(num))
        res.extend(tmp)
res.insert(0,str(len(res)))
print(' '.join(res))

def print_list(seq_I,seq_R):
    # seq_I [123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123]
    # seq_R [0,3,6]
    R_list = []
    for i in seq_R:
        seq_i_tishen = []
        for xx in seq_I:
            seq_i_tishen.append(xx)
        num_contain = 0#用来存储第二个数字 例为6
        R_manzu = []# 用来暂时存储   例['123', '453', '3', '453456', '453', '123']
        R_manzuindex = []# 例子 [0, 3, 7, 9, 13, 14]
        for j in seq_i_tishen:
            if str(i) in j:
                R_manzu.append(j)
                R_manzuindex.append(seq_i_tishen.index(j))
                seq_i_tishen[seq_i_tishen.index(j)] = '*'
                num_contain += 1
        if R_manzu != []:
            R_list.append(i)
            R_list.append(num_contain)
#         print(R_list)
        for n in range(len(R_manzu)):
            R_list.append(int(R_manzuindex[n]))
            R_list.append(int(R_manzu[n]))
    print(len(R_list),end=' ')
    for abc in R_list:
        print(abc,end=' ')
    return 0
while True:
    try:
        I_seq = input().split()[1:]
        R_seq = list(map(int,input().split()[1:]))
        R_seq = list(set(R_seq))
        R_seq.sort()
        print_list(I_seq,R_seq)
    except:
        break

target = input().split(" ")[1:]
nums = sorted(list(map(int, input().split(" ")))[1:])
dic = {}
for num in nums:
    s = str(num)
    if s in dic:
        continue
    dic[s] = []
    for i, tar in enumerate(target):
        if s in tar:
            dic[s].append((i, tar))
ans = []
for s, t in dic.items():
    if not t:
        continue
    ans.append(s)
    ans.append(str(len(t)))
    for x, y in t:
        ans.append(str(x))
        ans.append(str(y))

print(str(len(ans)), " ".join(ans))

while True:
    try:
        l = input().split(' ')[1:]
        r = list(map(int, input().split(' ')[1:]))
        r.sort()
        r_sort = []
        for i in r:
            if i not in r_sort:
                r_sort.append(i)
        r_sort = list(map(str, r_sort))
        dic = {}
        for i in r_sort:
            dic[i] = []
        for i in r_sort:
            for j in range(len(l)):
                if i in l[j]:
                    dic[i].append((j, l[j]))
                else:
                    continue
        key_record = []
        total_number = 0
        for key, value in dic.items():
            if value == []:
                continue
            else:
                key_record.append(key)
                total_number += 2
                total_number = total_number + len(value)*2
        result = [total_number]
        for key, value in dic.items():
            if value == []:
                continue
            else:
                result.append(key)
                result.append(len(value))
                for pair in value:
                    result.append(pair[0])
                    result.append(pair[1]) 
        result = [str(i) for i in result]
        print(' '.join(result))          
    except:
        break

def r_get( s1_follow):
    s1_empty = []
    for x in s1_follow:
        if x not in s1_empty:
            s1_empty.append(x)
    return sorted(s1_empty)

def i_get(s0, s1_follow):
    s0_top, s0_follow = s0[0], s0[1:]

    s0_ok_list = []
    for s1 in map(str, s1_follow):
        if len( [x for x in s0_follow if s1 in x] ):
            s0_ok = [f'{index} {x}' for index, x in enumerate(s0_follow) if s1 in x]

            s0_ok_list.append( f"{s1} {len(s0_ok)} {' '.join( s0_ok )}" )

    return ' '.join( s0_ok_list )

while True:
    try:
        s0, s1 = input().split(), input().split()
        s1_top, s1_follow = s1[0], map(int, s1[1:])

        s1_follow = r_get(s1_follow)
        s0_ok_list = i_get(s0, s1_follow)

        print(len(s0_ok_list.split()), s0_ok_list)
    except:
        break

I=input().split()[1:]
R=input().split()[1:]
R=sorted(list(set(R)),key=int)
opt=[]
for i in range(len(R)):
    line=[R[i]]
    for j in range(len(I)):
        if R[i] in I[j]:
            line.append(j)
            line.append(I[j])
    if len(line)>1:
        line.insert(1, len(line)//2)
        opt+=line
opt=[len(opt)]+opt
print(*opt,sep=' ')

"""
解题分析：
    1、先对R进行去重和排序
    2、判断I的的元素是否包含R，包含则记录满足条件的I,R和I的索引
    3、要输出元素的个数，满足条件的R（升序）
    4、满足条件的I的个数
    5、I所在的索引（去最小的那个），I的元素
"""
I = list(input().split())
R = list(input().split())
# 从第二个元素开始取，第一个元素表示个数，并使用set去重
R_set = set(R[1:])
# 进行降序排序,要转化成int
a_list = list(R_set)
b_list = list(map(int, a_list))
new_R = sorted(b_list, reverse=False)
# 创建列表存放符合要求的R元素
# 创建字典存放符合要求的I的索引：I的值
r_list = []
r_dict = {}
# 判断 I是否包含R,满足条件的存入R
for r in new_R:
    i_dict = {}
    for i in range(1,len(I)):
        if str(r) in str(I[i]):
            # 过滤重复的元素
            if r not in r_list:
                r_list.append(r)
            i_dict[i] = I[i]
    r_dict[str(r)] = i_dict
# 把符合要求的R进行排序
o_list = sorted(r_list, reverse=False)
# 把要输出的内容存放到列表中，第一个元素使用0占位，后续赋值要输出的长度
last_list = [0]
for one in o_list:
    # 把符合要求的R存入指定的列表
    last_list.append(one)
    last_list.append(len(r_dict[str(one)]))
    # 根据符合要求的R，取出对应字典中的数据，即符合要求的I
    new_dict = r_dict[str(one)]
    for j in new_dict.keys():
        # 遍历字典把数据同一存放在列表中
        last_list.append(j-1)
        last_list.append(new_dict[j])
# 计算列表长度-占位的
long_num = len(last_list)-1
last_list[0] = long_num
for l in last_list:
    print(l, end=' ')