当前位置： 首页 > news >正文

华为OD机试真题——数据分类（2025A卷：100分）Java/python/JavaScript/C++/C语言/GO六种最佳实现

news 2025/8/27 3:22:15

在这里插入图片描述

2025 A卷 100分 题型

本文涵盖详细的问题分析、解题思路、代码实现、代码详解、测试用例以及综合分析；
并提供Java、python、JavaScript、C++、C语言、GO六种语言的最佳实现方式！

本文收录于专栏：《2025华为OD真题目录+全流程解析/备考攻略/经验分享》

华为OD机试真题《数据分类》：

目录

    • 题目名称：数据分类
      • 题目描述
    • Java
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • python
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • JavaScript
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • C++
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • C语言
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • GO
      • 问题分析
      • 解题思路
      • 代码实现
      • 代码详细解析
      • 示例测试
      • 综合分析
    • 更多内容：

题目名称：数据分类

  • 知识点：位运算、逻辑处理
  • 时间限制：1秒
  • 空间限制：256MB
  • 限定语言：不限

题目描述

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

  1. 将 a（四个字节大小）的四个字节的十进制值相加，得到一个总和。
  2. 将此总和对一个给定的值 b 取模。
  3. 若取模结果小于另一个给定值 c，则该结果为 a 的有效类型；否则类型无效。

输入描述

  • 输入12个数据，以空格分隔：
    • 第一个数据为 c，第二个数据为 b，剩余10个数据为待分类的整数（每个数 ≤ 1e9）。

输出描述

  • 统计有效类型中包含数据最多的类型，输出其数据个数。若所有类型均无效，输出 0。

示例1
输入：

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

输出：

3

说明

  • 每个数转换为四个字节的十六进制字符串（不足8位补前导0），例如256补为 00000100，每个字节转为十进制相加，结果为 0 + 0 + 1 + 0 = 1。
  • 10个数的总和分别为 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个数据，故输出3。

补充说明

  • 每个整数需转换为四个字节的十六进制表示，例如 256 转为 00000100，拆分后字节为 0x00, 0x00, 0x01, 0x00。
  • 需统计所有有效类型的出现次数，取最大值。

Java

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取c、b和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对b取模，判断是否小于c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

import java.util.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);String[] input = scanner.nextLine().split(" ");// 解析输入参数int c = Integer.parseInt(input[0]);int b = Integer.parseInt(input[1]);int[] nums = new int[10];for (int i = 0; i < 10; i++) {nums[i] = Integer.parseInt(input[i + 2]);}Map<Integer, Integer> typeCount = new HashMap<>(); // 统计有效类型出现次数for (int num : nums) {// 计算四个字节的十进制和int sum = 0;sum += (num >> 24) & 0xFF; // 最高位字节sum += (num >> 16) & 0xFF;sum += (num >> 8) & 0xFF;sum += num & 0xFF; // 最低位字节int mod = sum % b; // 取模结果if (mod < c) { // 判断是否有效typeCount.put(mod, typeCount.getOrDefault(mod, 0) + 1);}}// 找出最大出现次数int max = 0;for (int count : typeCount.values()) {if (count > max) max = count;}System.out.println(max);}
}

代码详细解析

  1. 输入处理：使用Scanner读取输入并分割成字符串数组，解析出c、b和10个整数。
  2. 字节和计算：
    • 通过位运算(num >> n) & 0xFF依次提取四个字节的值。
    • 累加四个字节的十进制值得到总和。
  3. 模运算与分类：计算总和对b取模，若结果小于c则记录到哈希表中。
  4. 统计与输出：遍历哈希表的值，找到最大出现次数并输出。

示例测试

示例1输入：

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

输出：

3

解析：有效类型为0、1、2，类型1和2各出现3次。

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：所有模结果均小于5，所有类型有效，最大值10。

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：c=0，所有模结果不小于0，无有效类型。

综合分析

  1. 时间复杂度：O(n)，其中n=10，每个数处理时间为常数。
  2. 空间复杂度：O(k)，k为有效类型数量，最多为min(b, c)。
  3. 优势：
    • 高效位运算：快速提取字节值，无需复杂转换。
    • 哈希表统计：O(1)时间记录和查询频率。
  4. 适用场景：适用于大范围整数分类，满足时间与空间要求。

python

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取c、b和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对b取模，判断是否小于c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

# 读取输入并解析
input_list = list(map(int, input().split()))
c = input_list[0]
b = input_list[1]
nums = input_list[2:12]# 统计有效类型出现次数
type_count = {}for num in nums:# 提取四个字节的十进制值byte1 = (num >> 24) & 0xFF  # 最高位字节byte2 = (num >> 16) & 0xFFbyte3 = (num >> 8)  & 0xFFbyte4 = num & 0xFF         # 最低位字节total = byte1 + byte2 + byte3 + byte4# 计算模结果并判断有效性mod = total % bif mod < c:type_count[mod] = type_count.get(mod, 0) + 1# 找出最大出现次数
max_count = max(type_count.values()) if type_count else 0
print(max_count)

代码详细解析

  1. 输入处理：

    • input().split() 读取输入并分割成字符串列表
    • map(int, ...) 转换为整数列表
    • 第一个元素为c，第二个为b，后续为待处理的10个整数

  2. 字节提取：

    • (num >> 24) & 0xFF：右移24位获取最高位字节
    • (num >> 16) & 0xFF：右移16位获取第二个字节
    • (num >> 8) & 0xFF：右移8位获取第三个字节
    • num & 0xFF：直接取最低位字节

  3. 求和与分类：

    • 计算四个字节之和 total
    • total % b 计算模结果
    • 若模结果 < c 则记录到字典 type_count

  4. 统计结果：

    • 若字典非空则取最大值，否则输出0

示例测试

示例1输入：

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

输出：

3

解析：

  • 256的字节和为1 → 1%4=1（有效）
  • 类型1和2各出现3次，最大值3

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：

  • 所有数的模结果均小于5，最大值10

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：

  • 所有模结果≥0，但c=0，均无效

综合分析

  1. 时间复杂度：O(n)，其中n=10，每个数处理时间为O(1)
  2. 空间复杂度：O(k)，k为有效类型数量（最多为b）
  3. 优势：
    • 位运算高效：直接通过位移和掩码提取字节，无需类型转换
    • 哈希表快速统计：字典操作时间复杂度为O(1)
  4. 适用场景：适用于大规模整数处理，满足时间与空间要求

JavaScript

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取 c、b 和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对 b 取模，判断是否小于 c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

const fs = require('fs');
const input = fs.readFileSync(0).toString().trim().split(/\s+/);// 解析输入参数
const c = parseInt(input[0], 10);
const b = parseInt(input[1], 10);
const nums = input.slice(2, 12).map(num => parseInt(num, 10));const typeCount = {}; // 记录有效类型出现次数/*** 计算整数的四个字节之和* @param {number} num - 待处理的整数* @returns {number} 四个字节的十进制和*/
function getByteSum(num) {const byte1 = (num >> 24) & 0xff; // 最高位字节const byte2 = (num >> 16) & 0xff;const byte3 = (num >> 8)  & 0xff;const byte4 = num & 0xff;         // 最低位字节return byte1 + byte2 + byte3 + byte4;
}// 处理每个数字
for (const num of nums) {const sum = getByteSum(num);const mod = sum % b;          // 计算模结果if (mod < c) {               // 判断有效性typeCount[mod] = (typeCount[mod] || 0) + 1;}
}// 找出最大出现次数
const counts = Object.values(typeCount);
const max = counts.length > 0 ? Math.max(...counts) : 0;
console.log(max);

代码详细解析

  1. 输入处理：

    • fs.readFileSync(0) 读取输入流。
    • split(/\s+/) 按空格分割输入字符串。
    • 解析前两个参数为 c 和 b，剩余参数转为整数数组。

  2. 字节和计算：

    • (num >> 24) & 0xff：右移24位获取最高位字节。
    • (num >> 16) & 0xff：右移16位获取第二个字节。
    • (num >> 8) & 0xff：右移8位获取第三个字节。
    • num & 0xff：直接取最低位字节。

  3. 模运算与分类：

    • 计算四个字节之和 sum。
    • sum % b 计算模结果。
    • 若模结果 < c 则记录到 typeCount 对象。

  4. 统计与输出：

    • Object.values(typeCount) 获取所有有效类型的出现次数。
    • 找出最大值，若无效则输出0。

示例测试

示例1输入：

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

输出：

3

解析：

  • 256的字节和为1 → 1%4=1（有效）。
  • 有效类型0、1、2中，类型1和2各出现3次。

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：

  • 所有模结果均小于5，所有类型有效，最大值10。

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：

  • c=0，所有模结果非负，均无效。

综合分析

  1. 时间复杂度：O(n)，其中n=10，每个数处理时间为O(1)。
  2. 空间复杂度：O(k)，k为有效类型数量（最多为b）。
  3. 优势：
    • 位运算高效：直接通过位移和掩码提取字节，无需类型转换。
    • 哈希表快速统计：对象操作时间复杂度为O(1)。
  4. 适用场景：适用于大规模整数处理，满足时间与空间要求。

C++

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取 c、b 和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对 b 取模，判断是否小于 c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

#include <iostream>
#include <unordered_map>
#include <vector>using namespace std;int main() {int c, b;vector<int> nums(10);// 读取输入：前两个参数为c和b，剩余10个为待处理整数cin >> c >> b;for (int i = 0; i < 10; ++i) {cin >> nums[i];}unordered_map<int, int> type_count; // 记录有效类型及其出现次数for (int num : nums) {unsigned unum = num; // 转换为无符号类型，避免符号扩展问题int sum = 0;sum += (unum >> 24) & 0xFF; // 提取最高位字节（第4个字节）sum += (unum >> 16) & 0xFF; // 提取第3个字节sum += (unum >> 8)  & 0xFF; // 提取第2个字节sum += unum & 0xFF;         // 提取最低位字节（第1个字节）int mod = sum % b;          // 计算模结果if (mod < c) {              // 判断是否为有效类型type_count[mod]++;}}// 找出出现次数最多的类型int max_count = 0;for (const auto& pair : type_count) {if (pair.second > max_count) {max_count = pair.second;}}cout << max_count << endl;return 0;
}

代码详细解析

  1. 输入处理：

    • cin 读取输入，前两个值为 c 和 b，后续为10个整数。
    • 使用 vector<int> 存储待处理的整数。

  2. 字节和计算：

    • unum = num：将数值转换为无符号类型，避免右移时的符号扩展问题。
    • (unum >> 24) & 0xFF：右移24位获取最高位字节（第4个字节）。
    • (unum >> 16) & 0xFF：右移16位获取第3个字节。
    • (unum >> 8) & 0xFF：右移8位获取第2个字节。
    • unum & 0xFF：直接取最低位字节（第1个字节）。

  3. 模运算与分类：

    • sum % b：计算四个字节之和的模结果。
    • if (mod < c)：判断是否为有效类型，并更新哈希表 type_count。

  4. 统计结果：

    • 遍历哈希表，找到出现次数最多的类型，输出其出现次数。

示例测试

示例1输入：

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

输出：

3

解析：

  • 256的四个字节和为 0+0+1+0=1 → 1%4=1（有效）。
  • 有效类型为0、1、2，类型1和2各出现3次。

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：

  • 所有数的模结果均小于5，有效类型出现次数最大为10。

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：

  • c=0，所有模结果非负，均无效。

综合分析

  1. 时间复杂度：O(1)

    • 每个整数处理时间为常数，总共有10个整数，总时间复杂度为 O(10) = O(1)。

  2. 空间复杂度：O(1)

    • 哈希表最多存储 b 个键值对，但 b 的范围由输入决定，实际中可视为常数。

  3. 优势：

    • 位运算高效：通过位移和掩码快速提取字节值，时间复杂度稳定。
    • 哈希表快速统计：unordered_map 的插入和查询操作平均为 O(1) 时间复杂度。

  4. 适用场景：

    • 适用于需要快速处理整数分类的场景，如网络协议解析、数据特征提取等。

C语言

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取 c、b 和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对 b 取模，判断是否小于 c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

#include <stdio.h>
#include <stdlib.h>int main() {int c, b;int nums[10];// 读取输入参数scanf("%d %d", &c, &b);for (int i = 0; i < 10; i++) {scanf("%d", &nums[i]);}// 处理特殊情况：c ≤ 0时所有类型无效if (c <= 0) {printf("0\n");return 0;}// 动态分配数组记录有效类型的出现次数int *count = (int *)calloc(b, sizeof(int));if (count == NULL) {printf("0\n");return 0;}// 处理每个数字for (int i = 0; i < 10; i++) {unsigned num = (unsigned)nums[i]; // 转为无符号数处理// 提取四个字节的十进制值int byte1 = (num >> 24) & 0xFF; // 最高位字节int byte2 = (num >> 16) & 0xFF;int byte3 = (num >> 8) & 0xFF;int byte4 = num & 0xFF;         // 最低位字节int sum = byte1 + byte2 + byte3 + byte4;int mod = sum % b;              // 计算模结果if (mod < c) {                  // 判断有效性count[mod]++;               // 统计有效类型}}// 遍历数组找出最大出现次数int max_count = 0;for (int i = 0; i < b; i++) {if (count[i] > max_count) {max_count = count[i];}}// 输出结果并释放内存printf("%d\n", max_count);free(count);return 0;
}

代码详细解析

  1. 输入处理：
    • scanf 读取前两个参数 c 和 b，后续读取10个整数存入数组 nums。
  2. 特殊处理：
    • 若 c <= 0，直接输出0，因为所有模结果均无效。
  3. 动态数组分配：
    • 使用 calloc 分配大小为 b 的数组 count，初始化为0，用于记录每个有效类型的出现次数。
  4. 字节分解与求和：
    • 将整数转为无符号数处理，避免符号扩展问题。
    • 通过位操作提取四个字节的值，计算它们的十进制和。
  5. 模运算与分类：
    • 计算总和对 b 取模，若结果小于 c，则在 count 数组中对应位置计数加1。
  6. 统计结果：
    • 遍历 count 数组，找到出现次数的最大值并输出。

示例测试

示例1输入：

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

输出：

3

解析：

  • 有效类型为0、1、2，类型1和2各出现3次。

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：

  • 所有模结果均小于5，有效类型出现次数最大为10。

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：

  • c=0，所有模结果均无效，输出0。

综合分析

  1. 时间复杂度：O(1)
    • 每个整数处理时间为常数，总共有10个整数，时间复杂度为 O(10) = O(1)。
  2. 空间复杂度：O(b)
    • 使用动态数组 count 记录有效类型次数，数组大小为 b。
  3. 优势：
    • 位运算高效：通过无符号转换和位操作快速提取字节值。
    • 动态内存管理：灵活处理不同规模的 b，避免内存浪费。
  4. 适用场景：
    • 适用于需要快速处理整数分类的场景，如网络协议解析、数据特征提取等。

GO

问题分析

我们需要根据输入的整数数组进行分类，分类规则基于每个整数的四个字节之和的模运算结果。统计有效类型中出现次数最多的数据个数，若所有类型无效则输出0。

解题思路

  1. 输入处理：读取 c、b 和10个待分类的整数。
  2. 字节和计算：将每个整数拆分为四个字节，计算各字节的十进制和。
  3. 模运算与分类：计算字节和对 b 取模，判断是否小于 c，记录有效类型。
  4. 统计与输出：统计有效类型的出现次数，输出最大值。

代码实现

package mainimport ("bufio""fmt""os""strconv""strings"
)func main() {scanner := bufio.NewScanner(os.Stdin)scanner.Scan()input := strings.TrimSpace(scanner.Text())parts := strings.Fields(input)// 解析输入参数c, _ := strconv.Atoi(parts[0])b, _ := strconv.Atoi(parts[1])nums := parts[2:12]// 处理无效的 cif c <= 0 {fmt.Println(0)return}typeCount := make(map[int]int) // 记录有效类型的出现次数// 处理每个数字for _, s := range nums {num, _ := strconv.Atoi(s)u := uint32(num) // 转换为无符号数处理负数// 提取四个字节的十进制值byte1 := (u >> 24) & 0xFF // 最高位字节byte2 := (u >> 16) & 0xFFbyte3 := (u >> 8) & 0xFFbyte4 := u & 0xFFsum := int(byte1 + byte2 + byte3 + byte4)mod := sum % b // 计算模结果if mod < c {    // 判断是否有效typeCount[mod]++}}// 找出最大出现次数maxCount := 0for _, count := range typeCount {if count > maxCount {maxCount = count}}fmt.Println(maxCount)
}

代码详细解析

  1. 输入处理：

    • bufio.Scanner 读取输入并分割为字符串数组。
    • 第一个元素为 c，第二个为 b，剩余10个为待处理整数。

  2. 无效类型处理：

    • 若 c <= 0，直接输出0，因为所有模结果均无效。

  3. 字节分解与求和：

    • uint32(num)：将整数转为无符号类型，避免符号扩展问题。
    • (u >> 24) & 0xFF：提取最高位字节（第4个字节）。
    • (u >> 16) & 0xFF：提取第3个字节。
    • (u >> 8) & 0xFF：提取第2个字节。
    • u & 0xFF：提取最低位字节（第1个字节）。

  4. 模运算与分类：

    • sum % b：计算总和对 b 取模。
    • mod < c：判断是否为有效类型，并记录到 typeCount。

  5. 统计结果：

    • 遍历哈希表 typeCount，找到出现次数最多的有效类型。

示例测试

示例1输入：

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

输出：

3

解析：

  • 256的四个字节和为 0+0+1+0=1 → 1%4=1（有效）。
  • 有效类型为0、1、2，类型1和2各出现3次。

示例2输入：

5 3 1 2 3 4 5 6 7 8 9 10

输出：

10

解析：

  • 所有数的模结果均小于5，有效类型出现次数最大为10。

示例3输入：

0 1 100 200 300 400 500 600 700 800 900 1000

输出：

0

解析：

  • c=0，所有模结果均无效，输出0。

综合分析

  1. 时间复杂度：O(1)
    • 每个整数处理时间为常数，总共有10个整数，时间复杂度为 O(10) = O(1)。
  2. 空间复杂度：O(1)
    • 哈希表最多存储 b 个键值对，但 b 的范围由输入决定，实际中可视为常数。
  3. 优势：
    • 位运算高效：通过位移和掩码快速提取字节值。
    • 哈希表快速统计：map[int]int 的插入和查询操作平均为 O(1)。
  4. 适用场景：
    • 适用于需要快速处理整数分类的场景，如网络协议解析、数据特征提取等。

更多内容：

https://www.kdocs.cn/l/cvk0eoGYucWA

本文发表于【纪元A梦】，关注我，获取更多实用教程/资源！

http://www.xdnf.cn/news/56701.html

相关文章：

  • 爱普生TG-5006CG成为提升5G RedCap时钟同步精度的理想选择
  • 4.1腾讯校招简历优化与自我介绍攻略：公式化表达+结构化呈现
  • 【AI提示词】数据分析专家
  • from tensorflow.keras.models import Model中Model报红；以及动态链接库(DLL)初始化例程失败
  • n8n 中文系列教程_05.如何在本机部署/安装 n8n（详细图文教程）
  • jvm-描述符与特征签名的区别
  • 华为设备命令部分精简分类汇总示例
  • 【Unity iOS打包】报错解决记录
  • OpenCV训练题
  • 初识Redis · C++客户端set和zset
  • 【阿里云大模型高级工程师ACP习题集】2.1 用大模型构建新人答疑机器人
  • 阿里云入门手册
  • Java 将对象转为 Map 的几种方法
  • MySQL安装
  • 栈和队列--数据结构初阶(2)(C/C++)
  • MATLAB 训练CNN模型 yolo v4
  • CSS预处理工具有哪些？分享主流产品
  • 【身份证扫描件识别表格】如何识别大量身份证扫描件将内容导出保存到Excel表格，一次性处理多张身份证图片导出Excel表格，基于WPF和腾讯云的实现方案
  • spring security +kotlin 实现oauth2.0 认证
  • 问题 | RAIM + LSTM 你怎么看？？？
  • 【图像轮廓特征查找】图像处理（OpenCV) -part8
  • Linux深度探索：进程管理与系统架构
  • 碰一碰发视频源码，碰一碰发视频OEM
  • MySQL快速入门篇---表的操作
  • 【图片转PDF工具】如何批量将文件夹里的图片以文件夹为单位批量合并PDF文档，基于WPF实现步骤及总结
  • 深入理解自监督学习（Self-Supervised Learning）：理论与实践
  • Spring MVC
  • Web3核心技术解析：从区块链到C++实践
  • 【沉浸式求职学习day21】【常用类分享，完结！】
  • 【Hive入门】Hive概述：大数据时代的数据仓库桥梁