✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

中兴

题目一：小兰的宠物管理系统

1️⃣：使用面向对象设计，定义抽象基类和派生类

2️⃣：利用多态机制统一处理不同类型的宠物

3️⃣：使用哈希表管理宠物对象，数组记录创建顺序

难度：中等

这道题目考查面向对象程序设计的核心概念，包括继承、多态和封装。通过设计抽象基类和具体派生类，可以实现统一的接口来管理不同类型的宠物。关键在于理解多态性的应用和容器的合理使用。

题目二：小基的魔法计算器

1️⃣：使用栈数据结构存储操作数

2️⃣：逐个处理表达式元素，区分数字和运算符

3️⃣：注意运算时操作数的顺序和整数除法的处理

难度：简单

这道题目是经典的后缀表达式求值问题，重点考查栈数据结构的应用。需要掌握栈的基本操作，理解后缀表达式的计算规则，以及正确处理运算符的操作数顺序。算法思路清晰，实现相对简单。

01. 小兰的宠物管理系统

问题描述

小兰是一位热爱动物的软件工程师，她最近收养了许多不同类型的宠物。为了更好地管理这些可爱的小家伙们，她决定开发一个宠物管理系统。该系统需要能够管理不同类型的宠物（如小猫和小狗），并能统一查询它们的状态。

你需要运用所选编程语言的特性，来实现宠物的抽象和具体化，以及统一的状态显示功能。

具体的实现方式应利用你所选编程语言的特性，例如：

• 对于支持面向对象编程的语言（如 C++、Java、Python、C#），应设计抽象基类/接口和具体宠物类，并利用多态性来统一处理宠物。

• 对于 C 语言，可以考虑使用结构体和函数指针来模拟多态行为，或者通过清晰的函数命名约定来管理不同宠物。

输入格式

输入包含多行，模拟对不同宠物的创建和操作。

第一行包含一个整数 ，表示操作的总次数。

接下来的 行，每行描述一个操作。操作类型有四种：

1. ：收养一只小猫。 是字符串， 是 或 。

2. ：收养一只小狗。 是字符串， 是 或 。

3. ：显示指定宠物的状态。

4. ：显示所有已收养宠物的状态。

输出格式

1. 对于每个 操作，输出对应宠物的状态信息。状态格式如下：

   a. 小猫：

   b. 小狗：

2. 如果 的 不存在，则输出 。

3. 对于 操作，按照宠物收养的先后顺序，逐行输出所有宠物的状态信息。

   如果没有宠物，则不输出任何内容。

约束与注意事项：

1. 宠物 的唯一性：系统中每个宠物的 必须是唯一的。如果尝试使用一个已经存在的 收养新宠物，则忽略该收养操作，不输出任何错误信息。

2. 错误处理：

   a. 无效初始状态：如果 操作提供的 不是 或 ，则忽略该收养操作，不输出任何错误信息。

   b. 未知操作类型：如果输入的操作类型不是 或 ，也忽略该操作。

3. 标准库使用：允许使用所选语言的标准库容器来管理宠物，例如 的 或 ， 的 ， 的 等。

样例输入

7
CREATE CAT Fluffy AWAKE
CREATE DOG Buddy HAPPY
DISPLAY Fluffy
DISPLAY Buddy
DISPLAY NonExistentPet
DISPLAY ALL
CREATE CAT Fluffy SLEEPING

6
CREATE CAT Whiskers SLEEPING
CREATE CAT Mittens AWAKE
DISPLAY Mittens
DISPLAY ALL
DISPLAY Whiskers
CREATE DOG Rex UNKNOWN_STATE

样例输出

Cat Fluffy is AWAKE
Dog Buddy is HAPPY
Pet NonExistentPet not found.
Cat Fluffy is AWAKE
Dog Buddy is HAPPY

Cat Mittens is AWAKE
Cat Whiskers is SLEEPING
Cat Mittens is AWAKE
Cat Whiskers is SLEEPING

数据范围

• 
• 宠物 长度不超过 个字符
• 操作数量不超过 次
• 宠物总数不超过 只

题解

这道题本质上是一个面向对象设计题，要求实现一个简单的宠物管理系统。核心思想是使用抽象基类和派生类来表示不同类型的宠物，通过多态机制统一处理。

解题思路：

首先分析题目要求，我们需要管理两种不同的宠物：小猫和小狗，它们有不同的状态表示方式。这是一个典型的面向对象设计场景，适合使用继承和多态。

设计思路：

1. 定义一个抽象基类 Pet，包含宠物的 ID 和一个纯虚函数 getStatus() 用于返回状态信息
2. 派生两个具体类 Cat 和 Dog，分别实现自己的状态逻辑
3. 使用哈希表存储宠物对象，便于快速查找
4. 使用数组记录宠物的创建顺序，用于 DISPLAY ALL 操作

关键技术点：

• 多态性：通过基类指针调用派生类的方法
• 容器管理：使用 unordered_map 实现 O(1) 查找
• 顺序记录：使用 vector 记录创建顺序
• 错误处理：忽略所有非法操作，不输出错误信息

算法的时间复杂度是 O(N)，其中 N 是操作数量。每个操作的时间复杂度都是 O(1)（除了 DISPLAY ALL 需要遍历所有宠物）。空间复杂度是 O(M)，其中 M 是宠物的数量。

这种设计方式可以很容易地扩展到更多类型的宠物，只需要添加新的派生类即可，体现了开闭原则。

参考代码

• Python

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

class Pet:
    """宠物抽象基类"""
    def __init__(self, pid):
        self.pid = pid  # 宠物ID
    
    def get_info(self):
        """获取宠物状态信息的抽象方法"""
        pass

class Cat(Pet):
    """小猫类"""
    def __init__(self, pid, state):
        super().__init__(pid)
        self.awake = (state == "AWAKE")  # True表示醒着，False表示睡觉
    
    def get_info(self):
        """返回小猫的状态信息"""
        status = "AWAKE" if self.awake else "SLEEPING"
        return f"Cat {self.pid} is {status}"

class Dog(Pet):
    """小狗类"""
    def __init__(self, pid, state):
        super().__init__(pid)
        self.happy = (state == "HAPPY")  # True表示开心，False表示伤心
    
    def get_info(self):
        """返回小狗的状态信息"""
        status = "HAPPY" if self.happy else "SAD"
        return f"Dog {self.pid} is {status}"

def solve():
    n = int(input())
    pets = {}  # 存储宠物对象的哈希表
    order = []  # 记录宠物创建顺序
    
    for _ in range(n):
        line = input().strip()
        if not line:
            continue
            
        parts = line.split()
        if not parts:
            continue
            
        cmd = parts[0]
        
        if cmd == "CREATE" and len(parts) >= 4:
            pet_type, pid, state = parts[1], parts[2], parts[3]
            
            # 检查ID是否已存在
            if pid in pets:
                continue
                
            # 创建对应类型的宠物
            if pet_type == "CAT":
                if state in ["AWAKE", "SLEEPING"]:
                    pets[pid] = Cat(pid, state)
                    order.append(pid)
            elif pet_type == "DOG":
                if state in ["HAPPY", "SAD"]:
                    pets[pid] = Dog(pid, state)
                    order.append(pid)
                    
        elif cmd == "DISPLAY" and len(parts) >= 2:
            target = parts[1]
            
            if target == "ALL":
                # 按创建顺序显示所有宠物
                for pid in order:
                    print(pets[pid].get_info())
            else:
                # 显示指定宠物
                if target in pets:
                    print(pets[target].get_info())
                else:
                    print(f"Pet {target} not found.")

if __name__ == "__main__":
    solve()

• Cpp

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

// 宠物抽象基类
struct Pet {
    string id;  // 宠物ID
    virtual string info() const = 0;  // 纯虚函数，获取状态信息
    virtual ~Pet() = default;  // 虚析构函数
};

// 小猫类
struct Cat : Pet {
    bool awake;  // 是否醒着
    
    Cat(const string &pid, const string &state) {
        id = pid;
        awake = (state == "AWAKE");
    }
    
    string info() const override {
        return "Cat " + id + " is " + (awake ? "AWAKE" : "SLEEPING");
    }
};

// 小狗类
struct Dog : Pet {
    bool happy;  // 是否开心
    
    Dog(const string &pid, const string &state) {
        id = pid;
        happy = (state == "HAPPY");
    }
    
    string info() const override {
        return "Dog " + id + " is " + (happy ? "HAPPY" : "SAD");
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n;
    cin >> n;
    cin.ignore();  // 忽略换行符
    
    unordered_map<string, unique_ptr<Pet>> pets;  // 存储宠物对象
    vector<string> order;  // 记录创建顺序
    
    for (int i = 0; i < n; i++) {
        string line;
        getline(cin, line);
        
        if (line.empty()) {
            i--;  // 空行不算操作
            continue;
        }
        
        stringstream ss(line);
        string cmd;
        ss >> cmd;
        
        if (cmd == "CREATE") {
            string type, pid, state;
            ss >> type >> pid >> stat