笔试时间：2025年04月17日

历史笔试传送门：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

题目：输出位数

小红有一个正整数x，当x小于等于5*10^4时，需要算出的x个位数，大于5*10^4时算出的十位数，你需要书写一个程序，计算出来。

输入描述

输入的正整数。

补充说明注:该题为核心模式，不需要自己处理输入输出，代码中的类名、方法名、参数名已经指定，请勿修改，直接书写函数返回方法规定的值即可。

样例输入

12

样例输出

2

参考题解

输出个位数就是x%10，十位数就是(x/10)%10。

C++：[此代码未进行大量数据的测试，仅供参考]

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

// Equivalent of Java's Solution.processNumber
int processNumber(int num) {
    if (num < 50000) {
        return num % 10;
    } else {
        return (num / 10) % 10;
    }
}

int main() {
    int num;
    cin >> num;
    cout << processNumber(num) << "\n";
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

public class Solution {
    public static int processNumber(int num) {
        if (num < 50000) {
            return num % 10;   
        } else {
            return (num / 10) % 10; 
        }
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

# Equivalent of Java's Solution.processNumber

def process_number(num: int) -> int:
    if num < 50000:
        return num % 10
    else:
        return (num // 10) % 10

if __name__ == "__main__":
    num = int(input().strip())
    print(process_number(num))

第二题

题目：圆周率

小红对圆周率的数字很感兴趣，她想知道一个字符串经过重新排序后能否形成的字符串。 请编写一个程序，进行判断。

补充说明注:该题为核心模式，不需要自己处理输入输出，代码中的类名、方法名、参数名已经指定，请勿修改，直接书写函数返回方法规定的值即可。

样例输入

31415

样例输出

true

参考题解

把字符串转成数组后排序，判断两数组是否相等即可。

C++：[此代码未进行大量数据的测试，仅供参考]

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

bool solution(const string &s) {
    string now = s;
    string need = "31415";
    sort(now.begin(), now.end());
    sort(need.begin(), need.end());
    return now == need;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s;
    if (!(cin >> s)) return 0;
    cout << (solution(s) ? "true" : "false") << "\n";
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.*;
public class Solution {
    public static boolean solution(String s) {
        String t = "31415";
        char[] now = s.toCharArray();
        char[] need = t.toCharArray();
        Arrays.sort(now);
        Arrays.sort(need);
        return Arrays.equals(now, need);
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

# Python 3

def solution(s: str) -> bool:
    now = sorted(s)
    need = sorted("31415")
    return now == need

if __name__ == "__main__":
    s = input().strip()
    # print lowercase true/false to match Java's boolean toString
    print(str(solution(s)).lower())

第三题

题目：数位倒置

在 n 行 m 列的网格中，我们使用\((i,j)\)表示网格中从上往下数第i行和从左往右数第j列的单元格，使用\(a_{i,j}\)表示单元格\((i,j)\)的权值，保证权值为非负整数。小红要选择一整行、一整列一共\(n + m - 1\)个单元格，并且希望选中的这些单元格的权值之和是全部选择方案中最大的。然而，小紫会在小红操作前提前选择一行元素，随后，将这一行的这m个元素全部进行数位倒置操作。小红会在小紫操作过后的网格上进行操作。你需要书写一个程序，计算小红可以得到的理论最大值。对于一个非负整数x，将其全部数位从高位到低位重新书写一遍，称为数位倒置。例如 123 进行数位倒置后得到 321，100 进行数位倒置后得到 1，9 进行数位倒置后得到 9。补充说明函数的第一个参数输入一个长度为\(n(1 \leq n \leq 100)\)、宽度为\(m(1 \leq m \leq 100)\)的二维数组a代表网格中每个单元格的权值。保证\((i,j)\)的权值\(a_{i,j}\)满足\((0 \leq a_{i,j} \leq 10^6)\)。注：该题为核心模式，不需要自己处理输入输出，代码中的类名、方法名、参数名已经指定，请勿修改，直接书写函数返回方法规定的值即可。

样例输入

[[1,2,3],[4,5,6],[7,8,9]]

样例输出

33

说明：在这个样例中，由于全部数字均只有个位，所以小紫进行任何操作均不会改变每一个单元格中的权值。

而小红的最优选择是选择第3行和第3列(下标从1开始)，权值之和为3+6+7+8+9=33。

参考题解

模拟即可。不妨预处理出每行每列原本的和，之和枚举要修改的那行，暴力计算出修改之后每行每列和的变化，之和枚举选择的行和列是谁，更新最大值即可。

C++：[此代码未进行大量数据的测试，仅供参考]

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

int reverseInt(int num) {
    string s = to_string(num);
    reverse(s.begin(), s.end());
    return stoi(s);
}

int work(const vector<vector<int>>& a) {
    int n = a.size();
    int m = a[0].size();
    vector<long long> pre_rs(n, 0), pre_cs(m, 0);

    // row sums
    for (int i = 0; i < n; ++i) {
        long long s = 0;
        for (int j = 0; j < m; ++j) {
            s += a[i][j];
        }
        pre_rs[i] = s;
    }
    // column sums
    for (int j = 0; j < m; ++j) {
        long long s = 0;
        for (int i = 0; i < n; ++i) {
            s += a[i][j];
        }
        pre_cs[j] = s;
    }

    long long res = 0;
    // try replacing each cell's row with reversed digits row
    for (int i = 0; i < n; ++i) {
        vector<int> tmp(m);
        for (int j = 0; j < m; ++j) {
            tmp[j] = reverseInt(a[i][j]);
        }
        // new row sum for row i
        long long new_row_sum = accumulate(tmp.begin(), tmp.end(), 0LL);

        // updated column sums when row i is replaced
        vector<long long> now_cs(m);
        for (int j = 0; j < m; ++j) {
            now_cs[j] = pre_cs[j] - a[i][j] + tmp[j];
        }

        // evaluate max over all cells
        for (int r = 0; r < n; ++r) {
            long long row_sum = (r == i ? new_row_sum : pre_rs[r]);
            for (int c = 0; c < m; ++c) {
                long long val = (r == i ? tmp[c] : a[r][c]);
                long long col_sum = now_cs[c];
                res = max(res, row_sum + col_sum - val);
            }
        }
    }
    return (int)res;
}

// Example usage
int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            cin >> grid[i][j];
    co