笔试时间：2025年04月06日

历史笔试传送门：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

题目：序列翻转

给定一个长度为n的二进制数字，你可以选择一个区间[x,y]进行翻转。你的目标是得到一个尽量小的二进制数字。例如下面这个例子中:对于数字11001，你可以选择第一个到第四个位置进行翻转，将11001变成00111。可以证明，这是翻转后可以得到的最小数字。至多进行一次翻转，请你找到最小的二进制数字并输出。

输入描述

第一行一个整数n，描述这个二进制数字的长度。

第二行一个长度为n的二进制数字。

1 ≤ n ≤ 500

输出描述

一个在题目限制下可以得到的长度为n的最小二进制数字。

样例输入

5

11001

样例输出

00111

参考题解

贪心，找到从左到右开始首次出现的'1'，然后枚举从当前1开始往后的每个区间进行翻转，在枚举过程中记录出最小的字符串，即最终答案。

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

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

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

    int n;
    string t;
    cin >> n;
    cin >> t;

    // 找到第一个 '1' 的位置
    int first1 = -1;
    for (int i = 0; i < n; i++) {
        if (t[i] == '1') {
            first1 = i;
            break;
        }
    }

    // 如果字符串中没有 '1'，直接输出原串并退出
    if (first1 == -1) {
        cout << t;
        return 0;
    }

    string res = t;
    // 枚举从 first1 到 i 的每一种反转方案
    for (int i = first1 + 1; i < n; i++) {
        // 先截取 [0, first1) 的前缀
        string prefix = t.substr(0, first1);
        // 再截取 [first1, i] 这段，反转后拼接
        string mid = t.substr(first1, i - first1 + 1);
        reverse(mid.begin(), mid.end());
        // 最后拼接 [i+1, n) 的后缀
        string suffix = (i + 1 < n ? t.substr(i + 1) : "");

        string tmp = prefix + mid + suffix;
        if (tmp < res) {
            res = tmp;
        }
    }

    cout << res;
    return 0;
}

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

// Java 版本
import java.util.Scanner;

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

        int n = Integer.parseInt(sc.nextLine().trim());
        String t = sc.nextLine().trim();

        // 找到第一个 '1' 的位置
        int first1 = -1;
        for (int i = 0; i < n; i++) {
            if (t.charAt(i) == '1') {
                first1 = i;
                break;
            }
        }

        // 如果字符串中没有 '1'，直接输出原串并退出
        if (first1 == -1) {
            System.out.println(t);
            return;
        }

        String res = t;
        // 枚举从 first1 到 i 的每一种反转方案
        for (int i = first1 + 1; i < n; i++) {
            // 前缀 [0, first1)
            String prefix = t.substring(0, first1);
            // 中间 [first1, i]，反转后拼接
            String mid = t.substring(first1, i + 1);
            mid = new StringBuilder(mid).reverse().toString();
            // 后缀 [i+1, n)
            String suffix = (i + 1 < n) ? t.substring(i + 1) : "";

            String tmp = prefix + mid + suffix;
            if (tmp.compareTo(res) < 0) {
                res = tmp;
            }
        }

        System.out.println(res);
    }
}

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

n = int(input())
t = input()
first0 = -1
for i in range(n):
    if t[i] == '1':
        first0 = i
        break
if first0 == -1:
    print(t)
    exit(0)
res = t
for i in range(first0 + 1,n):
    tmp = t[:first0] + t[first0:i + 1][::-1] + t[i+1:]
    if tmp < res:
        res = tmp
print(res)

第二题

题目：修复方程

给出一些仅包含正整数，加号，乘号和等号的方程，请判断这些方程能否通过插入至多一个数位(若原方程成立则可以不插)使得方程成立。插入一个数位即将方程视为一个字符里，并将一个0到9之间的数插入中间，开头或未尾。

输入描述

第一行有一个正整数T(1<=T<=10)，代表方程的数是。

接下来T行，每行均有一个仅包含十进制正整数，加号和乘号的方程。每个方程中均只会包含一个等号。

保证输入的方程合法，即每个数均不含前导要，开头和未尾没有运算符，且没有两个相邻的运算符。

输入中方程两边计算结果的最大值不超过1000000000，且每个方程的长度不超过1000。

输出描述

对于每个方程，若其成立或可以通过往该方程中插入一个数位使得方程成立，则输出Yes，否则输出No。

样例输入

6

16=1+2*3

7*8*9=54

1+1=1+22

4*6=22+2

15+7=1+2

11+1=1+5

样例输出

Yes

Yes

No

Yes

Yes

No

参考题解

模拟，根据数据范围可以暴力枚举并判断，因此枚举插入的数位的位置，去判断等式是否成立即可。可以直接使用python中的eval函数进行判断。在判断过程中要注意使用异常捕捉机制去除掉存在前导0的情况。

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

// C++ 版本
// 说明：因为 C++ 标准库并不自带“eval”函数，这里实现了一个简单的
// 四则运算 + 括号解析器（递归下降法），并手动拆分 “==” 比较或仅计算
// 单侧表达式的值。若解析或计算过程中出现错误（如语法不合法、除以 0），
// 就视作表达式不成立。

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

// 对输入字符串做初始化：去掉所有空格，把每个 '=' 变成 "=="，
// 然后用正则去掉数字前导零（例如 "007" → "7"；单独的 "0" 不影响）。
string init(const string& s_in) {
    // 1) 去掉空格
    string s;
    for (char c : s_in) {
        if (c != ' ') s.push_back(c);
    }
    // 2) 把每个 '=' 都替换为 "=="
    //    （如果原本字符串里有 "=="，就会被替换成 "===="，和 Python 原逻辑一致，
    //     但后续解析时会因语法错导致判定为不合法。）
    string replaced;
    replaced.reserve(s.size() * 2);
    for (char c : s) {
        if (c == '=') {
            replaced += "==";
        } else {
            replaced.push_back(c);
        }
    }
    s = replaced;

    // 3) 用正则 \b0+(\d+)\b 将前导零去掉 (例如 "00123" → "123")。
    try {
        static const regex p(R"(\b0+(\d+)\b)");
        s = regex_replace(s, p, "$1");
    } catch (...) {
        // 如果此环境下正则抛异常，就跳过，让 s 保持原样
    }
    return s;
}

// 对单侧算术表达式做求值，返回 (是否合法, 计算结果)。
// 支持：整数、加减乘除、括号，均为整除运算。若语法错误或除以 0，则 ok=false。
pair<bool, long long> evaluateArithmetic(const string& s) {
    // 用递归下降法解析：
    //   Expr  := Term { (+|-) Term }
    //   Term  := Factor { (*|/) Factor }
    //   Factor:= number | '(' Expr ')'
    //
    // 只允许十进制整数和小括号、不支持一元 + -（原 Python 里如果出现一元 '-'，
    //   在这里会被判为“语法错误”并返回 false；与原 Python eval 有所区别）。
    //
    // 注意：输入中的每个数字已经去掉了前导零（除了单独的 "0"）。
    struct Parser {
        const string& str;
        size_t pos;
        bool ok;

        Parser(const string& s_) : str(s_), pos(0), ok(true) {}

        // 跳过若干空格（理论上 init 后就没有空格了，这里留作保险）
        void skipSpaces() {
            while (pos < str.size() && str[pos] == ' ') {
                pos++;
            }
        }

        /