笔试时间：2025年9月18日

往年笔试合集：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

在数论与趣味数学中，水仙花数（Narcissistic Number/Armstrong Number）是一类自描述的整数。最早的经典定义出现在三位数情形：若一个三位数等于其各位数字立方和，则称其为三位水仙花数。常见的三位水仙花数包括153、370、371、407。

给定一个三位整数n，判断n是否为一个（十进制下的）三位水仙花数。若是，输出YES，否则输出NO。

三位水仙花数：设n的十进制表示为abc（a,b,c为各位数字，且1≤a≤9），当且仅当n=a³+b³+c³成立时，称n为三位水仙花数。

输入描述

输入一个整数n（100≤n≤999）。

输出描述

输出YES或NO，表示n是否为三位水仙花数。

样例输入

153

样例输出

YES

样例说明

153=1³+5³+3³=1+125+27=153，因此输出YES。

参考题解

解题思路：

1. 将三位数n分解为百位a、十位b和个位c
2. 计算a³+b³+c³的值
3. 比较该和是否等于原数n：若相等，则是水仙花数（输出YES）；否则不是（输出NO）

C++：

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int a = n / 100;
    int b = (n / 10) % 10;
    int c = n % 10;
    
    if (n == a*a*a + b*b*b + c*c*c) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    
    return 0;
}

Java：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        
        int a = n / 100;
        int b = (n / 10) % 10;
        int c = n % 10;
        
        if (n == a*a*a + b*b*b + c*c*c) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

Python：

n = int(input().strip())

a = n // 100
b = (n // 10) % 10
c = n % 10

if n == a**3 + b**3 + c**3:
    print("YES")
else:
    print("NO")

第二题

游游手上有一个被污染的符文，这个符文上刻着一个长度为n的字符串s（仅由大小写英文字母构成，下标从0开始）。为了清除污染，Tk将依次执行如下两步操作：

1. 先从左到右（按下标从小到大）依次处理每个位置i上的字符s[i]： 若s[i]为小写字母，则将s[i]替换为其在字母表中的循环前驱；特别地，'a'的循环前驱为'z'；若s[i]为大写字母，则将s[i]替换为其在字母表中的循环后继；特别地，'Z'的循环后继为'A'。
2. 在完成上述所有替换后，再从右到左（按下标从大到小）依次处理每个位置i上的字符s[i]： 若s[i]不是当前最新字符串的最后一个字符，且在当前最新字符串中它右侧紧邻的那个字符与s[i]为同字母异大小写，则删除s[i]；每次删除后，剩余字符按原有先后顺序连接，继续上述判断，直至处理完毕。

请输出游游完成全部操作后得到的字符串。

【名词解释】

• 循环前驱：对小写字母而言，若为'a'则其循环前驱为'z'，否则为其在字母表中的上一个小写字母。
• 循环后继：对大写字母而言，若为'Z'则其循环后继为'A'，否则为其在字母表中的下一个大写字母。
• 同字母异大小写：两个字符在忽略大小写后相同，且一个为小写另一个为大写，例如'a'与'A'。

输入描述

第一行输入一个整数n（1≤n≤100000），表示字符串的长度。 第二行输入一个长度为n的字符串s，由大小写英文字母构成。

输出描述

输出一个字符串，表示最终结果。

样例输入

2

bZ

样例输出

A

样例说明

先从左到右处理：

• 'b'的循环前驱为'a'；
• 'Z'的循环后继为'A'。 然后从右到左处理：
• 'A'和'a'是同字母异大小写，删除'a'。 最终结果为A。

参考题解

解题思路：

1. 第一步：字符转换 小写字母：'a'→'z'，其他减1大写字母：'Z'→'A'，其他加1
2. 第二步：使用栈从右向左处理删除操作，避免O(n²)复杂度 如果栈非空且当前字符与栈顶是同字母异大小写，跳过当前字符否则将当前字符压入栈
3. 最后反转栈得到结果

C++：

#include <iostream>
#include <string>
#include <stack>
#include <algorithm>
using namespace std;

int main() {
    int n;
    string s;
    cin >> n >> s;
    
    // Step 1: Transform characters
    string transformed;
    for (char c : s) {
        if (c >= 'a' && c <= 'z') {
            if (c == 'a') {
                transformed += 'z';
            } else {
                transformed += (char)(c - 1);
            }
        } else if (c >= 'A' && c <= 'Z') {
            if (c == 'Z') {
                transformed += 'A';
            } else {
                transformed += (char)(c + 1);
            }
        }
    }
    
    // Step 2: Process from right to left using stack
    stack<char> stk;
    for (int i = transformed.length() - 1; i >= 0; i--) {
        char c = transformed[i];
        if (!stk.empty() && tolower(c) == tolower(stk.top()) && c != stk.top()) {
            continue;
        } else {
            stk.push(c);
        }
    }
    
    // Build result
    string result;
    while (!stk.empty()) {
        result += stk.top();
        stk.pop();
    }
    
    cout << result << endl;
    return 0;
}

Java：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = sc.next();
        
        // Step 1: Transform characters
        StringBuilder transformed = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (c >= 'a' && c <= 'z') {
                if (c == 'a') {
                    transformed.append('z');
                } else {
                    transformed.append((char)(c - 1));
                }
            } else if (c >= 'A' && c <= 'Z') {
                if (c == 'Z') {
                    transformed.append('A');
                } else {
                    transformed.append((char)(c + 1));
                }
            }
        }
        
        // Step 2: Process from right to left using stack
        Stack<Character> stack = new Stack<>();
        String transformedStr = transformed.toString();
        for (int i = transformedStr.length() - 1; i >= 0; i--) {
            char c = transformedStr.charAt(i);
            if (!stack.isEmpty() && 
                Character.toLowerCase(c) == Character.toLowerCase(stack.peek()) && 
                c != stack.peek()) {
                continue;
            } else {
                stack.push(c);
            }
        }
        
        // Build result
        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }
        
        System.out.println(result.toString());
    }
}

Python：

import sys

def main():
    n = int(sys.stdin.readline())
    s = sys.stdin.readline().strip()
    
    transformed_chars = []
    for char in s:
        if 'a' <= char <= 'z':
            if char == 'a':
                transformed_chars.append('z')
            else:
                transformed_chars.append(chr(ord(char) - 1))
        elif 'A' <= char <= 'Z':
            if char == 'Z':
                transformed_chars.append('A')
            else:
                transformed_chars.append(chr(ord(char) + 1))
    
    transformed_string = "".join(transformed_chars)
    
    stack = []
    for char in reversed(transformed_string):
        if stack and char.lower() == stack[-1].lower() and char != stack[-1]:
            continue
        else:
            stack.append(char)
    
    result = "".join(reversed(st