(B卷,100分)- 数据分类（Java & JS & Python）

题目描述

对一个数据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个数据为需要分类的数据。

输出描述

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

用例

题目解析

逻辑题，按照题目意思写过程即可。

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
  let arr = line.split(" ");

  const c = arr.shift() - 0;
  const b = arr.shift() - 0;

  console.log(getResult(arr, c, b));
});

function getResult(arr, c, b) {
  const count = {};

  arr
    .map((a) => {
      let str = Number(a).toString(16);

      if (str.length % 2 !== 0) {
        str = "0" + str;
      }

      let sum = 0;
      for (let i = 0; i < str.length - 1; i += 2) {
        sum += parseInt(str.slice(i, i + 2), 16);
      }

      const type = sum % b;

      if (type < c) {
        return type;
      } else {
        return -1;
      }
    })
    .forEach((type) => {
      if (type !== -1) {
        count[type] ? count[type]++ : (count[type] = 1);
      }
    });

  return Object.values(count).sort((a, b) => b - a)[0];
}

Java算法源码

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class Main {
  // 输入获取
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int c = sc.nextInt();
    int b = sc.nextInt();

    int[] arr = new int[10];
    for (int i = 0; i < 10; i++) arr[i] = sc.nextInt();

    System.out.println(getResult(c, b, arr));
  }

  // 算法入口
  public static int getResult(int c, int b, int[] arr) {
    HashMap<Integer, Integer> count = new HashMap<>();

    Arrays.stream(arr)
        .map(
            a -> {
              String str = Integer.toHexString(a);

              if (str.length() % 2 != 0) {
                str = "0" + str;
              }

              int sum = 0;
              for (int i = 0; i < str.length() - 1; i += 2) {
                sum += Integer.parseInt(str.substring(i, i + 2), 16);
              }

              int t = sum % b;
              if (t < c) {
                return t;
              } else {
                return -1;
              }
            })
        .forEach(
            t -> {
              if (t != -1) {
                count.put(t, count.getOrDefault(t, 0) + 1);
              }
            });

    return count.values().stream().max((x, y) -> x - y).orElse(0);
  }
}

Python算法源码

# 输入获取
tmp = list(map(int, input().split()))
c = tmp[0]
b = tmp[1]
arr = tmp[2:]


# 判断是否有效
def classify(a):
    s = hex(a)[2:]  # hex方法会将十进制转为0x开头的16进制数，这里去除0x前缀

    if len(s) % 2 != 0:
        s = "0" + s  # 补足0

    sumV = 0
    for i in range(0, len(s) - 1, 2):
        sumV += int(s[i:i + 2], 16)

    t = sumV % b

    if t < c:
        return t
    else:
        return -1


# 算法入口
def getResult():
    count = {}

    for t in map(classify, arr):
        if t != -1:
            if count.get(t) is None:
                count[t] = 1
            else:
                count[t] += 1

    return max(count.values())


# 算法调用
print(getResult())