华为OD机试_2025 B卷_数据分类（Python，100分）（附详细解题思路）

蜗牛的旷野

已于 2025-07-13 22:40:12 修改

阅读量893

点赞数 36

CC 4.0 BY-SA版权

分类专栏：华为OD机试Python版文章标签：华为od python 算法

于 2025-07-13 20:41:05 首次发布

本文链接：https://blog.csdn.net/woniu2505/article/details/149315440

华为OD机试Python版专栏收录该内容

105 篇文章

订阅专栏

题目描述

对一个数据a进行分类，分类方法为：

此数据a（四个字节大小）的四个字节相加对一个给定的值b取模，如果得到的结果小于一个给定的值c，则数据a为有效类型，其类型为取模的值；如果得到的结果大于或者等于c，则数据a为无效类型。

比如一个数据a=0x01010101，b=3，按照分类方法计算（0x01+0x01+0x01+0x01）%3=1，

所以如果c=2，则此a为有效类型，其类型为1，如果c=1，则此a为无效类型；

又比如一个数据a=0x01010103，b=3，按照分类方法计算（0x01+0x01+0x01+0x03）%3=0，

所以如果c=2，则此a为有效类型，其类型为0，如果c=0，则此a为无效类型。

输入12个数据，第一个数据为c，第二个数据为b，剩余10个数据为需要分类的数据，

请找到有效类型中包含数据最多的类型，并输出该类型含有多少个数据。

输入描述
输入12个数据，用空格分隔，第一个数据为c，第二个数据为b，剩余10个数据为需要分类的数据。

输出描述
输出最多数据的有效类型有多少个数据。

用例

输入

3 4 256 257 258 259 260 261 262 263 264 265

输出

说明

10个数据4个字节相加后的结果分别为1 2 3 4 5 6 7 8 9 10，

故对4取模的结果为1 2 3 0 1 2 3 0 1 2，c为3，所以0 1 2都是有效类型，类型为1和2的有3个数据，类型为0的只有2个数据，故输出3。

输入

1 4 256 257 258 259 260 261 262 263 264 265

输出

说明

10个数据4个字节相加后的结果分别为1 2 3 4 5 6 7 8 9 10，

故对4取模的结果为1 2 3 0 1 2 3 0 1 2，c为1，

所以只有0是有效类型，类型为0的有2个数据，故输出2。

分类数据统计问题详解

一、核心解题思路

问题分析
题目要求对10个数据进行分类处理：

每个数据是32位整数，需要拆分为4个字节（每个字节8位）
计算4个字节的和并对b取模：r = (byte1+byte2+byte3+byte4) % b
分类规则：

若 r < c：有效类型，类型值为r
否则：无效类型，不计数

目标：找出有效类型中出现次数最多的类型，输出其出现次数

关键步骤

字节拆分：将32位整数拆分为4个8位字节
分类计算：

计算字节和 s = byte1+byte2+byte3+byte4
计算模值 r = s % b
若 r < c 则记录该类型

结果统计：统计各有效类型的出现次数，找出最大值

算法选择
使用哈希表（字典）记录各有效类型的出现次数：

count_dict = {}
for 每个数据:
r = 计算取模结果
if r < c:
count_dict[r] += 1
max_count = max(count_dict.values())

二、完整代码实现

def main():
    # 读取输入数据
    data = list(map(int, input().split()))
    if len(data) < 12:  # 增加输入验证
        print(0)
        return
        
    c = data[0]  # 分类阈值
    b = data[1]  # 取模基数
    values = data[2:12]  # 10个分类数据

    # 初始化类型计数器
    count_dict = {}

    # 处理每个数据
    for x in values:
        # 拆分32位整数为4个字节
        byte1 = (x >> 24) & 0xFF  # 最高位字节
        byte2 = (x >> 16) & 0xFF
        byte3 = (x >> 8) & 0xFF
        byte4 = x & 0xFF  # 最低位字节
        
        # 计算字节和并取模
        byte_sum = byte1 + byte2 + byte3 + byte4
        r = byte_sum % b
        
        # 记录有效类型
        if r < c:
            count_dict[r] = count_dict.get(r, 0) + 1
    
    # 输出最多数据的有效类型数量
    if count_dict:
        max_count = max(count_dict.values())
        print(max_count)
    else:
        print(0)  # 没有有效类型时输出0

if __name__ == "__main__":
    main()

三、算法原理解析

核心操作解析

字节拆分：

byte1 = (x >> 24) & 0xFF

右移24位获取最高8位
& 0xFF 屏蔽高位，保留8位值

取模运算：

r = byte_sum % b

确保结果在 [0, b-1] 范围内

类型统计：

count_dict[r] = count_dict.get(r, 0) + 1

使用字典记录各类型出现次数
get(r,0) 处理首次出现的类型

时间复杂度

O(10×4) = O(40)：10个数据，每个数据4次操作
高效处理最大1000+数据的扩展情况

四、示例解析

用例1：输入 3 4 256 257 258 259 260 261 262 263 264 265

计算过程：

拆分数据：

256 → [0,0,1,0] 和=1 %4=1 (有效)
257 → [0,0,1,1] 和=2 %4=2 (有效)
258 → [0,0,1,2] 和=3 %4=3 (无效)
259 → [0,0,1,3] 和=4 %4=0 (有效)
260 → [0,0,1,4] 和=5 %4=1 (有效)
261 → [0,0,1,5] 和=6 %4=2 (有效)
262 → [0,0,1,6] 和=7 %4=3 (无效)
263 → [0,0,1,7] 和=8 %4=0 (有效)
264 → [0,0,1,8] 和=9 %4=1 (有效)
265 → [0,0,1,9] 和=10 %4=2 (有效)

有效类型统计：

类型0：259,263 → 2次
类型1：256,260,264 → 3次
类型2：257,261,265 → 3次

输出最大值：3

用例2：输入 1 4 256 257 258 259 260 261 262 263 264 265

计算过程：

相同的数据拆分和取模
分类规则变化：c=1 → 只有 r<1 有效（即 r=0）
有效类型统计：

类型0：259,263 → 2次
类型1、2：均不符合 r<1

输出最大值：2

五、总结

算法特点：

精确高效：使用位运算高效拆分字节
逻辑清晰：分步骤处理分类规则
健壮性强：处理边界情况（无有效类型）
空间优化：字典仅存储有效类型

关键要点：

位运算技巧：移位和掩码操作拆分字节
模运算应用：确保类型值在合理范围
字典统计：高效记录类型出现次数
最大值提取：max(count_dict.values())

应用场景：

数据分类统计系统
网络协议数据处理
嵌入式系统字节操作
数据特征提取和分析

该解法严格遵循题目要求，正确处理了字节拆分、模运算、分类统计等关键步骤输出最优结果。