✅ 秋招备战指南 ✅

💡 学习建议：

• 先尝试独立解题
• 对照解析查漏补缺

🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。

🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力

🌸 目前本专栏已经上线140+套真题改编解析，后续会持续更新的

春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗

题目一：古币收藏家的宝物分析

1️⃣：质因数分解统计所有质因数的指数

2️⃣：利用数学性质发现分解质因数总是更优

3️⃣：答案为所有质因数指数之和的两倍

难度：中等

这道题目的核心在于理解质因数分解的性质。通过数学分析发现，将质数的幂次全部分解为单个质因数总是能获得更大的因子个数和。使用线性筛预处理最小质因数，可以在 O(log n) 时间内完成质因数分解。

题目二：企业员工兴趣多样性分析

1️⃣：解析 JSON 格式的员工兴趣数据

2️⃣：基于信息熵理论计算多样性指数

3️⃣：处理浮点精度并格式化输出结果

难度：中等

这道题目结合了数据解析和信息论知识，需要理解信息熵的计算原理。关键在于正确处理概率计算、对数运算和浮点数精度问题。通过 JSON 解析和数学计算，评估员工兴趣分布的多样性程度。

题目三：密码学家的编码解谜

1️⃣：解析特殊编码格式，提取运算符和操作数

2️⃣：将字母序列转换为对应的数字

3️⃣：执行四则运算并处理特殊情况

难度：中等

这道题目考查字符串处理和基本数学运算。需要理解字符到数字的映射规则，正确解析表达式结构，并处理除零和负数等边界情况。通过字符串遍历和数学计算，实现自定义编码系统的表达式求值。

01. 古币收藏家的宝物分析

问题描述

小基 是一位资深的古币收藏家，她拥有一个特殊的古币价值评估系统。在这个系统中，每枚古币的价值 都有一个对应的"神秘指数"，定义为 的所有正因子的个数，记作 ，其中 表示 的因子个数。

小基 最近获得了一批珍贵的古币，每批古币的总价值为 。她可以选择将这批古币重新组合，分成若干组，每组的价值分别为 （其中 ，且每个 ），满足以下条件：

• 

• 最大化

请帮助 小基 计算在最优重新组合方案下，所有组的神秘指数之和的最大可能值。

输入格式

第一行包含一个正整数 （），表示测试数据的组数。

接下来 行，每行包含一个正整数 （），表示古币的总价值。

输出格式

对于每组测试数据，输出一行，包含一个整数，表示在最优重新组合方案下，神秘指数之和的最大值。

样例输入

3
2
10
123

样例输出

2
4
4

数据范围

样例	解释说明
样例1	对于 ，无法再分解，只能取自身，
样例2	对于 ，最优方案为 ，，，总和为
样例3	对于 ，最优方案为 ，，，总和为

题解

这道题的核心思想是要理解因数分解的本质。当我们有一个数 时，我们要考虑如何分解它能让所有部分的因子个数之和最大。

首先，我们需要明白一个重要的数学事实：对于任何质数 和正整数 ，将 分解为 个 的乘积，会比保持 不变得到更大的因子个数和。

具体来说：

• 如果不分解， 的因子个数为
• 如果分解为 个 ，每个 的因子个数为 ，总和为

当 时，显然有 ，所以分解总是更优的。

基于这个观察，最优策略就是：

1. 将 进行质因数分解：
2. 将每个质因数的所有幂次都分解为单个质因数
3. 最终答案就是所有质因数指数之和的两倍：

算法步骤：

1. 对输入的 进行质因数分解
2. 统计所有质因数的指数和
3. 将结果乘以 即为答案

时间复杂度：每个数的质因数分解复杂度为 ，但通过预处理最小质因数可以优化到 。

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

def solve():
    # 预处理最小质因数，用于快速分解
    MAXN = 200000
    spf = [0] * (MAXN + 1)  # smallest prime factor
    
    # 线性筛预处理最小质因数
    for i in range(2, MAXN + 1):
        if spf[i] == 0:  # i是质数
            for j in range(i, MAXN + 1, i):
                if spf[j] == 0:
                    spf[j] = i
    
    T = int(input())
    for _ in range(T):
        x = int(input())
        exp_sum = 0  # 指数和
        
        # 质因数分解，统计所有质因数的指数
        while x > 1:
            p = spf[x]  # 当前最小质因数
            cnt = 0     # 当前质因数的指数
            while x % p == 0:
                x //= p
                cnt += 1
            exp_sum += cnt
        
        # 答案是指数和的两倍
        print(exp_sum * 2)

if __name__ == "__main__":
    solve()

• Cpp

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    const int MAXN = 200000;
    vector<int> spf(MAXN + 1, 0);  // 最小质因数数组
    
    // 线性筛预处理最小质因数
    for (int i = 2; i <= MAXN; i++) {
        if (spf[i] == 0) {  // i是质数
            for (int j = i; j <= MAXN; j += i) {
                if (spf[j] == 0) {
                    spf[j] = i;
                }
            }
        }
    }
    
    int T;
    cin >> T;
    
    while (T--) {
        int x;
        cin >> x;
        int exp_sum = 0;  // 指数和
        
        // 质因数分解过程
        while (x > 1) {
            int p = spf[x];  // 获取最小质因数
            int cnt = 0;     // 计算该质因数的指数
            while (x % p == 0) {
                x /= p;
                cnt++;
            }
            exp_sum += cnt;  // 累加指数
        }
        
        cout << exp_sum * 2 << "\n";  // 输出指数和的两倍
    }
    
    return 0;
}

• Java

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        final int MAXN = 200000;
        int[] spf = new int[MAXN + 1];  // 最小质因数数组
        
        // 线性筛预处理最小质因数
        for (int i = 2; i <= MAXN; i++) {
            if (spf[i] == 0) {  // i是质数
                for (int j = i; j <= MAXN; j += i) {
                    if (spf[j] == 0) {
                        spf[j] = i;
                    }
                }
            }
        }
        
        int T = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        
        for (int t = 0; t < T; t++) {
            int x = Integer.parseInt(br.readLine());
            int expSum = 0;  // 指数和
            
            // 质因数分解过程
            while (x > 1) {
                int p = spf[x];  // 获取最小质因数
                int cnt = 0;     // 计算该质因数的指数
                while (x % p == 0) {
                    x /= p;
                    cnt++;
                }
                expSum += cnt;   // 累加指数
            }
            
            sb.append(expSum * 2).append("\n");  // 输出指数和的两倍
        }
        
        System.out.print(sb.toString());
    }
}

02. 企业员工兴趣多样性分析

问题描述

小兰在一家大型科技公司担任人力资源分析师，她负责分析员工的兴趣多样性来优化团队配置。公司有一个员工兴趣统计系统，记录了每位员工在不同兴趣领域的参与度。

为了衡量员工兴趣的多样性程度，小兰需要计算每位员工的"兴趣多样性指数"。这个指数基于信息熵理论计算，公式如下：

其中， 是员工在第 个兴趣领域的参与度占比， 是兴趣领域的总数。

你需要编写一个程序，读取员工兴趣数据，计算每位员工的兴趣多样性指数，并将结果保留到 位小数输出。

输入格式

输入为一个 JSON 格式的字典，键是员工的工号（字符串），值是一个字典，包含该员工在各个兴趣领域的参与度数值。

输出格式

输出一个 JSON 格式的字典，格式与输入类似，但每位员工的值改为包含 entropy 键的字典，对应其兴趣多样性指数（保留 位小数）。注意输出需要使用双引号格式。

样例输入

{"emp001":{"music":10, "sports":20, "reading":30}, "emp002":{"music":20, "sports":30, "reading":10}, "emp003":{"music":30, "sports":10, "reading":20}}

样例输出

{"emp001": {"entropy": 1.459}, "emp002": {"entropy": 1.459}, "emp003": {"entropy": 1.459}}

数据范围

• 员工数量不超过

• 每位员工的兴趣领域数量不超过

• 每个兴趣领域的参与度为正整数，不超过

样例	解释说明
样例1	三位员工的兴趣分布都是 的某种排列，计算得到的熵值相同，都约为

题解

这道题本质上是计算信息熵的应用问题。信息熵是衡量信息不确定性或随机性的重要指标，在这里用来评估员工兴趣的多样性程度。

解题思路很直接：

1. 首先解析输入的 JSON 字符串，获得每位员工的兴趣数据
2. 对于每位员工，计算其在各个兴趣领域的总参与度
3. 计算每个领域的参与度占比
4. 根据信息熵公式计算多样性指数
5. 将结果保留 位小数并输出为指定的 JSON 格式

需要注意的几个细节：

• 当某个领域的参与度为 时，不参与熵的计算（因为 ）
• 使用 math.log2() 计算以 为底的对数
• 浮点数运算可能有精度误差，需要适当处理
• 输出格式要严格按照要求使用双引号

时间复杂度为 ，对于给定的数据范围完全可以接受。

参考代码

• Python

import sys
import json
import math

input = lambda: sys.stdin.readline().strip()

def calc_entropy(counts):
    """计算给定计数字典的信息熵"""
    total = sum(counts.values())  # 计算总参与度
    entropy_val = 0.0
    
    for cnt in counts.values():
        if cnt > 0:  # 只有参与度大于0才参与计算
            prob = cnt / total  # 计算概率
            entropy_val -= prob * math.log2(prob)  # 累加熵值
    
    return round(entropy_val + 1e-9, 3)  # 避免浮点误差，保留3位小数

def solve():
    data = json.loads(input())  # 解析JSON输入
    result = {}
    
    # 遍历每位员工
    for emp_id, interests in data.items():
        diversity_idx = calc_entropy(interests)  # 计算多样性指数
        result[emp_id] = {"entropy": float(f"{diversity_idx:.3f}")}
    
    # 输出JSON格式结果
    print(json.dumps(result, ensure_ascii=False))

if __name__ == "__main__":
    solve()

• Cpp

#include <