✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

01. 小柯的魔法面料

问题描述

小柯是一名服装设计师，她最近发现了一种神奇的面料。这种面料由 的网格组成，每个格子上有三种可能的图案：圆点（.）、星星（*）和爱心（o）。

这种面料的图案会不断变化，同时面料的整体颜色也会随之改变。经过长时间的观察，小柯发现了以下规律：

• 如果面料上只出现 o*o 的图案组合，那么面料会变成蓝色。
• 如果面料上只出现 *o* 的图案组合，那么面料会变成红色。
• 如果面料上同时出现 o*o 和 *o* 的图案组合，或者两者都不出现，那么面料会保持白色。

现在，小柯想请你帮忙判断，给定一种面料的图案，它的颜色会是什么。

输入格式

第一行包含一个正整数 ，表示询问的次数。

接下来对于每组询问，输入三行，每行包含一个长度为 的字符串，表示面料的图案。字符串只包含字符 '.'、'*' 和 'o'。

输出格式

对于每组询问，输出一行，表示面料的颜色：

• 如果面料是蓝色，输出 yukari。
• 如果面料是红色，输出 kou。
• 如果面料是白色，输出 draw。

样例输入

3
...
o*o
...
...
*o*
...
o..
*..
o..

样例输出

yukari
kou
yukari

数据范围

题解

这道题目主要考察字符串处理和模式识别。我们需要在给定的 网格中，检查是否存在特定的图案组合。

关键思路是：

1. 我们需要检查每一行和每一列是否出现了 o*o 或 *o* 的图案组合。
2. 根据题目规则，如果只出现 o*o，面料是蓝色；如果只出现 *o*，面料是红色；如果两者都出现或都不出现，面料是白色。

实现步骤：

1. 首先读取询问次数 。
2. 对于每个询问，读取 网格的图案。
3. 检查每一行是否出现了 o*o 或 *o* 的图案组合。
4. 检查每一列是否出现了 o*o 或 *o* 的图案组合。
5. 根据检查结果，判断面料的颜色并输出。

这种方法的时间复杂度是 ，因为对于每个询问，我们只需要常数时间来检查网格中的图案。空间复杂度也是 ，因为我们只需要存储固定大小的网格和一些辅助变量。

参考代码

• Python

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

def solve():
    # 读取询问次数
    t = int(input())
    
    for _ in range(t):
        # 读取面料图案
        grid = [input() for _ in range(3)]
        
        # 检查是否存在特定组合
        has_blue = False
        has_red = False
        
        # 检查每一行
        for row in grid:
            if row == "o*o":
                has_blue = True
            if row == "*o*":
                has_red = True
                
        # 检查每一列
        for j in range(3):
            col = grid[0][j] + grid[1][j] + grid[2][j]
            if col == "o*o":
                has_blue = True
            if col == "*o*":
                has_red = True
        
        # 判断颜色
        if has_blue and not has_red:
            print("yukari")
        elif has_red and not has_blue:
            print("kou")
        else:
            print("draw")

if __name__ == "__main__":
    solve()

• Cpp

#include 
#include 
#include 
using namespace std;

void solve() {
    int t;
    cin >> t;
    
    while (t--) {
        // 读取面料图案
        vector grid(3);
        for (int i = 0; i < 3; i++) {
            cin >> grid[i];
        }
        
        bool has_blue = false, has_red = false;
        
        // 检查每一行
        for (int i = 0; i < 3; i++) {
            if (grid[i] == "o*o") has_blue = true;
            if (grid[i] == "*o*") has_red = true;
        }
        
        // 检查每一列
        for (int j = 0; j < 3; j++) {
            string col = "";
            col += grid[0][j];
            col += grid[1][j];
            col += grid[2][j];
            
            if (col == "o*o") has_blue = true;
            if (col == "*o*") has_red = true;
        }
        
        // 判断颜色
        if (has_blue && !has_red) {
            cout << "yukari" << endl;
        } else if (has_red && !has_blue) {
            cout << "kou" << endl;
        } else {
            cout << "draw" << endl;
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    return 0;
}

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        sc.nextLine(); // 读取换行符
        
        for (int tc = 0; tc < t; tc++) {
            String[] grid = new String[3];
            for (int i = 0; i < 3; i++) {
                grid[i] = sc.nextLine();
            }
            
            boolean hasBlue = false, hasRed = false;
            
            // 检查每一行
            for (int i = 0; i < 3; i++) {
                if (grid[i].equals("o*o")) hasBlue = true;
                if (grid[i].equals("*o*")) hasRed = true;
            }
            
            // 检查每一列
            for (int j = 0; j < 3; j++) {
                String col = "" + grid[0].charAt(j) + grid[1].charAt(j) + grid[2].charAt(j);
                if (col.equals("o*o")) hasBlue = true;
                if (col.equals("*o*")) hasRed = true;
            }
            
            // 判断颜色
            if (hasBlue && !hasRed) {
                System.out.println("yukari");
            } else if (hasRed && !hasBlue) {
                System.out.println("kou");
            } else {
                System.out.println("draw");
            }
        }
        
        sc.close();
    }
}

02. 小基 的字符串重构

问题描述

小基 是一位勤奋的程序员，她决定对自己以前写的程序进行 debug。

小基 有一个待修复的 bug 列表，用二进制字符串表示。其中第 位为 表示该 bug 已经修复，为 表示该 bug 尚未修复。

小基 有 个修复工具，每个工具能修复的 bug 也用二进制字符串表示。其中第 位为 表示该工具能够修复该 bug，为 表示该工具不能修复该 bug。但是每个工具都有一些副作用，它们会引入新的 bug。工具引入 bug 的情况也用二进制字符串表示，其中第 位为 表示该工具在修复后会引入该 bug。

现在，小基 告诉你她使用工具的顺序，她想知道每使用一个工具后，还会剩下多少个未修复的 bug。

输入格式

第一行输入一个正整数 ，表示 bug 列表的长度。

第二行输入一个长度为 的二进制字符串，表示初始的 bug 列表。

第三行输入一个正整数 ，表示工具的数量。

接下来的 行，每 行描述一个工具：

• 第一行输入一个长度为 的二进制字符串，表示该工具能够修复的 bug。
• 第二行输入一个长度为 的二进制字符串，表示该工具会引入的 bug。

接下来一行，输入一个正整数 ，表示 小基 使用工具的次数。

最后 行，每行输入一个正整数 ，表示 小基 使用了第 个工具。

输出格式

输出 行，每行一个整数，表示使用相应工具后剩余的 bug 数量。

样例输入

4
1101
2
1010
0001
1001
0100
2
2
1

样例输出

1
2

数据范围

保证每个工具能够修复的 bug 和引入的 bug 都不会重复。

题解

这道题目的核心在于理解二进制字符串如何表示bug的状态，以及如何模拟工具修复和引入bug的过程。

首先，我们需要明确几个概念：

1. bug列表是一个二进制字符串，1表示未修复，0表示已修复
2. 工具的修复能力也是一个二进制字符串，1表示能修复，0表示不能修复
3. 工具的副作用也是一个二进制字符串，1表示会引入新bug，0表示不会引入

解题思路如下：

1. 将二进制字符串转换为整数，以便进行位运算
2. 当使用工具修复bug时，如果工具能修复某位置的bug（工具对应位为1），且当前存在该bug（列表对应位为1），则将该位置为0（表示修复）
3. 当引入新bug时，如果工具会引入某位置的bug（副作用对应位为1），则将该位置为1（表示有bug）
4. 每次操作后，统计当前bug列表中1的个数，即为未修复的bug数量

用位运算表达就是：

• 修复bug：bug_list = bug_list & ~(tool_fix & bug_list)，即先找出能被修复的bug，然后从bug列表中去掉
• 引入bug：bug_list = bug_list | tool_introduce，即将新bug添加到列表中

这种方法时间复杂度为O(t)，其中t是操作次数。每次操作都是O(1)的位运算，非常高效。空间复杂度为O(m)，用于存储工具信息。

参考代码

• Python

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

def count_bits(num):
    """计算一个整数的二进制表示中1的个数"""
    count = 0
    while num > 0:
        count += num & 1
        num >>= 1
    return count

def solve():
    n = int(input())  # bug列表长度
    
    # 将二进制字符串转换为整数
    bug_list = int(input(), 2)
    
    m = int(input())  # 工具数量
    tools = []
    
    # 读取每个工具的信息
    for _ in range(m):
        fix = int(input(), 2)