首页 > 试题广场 >

数据分类处理

[编程题]数据分类处理

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

$\hspace{15pt}$ 信息社会，有海量的数据需要分析处理，比如公安局分析身份证号码、QQ 用户、手机号码、银行帐号等信息及活动记录。采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。

$\hspace{15pt}$ 对于给定的分类规则集 $R = \{R_1, R_2, \dots, R_m\}$ ，规范化它，具体地：
$\hspace{23pt}\bullet\,$ 将 $R$ 中的整数按从小到大的顺序重新排序；
$\hspace{23pt}\bullet\,$ 去除 $R$ 中的重复元素；
$\hspace{15pt}$ 记规范化后的分类规则集为 $r = \{r_1, r_2, \dots, r_m\}$ 。

$\hspace{15pt}$ 对于收集到的、由若干个整数组成的数据集 $I$ ，按照下方的要求，使用规范后的分类规则集 $r$ 输出分类后的结果。

$\hspace{23pt}\bullet\,$ 对于第 $i$ 条分类规则 $r_i$ ，如果 $I$ 中存在以 $r_i$ 为连续子串的整数，则该规则集有效；进一步地，你需要输出有多少条数据符合该规则，以及这些数据在 $I$ 中的位置、数据本身。

$\hspace{15pt}$ 子串为从原字符串中，连续的选择一段字符（可以全选、可以不选）得到的新字符串。对应本题中，你需要将整数看作是数字字符串。

输入描述:

第一行先输入一个整数  代表数据集  中的数据条数。随后，在同一行输出  个整数  代表数据。
第二行先输入一个整数  代表分类规则集  中的规则条数。随后，在同一行输出  个整数  代表规则。

输出描述:

在一行上：
先输出一个整数  ，代表一共需要输出的数字个数。简单地说，这个数字为下文中你输出数量的个数统计。
随后，对于规范后的每一条规则，如果其有效：先输出这条规则本身，随后输出一个整数  ，代表符合该规则的数据条数；随后输出  个二元组  ，代表符合这条规则的数据在  中的位置、数据本身。其中，位置从  开始计数。如果其无效，则跳过这条规则。

示例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依次中取出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，满足条件

算法知识视频讲解

Python 3

希望早日成为社会栋梁

i = input().strip()
r = input().strip()
i_list = i.split()[1:] # 数据集I
r_list = sorted(set(r.split()[1:]), key=int) # 规范化分类规则集R
result = [] # 最终结果
for rule in r_list:
    temp = []
    for index, num in enumerate(i_list):
        if rule in num:
            temp.append((index, num))
    if temp:
        result.append((rule, len(temp), temp))
if result:
    n_rules = len(result)
    counts_sum = sum(item[1] for item in result)   # 所有有效规则的匹配总数
    s = 2 * (n_rules + counts_sum)
    print(s, end=' ')
    for res in result:
        print(res[0], res[1], end=' ')
        for t in res[2]:
            print(t[0], t[1], end=' ')

发表于 2025-09-17 14:05:08 回复(0)

Python 3

晴天前夜是月明

while True:
try:
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
nums = l1[1:]
rule = list(sorted(set(l2[1:]))) #去重+排序
result = []
for i in rule: #循环套用规则
rn = 0
temp = []
result.append(i) #先将规则存入
for j in range(len(nums)): #将符合规则的数的序号和值存入temp
if str(i) in str(nums[j]):
rn += 1
temp.append(j)
temp.append(nums[j])
if rn == 0: #若没有适配规则的数，从result中删除规则
result.pop()
continue
result.append(rn) #存入适配规则的数的数量
result = result + temp #存入序号和值
print(len(result),' '.join(map(str,result))) #要将result转化为字符串才能join
except:
break

如果直接input().split()就有些例子不能通过是为什么？

发表于 2025-07-18 15:15:57 回复(0)

Python 3

dk斗志昂扬

I = input().strip().split()[1:]
R = list(set(map(int,input().strip().split()[1:])))
R.sort()
results = []
for _ in R:
    lst_i = []
    for index,Ii in enumerate(I):
        if str(_) in Ii:
            lst_i.append(str(index))
            lst_i.append(Ii)
    if len(lst_i)>0:
        results.append(str(_))
        results.append(str(len(lst_i)//2))
        results += lst_i
print(len(results), end=' ')
print(' '.join(results))

发表于 2025-04-16 23:04:18 回复(0)

Python 3

牛客274247708号

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

发表于 2024-09-10 22:06:46 回复(0)

Python 3

游客留步牛

#输入处理

I_input,R_input = input().split(),list(map(int,input().split()))

i_num,r_num = I_input[0],R_input[0]

I,R = I_input[1:],sorted(set(R_input[1:]))

#一个为最终输出列表，一个对每一个R[i]进行计数增添操作

lst_out,lst = [],[]

for i in R:

for index,j in enumerate(I):

if str(i) in j:

lst.extend((str(index),j))

#如果有记录，就将lst信息添加到lst_out中

if lst:

lst_out.extend((str(i),str(len(lst)//2)))

lst_out.extend(str(i) for i in lst)

#清楚lst内容

lst.clear()

print(len(lst_out),end= ' ')

print(' '.join( i for i in lst_out))

编辑于 2023-12-26 18:17:46 回复(0)

Python 3

TJF

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=' ')

发表于 2023-05-23 00:00:23 回复(0)

Python 3

如果当时就好了

用到字典存储R以及I的数值对，列表排序

I = input()
I = I[I.index(" ") + 1:]
Is = I.split(" ")
R = input()
Rs = R[R.index(" ") + 1:].split(" ")

Rdict= dict()
Is_len = len(Is)
nums = list()

# store number order in nums
for key in Rs:
    if not Rdict.get(key):
        Rdict[key] = []
        nums.append(int(key))
        # loop through Is to check if value pairs
        for i in range(Is_len):
            if key in Is[i]:
                Rdict[key].append(str(i))
                Rdict[key].append(Is[i])

nums.sort()

count = 0
res = ""
for num in nums:
    num_len = len(Rdict[str(num)])
    if num_len == 0:
        continue
    else:
        # current count means the count of value pairs
        cur_count = int(num_len / 2)
        res += str(num) + " " + str(cur_count) + " " + " ".join(Rdict[str(num)]) + " "
        count += 2 + num_len

res = str(count) + " " + res

print(res)

发表于 2023-02-13 16:13:31 回复(0)

Python 3

牛客465309906号

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)

发表于 2022-10-28 00:54:39 回复(0)

Python 3

牛客881904201号

# 题目看起来很复杂，其实就是简单的排序加整理数据

I = input().split()[1:]

R = sorted(set(input().split()[1:]))
dic = {}
for i in R:
li = []
for m,n in enumerate(I):
if i in n:
li.append((m,n))
if li:
dic[i]=[len(li),li]
rl = sorted(dic.items(),key=lambda x:int(x[0]))
s = str(rl).replace('[','').replace(']','').replace('(','').replace(')','').replace(' ','').replace("'",'').replace(':',' ').replace(',',' ')
n = len(s.split())
print(n,s)

发表于 2022-09-09 22:46:00 回复(0)

Python 3

Sunny_G

# 感觉我的方法简单点
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))

发表于 2022-09-01 16:00:12 回复(0)

Python 3

蔡泽钦

直接写一年

I = list(map(str, input().split()))[1:]
R = list(map(str, input().split()))[1:]
# print(I)
R = list(set(R))
R = [int(i) for i in R]
R.sort()
R = [str(i) for i in R]
# print(R)
li = []
for m in R:
for i, v in enumerate(I):
if m in v:
li.extend([i, v])
li = [int(s) for s in li]
# print(li)
dic = {}
for j in R:
dic[j] = 0
# print(dic)
for k in R:
for s in I:
if k in s:
dic[k] += 1
# print(dic)
for ind, value in dic.copy().items():
if value == 0:
del dic[ind]
# print(dic)
zz = []
for k, v in dic.items():
zz.append(int(k))
zz.append(v)
zz.extend(li[: 2*v])
li = li[2*v: ]

# print(zz)
zz.insert(0, len(zz))
zz = [str(y) for y in zz]
print(" ".join(zz))

发表于 2022-08-24 21:48:31 回复(0)

Python 3

修伊尔

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

发表于 2022-08-23 23:15:18 回复(0)

Python 3

在笔试的喜羊羊很用心

I = list(input().strip().split())[1:]
R = list(map(int, input().strip().split()))[1:]
R = list(set(R))
R.sort()
R = list(map(str, R))
res = []
for R_i in R:
index = []
for i in range(len(I)):
if R_i in I[i]:
index.append(i)
if index:
res.append(R_i)
res.append(len(index))
for i in index:
res.append(i)
res.append(I[i])
print(len(res), end=' ')
for item in res:
print(item, end=' ')

发表于 2022-08-11 16:03:28 回复(0)

Python 3

慕尼黑的白

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

发表于 2022-08-08 16:27:16 回复(0)

Python 3

牛客751542119号

#真奇怪，前面用了一次sort()后面还是会乱，所以在第23行又用了一次sorted()

line1 = input().split()
line2 = input().split()
I = line1[1:]
R = sorted(line2[1:])
# R.sort()

sort_R = list(map(int, R))
sort_R1 = []
for i in range(len(sort_R)):
    if not sort_R[i] in sort_R[(i+1):]:
        sort_R1.append(sort_R[i])
RI = {}
for i in range(len(sort_R1)):
    Ri = []
    for j in range(len(I)):
        if str(sort_R1[i]) in I[j] and I[j] not in Ri:
            Ri.append(j)
        RI[sort_R1[i]] = Ri
# print(sorted(RI))
Re = []
Ie = list(map(int, I))
# print(I)
for a in sorted(RI.keys()):
    if RI[a] != []:
        Re.append(int(a))
        Re.append(len(RI[a]))
        for j in range(len(RI[a])):
            Re.append(int(RI[a][j]))
            Re.append(int(I[int(RI[a][j])]))
print(len(Re), end=' ')
for i in range(len(Re)):
    print(Re[i], end=' ')

发表于 2022-07-26 15:40:50 回复(0)

Python 3

牛客613670709号

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

纯模拟，妥妥shabi

发表于 2022-07-22 08:33:15 回复(0)

Python 3

牛客707221930号

试着看吧。

while True:
    try:
        a, b = input().split(), input().split()
        numI, numR = int(a[0]), int(b[0])
        I, R = a[1:], b[1:]
        ele, rec, total = [], [{}], 0
        res = ''
        R = sorted(list(set(R)), key=lambda x: int(x))  # 整数字符排序
        for i in range(len(R)):
            for j in range(numI):
                if R[i] in I[j]:
                    rec[-1][j] = I[j]
            if rec[-1]:
                ele.append(R[i])
                rec.append({})
        for i in range(len(ele)):
            res += ' ' + ele[i] + ' ' + str(len(rec[i]))
            total += 2
            for k, v in rec[i].items():
                total += 2
                res += ' ' + str(k) + ' ' + v
        print(total, end = '')
        print(res)
    except:
        break

发表于 2022-07-11 14:53:24 回复(0)

Python 3

klyu


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

发表于 2022-06-15 18:20:31 回复(0)

Python 3

正在学习的小李

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

发表于 2022-06-04 16:45:35 回复(0)

Python 3

牛客597683639号

while True:
try:
I = list(map(int,input().split()))
R = list(map(int,input().split()))
I_n, R_n = I[1:],R[1:]
R_list = [] #去重后的R
for i in R_n:
if i in R_list:
continue
else:
R_list.append(i)
R_list = sorted(R_list) #去重并排序后的R
res = {} # 存放包含R的I数据，及其索引位置
for i in R_list:
for j in range(len(I_n)):
if str(i) in str(I_n[j]):
if i in res:
res[i] += [j, I_n[j]]
else:
res[i] = [j, I_n[j]]
l = []
for i in res:
l.append(i) #存放字典key值
l.append(len(res[i])//2) # 统计包含key值的个数，前面索引和值一起存放，故长度//2
l += res[i] # 存放字典value值
print(len(l),end=' ') # 打印总长度
for i in range(len(l)):
print(l[i],end=' ')
except:
break

发表于 2022-05-19 16:03:48 回复(0)

提交观点

问题信息

模拟哈希排序

来自：华为机试编程模拟题8

难度：

39条回答 2410收藏 44244浏览

通过挑战的用户

查看代码

牛客78170...

2022-11-09 10:09:57
黄启亮

2022-10-01 08:01:08
影殇20190...

2022-09-18 14:38:38
牛客67672...

2022-09-17 01:48:34
（＾Ｏ＾）

2022-09-16 11:17:54

数据分类处理

输入描述:

输出描述:

输入

输出

说明

备注:

问题信息

热门推荐

通过挑战的用户

相关试题