题面描述

给定12个数据，其中第一个数据为c，第二个数据为b，剩余的10个数据为需要分类的数据a。分类方法如下：

1. 对每个数据a，将其视为一个四字节（32位）的无符号整数。
2. 提取a的四个字节，分别为高位到低位的字节。
3. 计算这四个字节的和，然后对给定的值b取模，得到sum_mod。
4. 如果sum_mod小于c，则该数据a为有效类型，其类型为sum_mod；否则，该数据为无效类型。

最终，需要在所有有效类型中，找到包含数据最多的类型，并输出该类型所包含的数据个数。

思路

1. 输入处理：首先读取12个整数，其中第一个是c，第二个是b，其余10个是需要分类的数据a。
2. 字节提取与求和：对于每个数据a，提取其四个字节，并计算这四个字节的和。
3. 取模与分类：
   • 计算sum_mod = sum_of_bytes % b。
   • 如果sum_mod < c，则该数据为有效类型，类型为sum_mod。
   • 否则，该数据为无效类型。
4. 统计有效类型：使用一个数组或哈希表统计每种有效类型出现的次数。
5. 找到最大计数：遍历统计结果，找到出现次数最多的有效类型，并输出其计数。

cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

int main(){
    // 读取12个整数，分别赋值给c, b和data数组
    int c, b;
    cin >> c >> b;
    vector<unsigned int> data(10);
    for(int i=0;i<10;i++) cin >> data[i];
    
    // 使用一个哈希表统计各有效类型的出现次数
    unordered_map<int, int> type_count;
    
    for(auto a : data){
        // 提取四个字节
        unsigned int byte1 = (a >> 24) & 0xFF;
        unsigned int byte2 = (a >> 16) & 0xFF;
        unsigned int byte3 = (a >> 8) & 0xFF;
        unsigned int byte4 = a & 0xFF;
        
        // 计算字节和
        int sum = byte1 + byte2 + byte3 + byte4;
        
        // 计算sum_mod
        if(b == 0){
            // 避免除以0
            continue;
        }
        int sum_mod = sum % b;
        
        // 判断是否为有效类型
        if(sum_mod < c){
            type_count[sum_mod]++;
        }
    }
    
    // 找到最大计数
    int max_count = 0;
    for(auto &p : type_count){
        if(p.second > max_count){
            max_count = p.second;
        }
    }
    
    // 输出结果
    cout << max_count;
    
    return 0;
}

python

# 读取输入
input_values = list(map(int, input().split()))
c, b = input_values[0], input_values[1]
data = input_values[2:]

# 使用字典统计有效类型的出现次数
type_count = {}

for a in data:
    # 提取四个字节
    byte1 = (a >> 24) & 0xFF
    byte2 = (a >> 16) & 0xFF
    byte3 = (a >> 8) & 0xFF
    byte4 = a & 0xFF
    
    # 计算字节和
    sum_bytes = byte1 + byte2 + byte3 + byte4
    
    # 计算sum_mod
    if b == 0:
        # 避免除以0
        continue
    sum_mod = sum_bytes % b
    
    # 判断是否为有效类型
    if sum_mod < c:
        if sum_mod in type_count:
            type_count[sum_mod] += 1
        else:
            type_count[sum_mod] = 1

# 找到最大计数
max_count = 0
for count in type_count.values():
    if count > max_count:
        max_count = count

# 输出结果
print(max_count)

java

import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        // 读取c和b
        int c = sc.nextInt();
        int b = sc.nextInt();
        
        // 读取10个数据a
        long[] data = new long[10];
        for(int i=0;i<10;i++) data[i] = sc.nextLong();
        
        // 使用HashMap统计有效类型的出现次数
        HashMap<Integer, Integer> typeCount = new HashMap<>();
        
        for(long a : data){
            // 提取四个字节
            int byte1 = (int)((a >> 24) & 0xFF);
            int byte2 = (int)((a >> 16) & 0xFF);
            int byte3 = (int)((a >> 8) & 0xFF);
            int byte4 = (int)(a & 0xFF);
            
            // 计算字节和
            int sum = byte1 + byte2 + byte3 + byte4;
            
            // 计算sum_mod
            if(b == 0){
                // 避免除以0
                continue;
            }
            int sum_mod = sum % b;
            
            // 判断是否为有效类型
            if(sum_mod < c){
                typeCount.put(sum_mod, typeCount.getOrDefault(sum_mod, 0) + 1);
            }
        }
        
        // 找到最大计数
        int maxCount = 0;
        for(int count : typeCount.values()){
            if(count > maxCount){
                maxCount = count;
            }
        }
        
        // 输出结果
        System.out.println(maxCount);
    }
}

题目描述

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

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

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

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

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

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

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

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

输入描述

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

输出描述

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

样例1

输入

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

输出

3

说明

$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$。

样例2

输入

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

输出

2

说明

$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。