笔试时间：2025年8月29日

往年笔试合集：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

在遥远的神之大陆上，流传着一种神秘的语言，它由两个字符构成——'R'（代表红色魔力）和'B'（代表蓝色魔力）。据说，这种语言的每一个短句都蕴含着无穷的力量。一位名叫"词典癖"的古语法师，发现将一个句子无限循环展开后，会在某些特定区间产生强大的能量波动。他记录下了这些波动，并希望后人能够通过智慧算出任意一段区间中"蓝色魔力"（即字符'B'）的数量。你作为新一代的词律学徒，需要解决这个问题：给定一个只含'B'和'R'的字符串 S，将其无限循环连接形成一个无限长的字符串。然后，统计下标区间 [L, R] 中字符 'B' 的个数。

输入描述

输入共2行。

第一行为一个题目所述的字符串S。

第二行为两个正整数L和R，表示题目中要询问的区间。

输出描述

输出一个数字，表示要求的答案。

样例输入

BBRB

4 8

样例输出

4

参考题解

把无限串看成许多“完整块”（原串 S）加上最后一小段“尾巴”。区间长度 len = R - L + 1：完整块的数量 full = len // n，每块里 'B' 的个数固定为 S.count('B')；余下的 rem = len % n 个字符，从 start = (L - 1) % n 开始截取 rem 长度，可能跨到串首；如果不跨界，直接数 S[start:start+rem] 中的 'B'；跨界则数 S[start:] 与 S[:(start+rem)%n] 两段之和。

C++：

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

// 统计字符串中'B'的数量
int countB(const string &s) {
    int count = 0;
    for (char c : s) {
        if (c == 'B') {
            count++;
        }
    }
    return count;
}

int main() {
    string S;
    int L, R;
    
    // 读取输入
    getline(cin, S);
    cin >> L >> R;
    
    int n = S.length();
    if (n == 0) {
        cout << 0 << endl;
        return 0;
    }
    
    // 计算区间长度（闭区间）
    int length = R - L + 1;
    if (length <= 0) {
        // 非法或空区间
        cout << 0 << endl;
        return 0;
    }
    
    // 完整重复块的贡献
    int cycles = length / n;
    int count_in_cycles = countB(S);
    
    int ans = cycles * count_in_cycles;
    
    // 处理余下的 rem 个字符
    int rem = length % n;
    if (rem > 0) {
        int start = (L - 1) % n;
        int end = start + rem;
        
        if (end <= n) {
            // 不跨界，直接一段数
            ans += countB(S.substr(start, rem));
        } else {
            // 跨界，分两段
            ans += countB(S.substr(start));
            ans += countB(S.substr(0, end % n));
        }
    }
    
    cout << ans << endl;
    return 0;
}

Java：

import java.util.Scanner;

public class CountB {
    // 统计字符串中'B'的数量
    private static int countB(String s) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == 'B') {
                count++;
            }
        }
        return count;
    }
    
    // 统计子字符串中'B'的数量
    private static int countB(String s, int start, int end) {
        int count = 0;
        for (int i = start; i < end; i++) {
            if (s.charAt(i) == 'B') {
                count++;
            }
        }
        return count;
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取输入
        String S = scanner.nextLine().trim();
        int L = scanner.nextInt();
        int R = scanner.nextInt();
        
        int n = S.length();
        if (n == 0) {
            System.out.println(0);
            return;
        }
        
        // 计算区间长度（闭区间）
        int length = R - L + 1;
        if (length <= 0) {
            // 非法或空区间
            System.out.println(0);
            return;
        }
        
        // 完整重复块的贡献
        int cycles = length / n;
        int countInCycles = countB(S);
        
        int ans = cycles * countInCycles;
        
        // 处理余下的 rem 个字符
        int rem = length % n;
        if (rem > 0) {
            int start = (L - 1) % n;
            int end = start + rem;
            
            if (end <= n) {
                // 不跨界，直接一段数
                ans += countB(S, start, end);
            } else {
                // 跨界，分两段
                ans += countB(S, start, n);
                ans += countB(S, 0, end % n);
            }
        }
        
        System.out.println(ans);
        scanner.close();
    }
}

Python：

# 读取输入
S = input().strip()
L, R = map(int, input().split())

n = len(S)
if n == 0:
    print(0)
    raise SystemExit

# 计算区间长度（闭区间）
length = R - L + 1
if length <= 0:
    # 非法或空区间
    print(0)
    raise SystemExit

# 完整重复块的贡献
cycles = length // n
count_in_cycles = S.count('B')

ans = cycles * count_in_cycles

# 处理余下的 rem 个字符（从无限串中 L 的对应位置开始）
rem = length % n
if rem > 0:
    start = (L - 1) % n
    end = start + rem
    if end <= n:
        # 不跨界，直接一段数
        ans += S[start:end].count('B')
    else:
        # 跨界，分两段：S[start:] 和 S[:end % n]
        ans += S[start:].count('B')
        ans += S[:(end % n)].count('B')
print(ans)

第二题

在一个被遗忘的古代文明中，流传着一个传说：只有能拼出“时间之框”的人才能打开通往未来的大门。这个“时间之框”其实是一个正方形的边框，由若干根神秘木棒首尾相连组成，每一根都必须使用一次且仅用一次。你是一位年轻的探险者，在遗迹深处找到了一盒装满木棒的盒子，并在石壁上看到了制作“时间之框”的规则:”若你能用所有木棒拼成一个完美的正方形，则大门将为你开启。“现在你要判断每组木棒是否能满足条件-拼成一个正方形，不能丢弃任何一根木棒。简而言之，题目是：给定若干根长度不同的木棒，请判断是否可以使用所有木棒恰好拼成一个正方形。注意： 所有木棒必须全部使用。 正方形的四条边长度必须完全相同。 木棒不可折断或重叠。

输入描述

输入包含多组测试数据。

第一行是整数 T，表示测试数据组数。

接下来 T 组数据，每组：先给一个整数 n 表示有 n 根木棒，随后给出 n 个正整数 a_i 表示各木棒长度。

输出描述

对于每组数据：若可以用所有木棒恰好拼成一个正方形，输出 yes；否则输出 no。

样例输入

3

1 1

4 1 1 1 1

5 1 1 2 2 2

样例输出

no

yes

yes

参考题解

总长与目标边：设所有木棒长度之和为 sum，若 sum % 4 != 0 或 n < 4则不可能拼成正方形；目标边长 target = sum // 4，若存在木棒 > target，也不可能。排序与状态：将木棒按长度降序排序；用数组 sides[4] 表示四条边当前长度。回溯放置：依次尝试把第 i 根木棒放入某一条边（不超过 target）。空桶剪枝：