智码云端官网|言若金叶

少儿编程教师认证-题库(基础级)

基础级初级题库 基础级高级题库 在线练习

❀ 基 础 级 初 级 题 库（共12题）❀ 返回最前

试题1：生活指令分解术

【题目描述】

设计一个早餐制作流程模拟程序，根据用户输入的食物名称（包子或面条），输出对应的标准化加热步骤。

【题目要求】

  1. 输入一个字符串，表示早餐食物（仅限”包子”或”面条”）。
  2. 根据食物类型输出相应的制作步骤，步骤需编号。
  3. 输出格式需与示例保持一致，步骤间用换行分隔。

【输出示例】

今天早餐是(包子/面条): 包子
1. 取出包子
2. 加热3分钟
3. 装盘完成！

试题2：课程表生成器

【题目描述】

编写程序，使用多行字符串存储并输出一周课程表，格式需规范对齐。

【题目要求】

  1. 使用三引号字符串存储课程表数据。
  2. 课程表至少包含周一和周二的课程信息。
  3. 输出时需包含标题“我的专属课程表：”。
  4. 课程之间用“|”分隔，各列对齐。

【输出示例】

我的专属课程表：
周一 | 语文 | 数学 | 体育
周二 | 英语 | 科学 | 美术

试题3：求一个数的相反数

【题目描述】

编写程序，输入一个整数，计算并输出其相反数。

【题目要求】

  1. 输入一个整数。
  2. 计算该数的相反数（即符号取反）。
  3. 0的相反数仍为0。
  4. 输出格式为“相反数是: [结果]”。

【输出示例】

请输入一个整数: 7
相反数是: -7

试题4：偶数判断

【题目描述】

设计一个数字奇偶性判断程序，根据输入的整数输出其是否为偶数。

【题目要求】

  1. 输入一个整数。
  2. 使用取模运算判断该数是否能被2整除。
  3. 输出结果为“[数字]是偶数”或“[数字]是奇数”。
  4. 数字需在输出中完整显示。

【输出示例】

请输入一个整数: 8
8是偶数

试题5：智能饮水安全顾问

【题目描述】

根据世界卫生组织饮水建议，设计一个智能饮水安全提示系统，结合水温和运动状态给出个性化饮水建议。

【题目要求】

  1. 输入水温（浮点数）和运动状态（字符串，可选“静坐”“运动”“高强度”）。
  2. 按以下规则输出建议：
    • 水温>50℃ → “烫伤警告！冷却至40℃以下饮用”
    • 水温<10℃且运动状态≠“静坐” → “冰水伤胃，运动后建议常温水”
    • 水温在35-40℃之间 → “黄金水温，及时补充水分”
    • 其他情况 → “水温待优化，建议调节至35-40℃”
  3. 输出语句需完整、明确。

【智能判断逻辑】

# 核心判断结构
if 高温危险:          # >50℃触发安全红线
    紧急降温提示
elif 低温运动风险:     # <10℃且身体活跃状态
    温水饮用建议 
elif 理想水温区间:    # 35-40℃科学饮水温度
    及时补水提示
else:                # 10-34℃或41-49℃
    水温优化建议

【输出示例】

输入输出示例：
当前水温(℃)：8.5  
运动状态(静坐/运动/高强度)：运动  
冰水伤胃，运动后建议常温水

当前水温(℃)：37  
运动状态(静坐/运动/高强度)：高强度  
黄金水温，及时补充水分

试题6：空气污染分级预警系统

【题目描述】

根据PM2.5指数和湿度数据，设计一个空气质量分级预警系统，输出相应的健康防护建议。

【题目要求】

  1. 输入PM2.5指数（整数）和湿度百分比（浮点数）。
  2. 按以下规则输出预警信息：
    • PM2.5>300 或 (PM2.5>200且湿度>80) → “红色预警！停止户外活动”
    • PM2.5>150且湿度>60 → “橙色预警：敏感人群防护”
    • PM2.5>75 → “建议佩戴口罩”
    • 其他 → “空气质量优良”
  3. 输出需简洁明了。

【输出示例】

输入：PM2.5指数：280  
     湿度(%)：82  
输出：红色预警！停止户外活动

输入：PM2.5指数：160  
     湿度(%)：65  
输出：橙色预警：敏感人群防护

试题7：排队照相排列计算器

【题目描述】

编写程序计算10个人站成一排的所有可能排列方式总数，使用阶乘原理实现。

【题目要求】

  1. 使用循环计算10的阶乘（10!）。
  2. 输出计算结果。
  3. 输出格式为“10个人有[结果]种不同的排队方式”。

【输出示例】

10个人有3628800种不同的排队方式

试题8：数字金字塔生成器

【题目描述】

设计一个程序，生成一个9层的数字金字塔，每层由该层编号的数字重复组成。

【题目要求】

  1. 金字塔共9层。
  2. 第n层由数字n重复n次组成。
  3. 每层居中显示，形成金字塔形状。
  4. 使用嵌套循环实现。

【输出示例】

         1
        22
       333
      4444
     55555
    666666
   7777777
  88888888
 999999999

试题9：智能密码锁破解器

【题目描述】

编写程序找出所有符合条件的三位数密码：每位数字不同，且各位数字之和等于12。

【题目要求】

  1. 遍历100-999之间的所有三位数。
  2. 筛选出每位数字不相同且各位数字之和为12的数。
  3. 输出所有符合条件的密码，每行一个。
  4. 使用循环与条件判断实现。

【输出示例】

147
156
165
...
（这里列出的是部分符合条件的多个三位数）

试题10：班级成绩统计员

【题目描述】

设计一个成绩统计程序，计算平均分、最高分、最低分及及格人数。

【题目要求】

  1. 给定一个包含10个成绩的列表。
  2. 计算平均分（保留一位小数）。
  3. 找出最高分和最低分。
  4. 统计及格（≥60分）人数。
  5. 按格式输出所有统计结果。

【输出示例】

成绩列表：[85, 92, 78, 90, 62, 88, 76, 95, 60, 73]
平均分：79.9
最高分：95
最低分：60
及格人数：10

试题11：班级通讯录系统

【题目描述】

设计一个简易通讯录管理系统，支持存储、查找和显示联系人信息。

【题目要求】

  1. 使用字典存储至少5位同学的姓名和电话。
  2. 实现按姓名查找电话的功能。
  3. 实现显示所有联系人的功能。
  4. 输出格式清晰规范。

【输出示例】

所有联系人：
小明：13800138000
小红：13900139000
小刚：13700137000
小丽：13600136000
小强：13500135000

请输入要查找的姓名：小明
小明的电话是：13800138000

试题12：小蜜蜂采蜜记

【题目描述】

模拟小蜜蜂采蜜过程，输出采蜜进度和最终总量。

【题目要求】

  1. 模拟小蜜蜂采集10朵花的过程。
  2. 每采一朵花输出当前采蜜进度。
  3. 采集结束后输出总采蜜量。
  4. 使用循环实现，输出语句需生动形象。

【输出示例】

小蜜蜂开始采蜜！
第1朵花：采集完成
第2朵花：采集完成
第3朵花：采集完成
第4朵花：采集完成
第5朵花：采集完成
第6朵花：采集完成
第7朵花：采集完成
第8朵花：采集完成
第9朵花：采集完成
第10朵花：采集完成
总共采集了10份蜂蜜！

❀ 基 础 级 高 级 题 库（共30题）❀ 返回最前

试题1：购物清单管理系统

【题目描述】

编写一个Python程序，模拟购物清单的创建、查看、修改和删除功能。程序应能对清单中的物品进行增删改查操作，并支持按索引或切片方式访问物品。

【题目要求】

  1. 创建一个空列表用于存储购物物品。
  2. 实现添加物品功能（支持末尾添加与指定位置插入）。
  3. 实现查看物品功能（支持遍历、索引访问和切片）。
  4. 实现修改物品功能（根据索引修改物品名称）。
  5. 实现删除物品功能（支持按索引删除和按值删除）。
  6. 使用循环遍历并输出最终清单。

【输出示例】

欢迎使用购物清单管理小助手！
当前购物清单：[]

添加物品后的购物清单：
['苹果', '鸡蛋', '牛奶', '面包']

购物清单中的物品：
0. 苹果
1. 鸡蛋
2. 牛奶
3. 面包

第一个要买的物品：苹果
前两样物品：['苹果', '鸡蛋']
最后一样物品：面包

修改后的购物清单：['苹果', '鸡蛋', '牛奶', '全麦面包']

删除了：鸡蛋
删除后的购物清单：['苹果', '牛奶', '全麦面包']

再次删除后的购物清单：['苹果', '全麦面包']

最终购物清单：
0. 苹果
1. 全麦面包

试题2：浏览器后退功能模拟系统

【题目描述】

使用栈数据结构模拟浏览器的后退功能。要求实现一个类，支持页面访问记录和后退操作，遵循“后进先出”原则。

【题目要求】

  1. 实现一个BrowserHistory类，包含visit和back方法。
  2. visit方法用于访问新页面，并将当前页面压入栈中。
  3. back方法用于返回上一个页面，并从栈中弹出最近访问的页面。
  4. 若无法后退，应提示用户。
  5. 模拟一系列页面访问和后退操作，并输出每一步的结果。

【输出示例】

当前页面: 智码云端||言若金叶网站首页 www.kidzm.cn
当前页面: 关于我们->联系我们页
当前页面: 关于我们->新闻资讯页
当前页面: 关于我们->管理团队页
当前页面: 关于我们->企业简介页

开始后退操作:
后退到: 关于我们->管理团队页
后退到: 关于我们->新闻资讯页
后退到: 关于我们->联系我们页
后退到: 智码云端||言若金叶网站首页 www.kidzm.cn
无法后退，已在最初页面

试题3：打印机任务调度系统

【题目描述】

使用队列数据结构模拟打印机任务调度过程。任务按照“先进先出”原则依次执行，要求实现任务的添加、打印和队列查看功能。

【题目要求】

  1. 使用collections.deque实现一个任务队列。
  2. 实现add_task方法用于添加打印任务。
  3. 实现print_next方法用于打印队列中的下一个任务。
  4. 实现show_queue方法用于显示当前所有待打印任务。
  5. 模拟多个任务的添加与打印过程，并输出每一步的状态。

【输出示例】

已添加打印任务: 数学作业.pdf
已添加打印任务: 家庭照片.jpg
已添加打印任务: 科学报告.docx
当前打印队列: 数学作业.pdf → 家庭照片.jpg → 科学报告.docx

开始打印任务:
正在打印: 数学作业.pdf
完成打印: 数学作业.pdf
正在打印: 家庭照片.jpg
完成打印: 家庭照片.jpg
正在打印: 科学报告.docx
完成打印: 科学报告.docx
没有待打印的任务

已添加打印任务: 英语作文.doc
正在打印: 英语作文.doc
完成打印: 英语作文.doc

试题4：教室座位表管理系统

【题目描述】

使用二维数组（列表的列表）模拟一个4排5列的教室座位表，实现座位的占用、显示与统计功能。座位状态用0（空）和1（已占）表示。

【题目要求】

  1. 初始化一个4×5的全空座位表。
  2. 实现指定座位的占用功能（例如第2排第3列）。
  3. 以矩阵形式显示当前座位表，区分空位与已占座位。
  4. 统计并输出当前到课学生人数。
  5. 注意行列索引从0开始。

【输出示例】

当前座位表：
空位 空位 空位 空位 空位
空位 空位 已占 空位 空位
空位 空位 已占 空位 空位
空位 空位 空位 空位 空位

今天来了 2 位同学

试题5：单词翻译器

【题目描述】

编写一个简单的英汉单词翻译器。程序预置一个英文单词到中文释义的字典，允许用户输入英文单词查询其中文意思。

【题目要求】

  1. 创建一个字典，包含至少5个英文单词及其对应中文释义。
  2. 程序启动时显示欢迎语和可查询的单词列表。
  3. 接收用户输入的英文单词。
  4. 若单词在字典中，输出其中文释义；否则提示未收录。
  5. 程序应能处理连续查询（本题按单次查询实现即可）。

【输出示例】

欢迎使用小小单词翻译器！
目前我可以翻译这些水果单词：apple, banana, orange, grape, watermelon
请输入你想查的英文单词：apple
apple 的中文意思是：苹果

试题6：好友共同兴趣查找器

【题目描述】

使用集合数据结构，计算并显示你和两位好友的兴趣共同点与差异。程序支持选择一位好友进行比较，输出共同兴趣、所有兴趣以及各自独有的兴趣。

【题目要求】

  1. 为“你”和两位好友分别初始化一个兴趣集合。
  2. 提供菜单让用户选择与哪一位好友进行比较。
  3. 计算并输出：
    • 共同兴趣（交集）
    • 两人所有的兴趣（并集）
    • 你独有的兴趣（差集）
    • 好友独有的兴趣（差集）
  4. 使用集合运算符（&、|、-）实现计算。

【题目说明】

# 定义你和朋友的兴趣集合
your_hobbies = {"篮球", "画画", "编程", "吃披萨"}
friend1_hobbies = {"足球", "编程", "看电影", "吃汉堡"}
friend2_hobbies = {"篮球", "游泳", "编程", "吃披萨"}

【输出示例】

=== 好友兴趣匹配器 ===
请选择要比较的好友：
1. 小明
2. 小红
输入选择(1或2): 2

你和小红的共同兴趣是：{'吃披萨', '编程', '篮球'}
你们所有的兴趣是：{'画画', '吃披萨', '游泳', '篮球', '编程'}
只有你喜欢的：{'画画'}
只有小红喜欢的：{'游泳'}

试题7：图书馆找书系统

【题目描述】

模拟图书馆的图书查找过程。假设图书馆有100本编号连续的书，用户输入想借阅的图书编号，程序使用线性查找算法在列表中寻找该书，并返回其位置或未找到的提示。

【题目要求】

  1. 初始化一个包含1到100的列表，表示图书编号。
  2. 接收用户输入的目标图书编号。
  3. 使用线性查找（顺序遍历）算法在列表中查找该书。
  4. 若找到，输出该书在书架上的位置（从1开始计数）；若未找到，给出相应提示。
  5. 查找过程中使用found标志和position记录结果。

【输出示例】

请输入你想借的书本编号(1-100): 5

找到了！书本编号5在书架的第5个位置。

试题8：字典单词快速查询

【题目描述】

在已按字母顺序排序的单词列表中，使用二分查找算法快速查询某个单词是否存在，并返回其索引位置。

【题目要求】

  1. 初始化一个已排序的单词列表。
  2. 实现binary_search函数，接收单词列表和目标单词，返回其索引（找到）或-1（未找到）。
  3. 在函数中使用左右指针和循环实现二分查找。
  4. 在主程序中调用该函数，根据返回值输出相应的找到或未找到信息。
  5. 注意确保输入列表是有序的。

【单词列表示例】

# 示例使用
dictionary = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape']
word_to_find = 'date'
 
# 必须先确保字典是有序的！
dictionary.sort()  # 虽然这个例子已经有序，但实际使用时需要确保

【输出示例】

找到单词 'date' 了！它在字典的第 4 个位置。

试题9：运动会成绩排行榜

【题目描述】

使用选择排序算法对一组运动会成绩（如50米跑时间）进行从小到大排序，模拟排行榜的生成过程。要求输出每一轮排序后的结果。

【题目要求】

  1. 初始化一个包含至少5个成绩的列表。
  2. 实现selection_sort函数，对输入列表进行选择排序（升序）。
  3. 排序过程中，每确定一个最小值的位置后，输出当前轮次排序后的列表。
  4. 最终输出排序后的最终排行榜。
  5. 要求使用双重循环实现，并交换元素位置。

【成绩示例】

# 运动会50米跑成绩（秒）
scores = [8.5, 7.2, 9.1, 6.8, 7.8, 8.0, 7.5]

【输出示例】

原始成绩: [8.5, 7.2, 9.1, 6.8, 7.8, 8.0, 7.5]
第1轮排序后: [6.8, 7.2, 9.1, 8.5, 7.8, 8.0, 7.5]
第2轮排序后: [6.8, 7.2, 9.1, 8.5, 7.8, 8.0, 7.5]
第3轮排序后: [6.8, 7.2, 7.5, 8.5, 7.8, 8.0, 9.1]
第4轮排序后: [6.8, 7.2, 7.5, 7.8, 8.5, 8.0, 9.1]
第5轮排序后: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]
第6轮排序后: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]
最终排行榜: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]

试题10：班级身高排队系统

【题目描述】

使用冒泡排序算法对班级学生的身高数据进行从矮到高排序，并实现优化：当某一轮没有发生交换时提前终止排序。

【题目要求】

  1. 初始化一个包含至少5个身高数据的列表。
  2. 实现bubble_sort_with_optimization函数，进行升序冒泡排序。
  3. 使用swapped标志优化算法，当一轮未发生交换时提前结束。
  4. 每完成一轮排序，输出当前列表状态。
  5. 最终输出排序后的身高序列。

【输出示例】

原始身高顺序: [155, 160, 148, 172, 165, 158, 163, 170, 168, 150]
第1轮排序后: [155, 148, 160, 165, 158, 163, 170, 168, 150, 172]
第2轮排序后: [148, 155, 160, 158, 163, 165, 168, 150, 170, 172]
第3轮排序后: [148, 155, 158, 160, 163, 165, 150, 168, 170, 172]
第4轮排序后: [148, 155, 158, 160, 163, 150, 165, 168, 170, 172]
第5轮排序后: [148, 155, 158, 160, 150, 163, 165, 168, 170, 172]
第6轮排序后: [148, 155, 158, 150, 160, 163, 165, 168, 170, 172]
第7轮排序后: [148, 155, 150, 158, 160, 163, 165, 168, 170, 172]
第8轮排序后: [148, 150, 155, 158, 160, 163, 165, 168, 170, 172]
最终排序结果: [148, 150, 155, 158, 160, 163, 165, 168, 170, 172]

试题11：扑克牌整理小游戏

【题目描述】

模拟摸牌和理牌过程，使用插入排序的思想，每次摸一张新牌就将其插入到手牌中正确的位置，使手牌始终保持从小到大排列。

【题目要求】

  1. 准备一副数字为1-10的牌并打乱顺序。
  2. 初始化一个空手牌列表。
  3. 循环摸牌：每次从牌堆摸一张牌，找到它在手牌中的正确插入位置并插入。
  4. 每摸一张牌，输出摸到的牌、插入位置和当前手牌状态。
  5. 最终输出整理完成后的手牌。

【输出示例】

开始整理扑克牌！
洗好的牌: [7, 10, 6, 1, 9, 3, 8, 5, 4, 2]

摸到: 2
插入位置: 0
当前手牌: [2]

摸到: 4
插入位置: 1
当前手牌: [2, 4]

摸到: 5
插入位置: 2
当前手牌: [2, 4, 5]

摸到: 8
插入位置: 3
当前手牌: [2, 4, 5, 8]

摸到: 3
插入位置: 1
当前手牌: [2, 3, 4, 5, 8]

摸到: 9
插入位置: 5
当前手牌: [2, 3, 4, 5, 8, 9]

摸到: 1
插入位置: 0
当前手牌: [1, 2, 3, 4, 5, 8, 9]

摸到: 6
插入位置: 5
当前手牌: [1, 2, 3, 4, 5, 6, 8, 9]

摸到: 10
插入位置: 8
当前手牌: [1, 2, 3, 4, 5, 6, 8, 9, 10]

摸到: 7
插入位置: 6
当前手牌: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

整理完成！最终手牌:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

试题12：学校食堂快速分餐系统

【题目描述】

使用快速排序算法对不同班级的学生编号列表进行排序，模拟食堂按班级顺序分餐的优化流程。

【题目要求】

  1. 初始化一个包含多个班级编号的列表（可能有重复）。
  2. 实现quick_sort函数，使用分治策略对列表进行升序排序。
  3. 选择列表中间元素作为基准值（pivot），进行分区操作（左区小于基准，中区等于基准，右区大于基准）。
  4. 递归地对左右分区进行快速排序，并与中区合并返回结果。
  5. 输出排序前后的班级顺序。

【输出示例】

分餐前班级顺序: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
分餐后班级顺序: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

试题13：校园快递最优配送路线

【题目描述】

小明是校园快递站的一名配送员，每天需要从快递站出发，将包裹送到校园各个宿舍楼。校园中有多条道路连接不同的地点，每条道路都有不同的行走时间。请使用Dijkstra算法计算从快递站出发到各宿舍楼的最短路径（时间）及具体路线。

【题目要求】

  1. 使用邻接表（字典）表示校园各地点及其之间的步行时间。
  2. 实现dijkstra函数，使用优先队列（heapq）计算单源最短路径。
  3. 记录每个节点的最短距离和前驱节点。
  4. 实现get_shortest_path函数，根据前驱节点字典回溯出完整路径。
  5. 输出从起点到各目标地点的最短时间和具体路线。

【题目说明】

# 校园地图图表示（邻接表）（单位：分钟）
campus_graph = {
    '快递站': {'食堂': 3, '图书馆': 5},
    '食堂': {'快递站': 3, '图书馆': 1, '教学楼': 2},
    '图书馆': {'快递站': 5, '食堂': 1, '教学楼': 1, '宿舍A': 4},
    '教学楼': {'食堂': 2, '图书馆': 1, '宿舍B': 3},
    '宿舍A': {'图书馆': 4, '宿舍B': 2},
    '宿舍B': {'教学楼': 3, '宿舍A': 2}
}

【输出示例】

从快递站到各宿舍楼的最短配送时间:
到宿舍A: 8分钟
最优路线: 快递站 -> 食堂 -> 图书馆 -> 宿舍A
到宿舍B: 8分钟
最优路线: 快递站 -> 食堂 -> 教学楼A -> 宿舍B

试题14：走迷宫最短步数求解

【题目描述】

在一个字符矩阵表示的迷宫中，使用广度优先搜索（BFS）算法找出从起点‘S’到终点‘E’的最短步数。只能上下左右移动，每次一步，‘#’代表墙壁。

【题目要求】

  1. 定义迷宫地图（二维列表）。
  2. 实现shortest_path函数，使用队列（deque）进行BFS。
  3. 使用visited集合记录已访问位置，避免重复。
  4. 每次从队列取出位置时，检查是否到达终点。
  5. 若找到终点，返回步数；若队列为空仍未找到，返回-1。
  6. 输出最短步数。

【题目说明】

#迷宫地图:
S . . . #
. # # . #
. # # . .
. . . . E
   S代表起点，E代表终点，.代表可通路径，#代表墙壁不能能行

【输出示例】

迷宫地图:
S . . . #
. # # . #
. # # . .
. . . . E

从起点到终点的最短步数是: 7

试题15：校园迷宫寻宝

【题目描述】

在一个4×4的迷宫中，使用深度优先搜索（DFS）回溯算法寻找一条从起点‘S’到宝藏‘T’的路径。‘.’为路，‘#’为墙。

【题目要求】

  1. 定义4×4的迷宫地图。
  2. 实现递归函数find_path，尝试四个方向（上、下、左、右）。
  3. 通过将走过的位置标记为‘x’来避免绕圈。
  4. 若到达终点，记录路径并返回成功；若所有方向都不通，则回溯（恢复标记并从路径中移除当前位置）。
  5. 输出找到的一条路径（位置坐标序列）。

【题目说明】

• S 是起点（入口）
• T 是宝藏（终点）
• . 是可以走的路
• # 是灌木墙，不能走
# 迷宫 4×4 定义如下
maze = [
    ['S', '.', '.', '#'],
    ['.', '#', '.', '.'],
    ['.', '.', '#', '.'],
    ['#', '.', '.', 'T']
]

小明一次只能向上、下、左、右走一步，

【输出示例】

找到了一条路径:
-> (0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (3, 1) -> (3, 2) -> (3, 3)

试题16：村庄光纤铺设成本优化

【题目描述】

在多个村庄之间铺设光纤网络，每条线路有相应成本。使用Kruskal算法找到连接所有村庄且总成本最低的铺设方案。

每条可能的光纤线路及其铺设成本如下：

  • A-B: 2万元
  • A-D: 6万元
  • B-C: 3万元
  • B-D: 8万元
  • B-E: 5万元
  • C-E: 7万元
  • D-E: 9万元

【题目要求】

  1. 使用边列表表示村庄间的连接及成本。
  2. 实现UnionFind类（并查集），支持find和union操作，用于检测环路。
  3. 实现kruskal函数：将边按成本排序，依次选择不会构成环路的边加入最小生成树，直到选中边数达到n-1。
  4. 输出最优铺设方案（边及其成本）和总成本。

【输出示例】

最优光纤铺设方案：
A-B: 2万元
B-C: 3万元
B-E: 5万元
A-D: 6万元
总成本: 16万元

试题17：家族关系查询系统

【题目描述】

构建一个简单的家族树，并实现基于深度优先搜索（DFS）的成员查找功能。树节点包含成员姓名和子节点列表。

【题目要求】

  1. 实现FamilyMember类，包含姓名、子节点列表，以及add_child和find_member方法。
  2. find_member方法使用递归进行DFS查找，打印检查过程。
  3. 构建一个至少三代的家族树。
  4. 调用根节点的find_member方法查找指定成员。
  5. 输出查找过程及结果。

【输出示例】

=== 家族结构 ===
爷爷
  爸爸
    小明
    妹妹
  妈妈

=== 查找家庭成员 ===
正在检查：爷爷
正在检查：爸爸
正在检查：小明
正在检查：妹妹
找到了！妹妹

查找结果：找到 妹妹

试题18：地铁线路查询与图论基础

【题目描述】

模拟一个简单的地铁线路网络，使用邻接矩阵和邻接表两种方式表示图结构，并计算每个站点的连接线路数量（顶点的度）。

【题目要求】

  1. 定义5个地铁站及其名称映射。
  2. 分别用邻接矩阵和邻接表表示给定的地铁连接关系。
  3. 实现calculate_degrees函数，根据邻接矩阵计算每个站点的连接数。
  4. 输出站点信息、邻接矩阵、邻接表以及每个站点的连接数量。
  5. 查询指定站点的连接信息。

【题目说明】

地铁线路示例-假设我们有5个地铁站：
•	0: 动物园站
•	1: 公园站
•	2: 学校站
•	3: 商场站
•	4: 游泳馆站
地铁线路连接如下：
•	动物园站 ↔ 公园站
•	公园站 ↔ 学校站
•	学校站 ↔ 商场站
•	商场站 ↔ 游泳馆站
•	游泳馆站 ↔ 动物园站

【输出示例】

=== 地铁站信息 ===
0: 动物园站
1: 公园站
...

=== 邻接矩阵表示 ===
[0, 1, 0, 0, 1]
[1, 0, 1, 0, 0]
...

=== 每个地铁站的连接线路数量 ===
动物园站: 2条连接线路
...

查询: 学校站的连接信息
学校站 直接连接: 公园站, 商场站

试题19：零钱兑换问题（贪心算法）

【题目描述】

给定一个金额和一组硬币面额，使用贪心算法计算凑出该金额所需的最少硬币数量（假设硬币供应无限）。硬币面额需满足贪心选择性质。

【题目要求】

  1. 实现min_coins_greedy函数，接收金额和硬币面额列表。
  2. 将硬币面额从大到小排序。
  3. 遍历排序后的面额，每次尽可能多地使用当前面额硬币，并更新剩余金额。
  4. 若最终剩余金额为0，返回使用的硬币列表；否则返回None。
  5. 输出凑零钱的方案和硬币总数。

【题目说明】

小明想用最少的硬币数来买价值8元的零食。假设现在有面额为1元、2元和5元的硬币，如何用最少的硬币凑出8元？

【输出示例】

用最少的硬币凑出8元的方法是：[5, 2, 1]
最少需要3个硬币

试题20：小书包装玩具（0/1背包问题）

【题目描述】

在背包容量有限的情况下，从一组物品（各有重量和价值）中选择若干物品装入背包，使得总价值最大。每个物品最多选一次（0/1背包）。分别用动态规划法和贪心法求解，并比较结果。

【题目要求】

  1. 实现动态规划解法knapsack_dp：使用二维DP表，状态dp[i][w]表示前i个物品、容量w下的最大价值。通过状态转移填充表格，并回溯得到所选物品。
  2. 实现贪心解法knapsack_greedy：按价值重量比降序选择物品，直到背包装满。
  3. 给定物品数据（重量、价值）和背包容量，分别调用两种方法。
  4. 输出两种方法得到的最大价值、所选物品及其重量、价值。

【题目说明】

玩具清单：
1.	玩具熊：重量1kg，价值6元
2.	小汽车：重量2kg，价值10元
3.	积木：重量3kg，价值12元
4.	玩偶：重量2kg，价值7元
5.	拼图：重量4kg，价值14元
6.	球：重量1kg，价值5元

【输出示例】

动态规划解法：
最大价值: 23元
选择的玩具: [4, 2, 1]
对应重量: [2, 2, 1]
对应价值: [7, 10, 6]

贪心算法解法：
最大价值: 21元
选择的玩具: [1, 6, 2]
对应重量: [1, 1, 2]
对应价值: [6, 5, 10]

试题21：校园快递派送路径规划（Dijkstra算法实现）

【题目描述】

在一个加权有向图表示的校园地图中，实现Dijkstra算法，计算从快递站出发到其他所有地点的最短配送时间，并输出最短路径。

【题目要求】

  1. 使用邻接表字典表示校园地图（地点为键，值为可达邻居及时间的字典）。
  2. 实现完整的dijkstra函数，使用优先队列（最小堆）优化。
  3. 记录每个地点的最短距离和前驱节点。
  4. 实现print_paths函数，根据前驱节点字典打印从起点到所有其他地点的最短路径及时间。
  5. 输出所有最短路径。

【题目说明】

#用字典构建邻接表，出发点到到达点的时间
campus = {
"快递站": {"图书馆": 5, "食堂": 2},
"食堂": {"教学楼A": 1},
"图书馆": {"教学楼A": 3},
"教学楼A": {"教学楼B": 4},
"教学楼B": {}
}

【输出示例】

从快递站到各教学楼的最短时间：
快递站: 0分钟
食堂: 2分钟
图书馆: 5分钟
教学楼A: 3分钟
教学楼B: 7分钟

从快递站出发的最短路径：
到食堂: 快递站 -> 食堂 (总时间: 2分钟)
到图书馆: 快递站 -> 图书馆 (总时间: 5分钟)
到教学楼A: 快递站 -> 食堂 -> 教学楼A (总时间: 3分钟)
到教学楼B: 快递站 -> 食堂 -> 教学楼A -> 教学楼B (总时间: 7分钟)

试题22：电视节目选择问题（区间调度-贪心算法）

【题目描述】

给定一组电视节目的开始和结束时间，使用贪心算法找出最多能观看多少个互不冲突的完整节目。

【题目要求】

  1. 实现max_programs函数，接收节目列表（每个节目是[start, end]）。
  2. 将节目按结束时间升序排序。
  3. 贪心选择：依次选择结束时间最早且不与已选节目冲突的节目。
  4. 记录并输出选择过程（选择或跳过某个节目）。
  5. 返回并输出最多可观看的节目数量。

【题目说明】

电视节目数量：10个

【输出示例】

=== 测试用例1 ===
排序后的节目表：[[1, 3], [2, 4], [3, 5], [4, 6]]
首先选择节目：[1, 3]，结束时间为：3
跳过节目：[2, 4]（与已选节目时间冲突）
选择节目：[3, 5]，结束时间更新为：5
跳过节目：[4, 6]（与已选节目时间冲突）
最多可以观看 2 个节目

=== 测试用例2 ===
排序后的节目表：[[1, 2], [3, 4], [6, 8], [5, 9], [7, 10]]
首先选择节目：[1, 2]，结束时间为：2
选择节目：[3, 4]，结束时间更新为：4
选择节目：[6, 8]，结束时间更新为：8
跳过节目：[5, 9]（与已选节目时间冲突）
跳过节目：[7, 10]（与已选节目时间冲突）
最多可以观看 3 个节目

试题23：密码强度检查员（字符串动态规划）

【题目描述】

给定一个密码字符串，使用动态规划思想找出其中最长的连续数字子序列的长度。

【题目要求】

  1. 实现find_longest_digits函数，接收密码字符串。
  2. 使用DP数组dp，其中dp[i]表示以第i个字符（索引i-1）结尾的连续数字长度。
  3. 遍历字符串：若当前字符是数字，dp[i] = dp[i-1] + 1；否则dp[i] = 0。同时更新全局最大长度和结束位置。
  4. 根据结束位置回溯得到最长的连续数字子串。
  5. 输出分析过程、最长连续数字及其长度。

【输出示例】

=== 测试用例1：混合字符 ===
分析密码: 'abc123xy4567z'
密码长度: 13

开始检查每个字符...
字符1: 'a'不是数字，重置计数: 0
字符2: 'b'不是数字，重置计数: 0
字符3: 'c'不是数字，重置计数: 0
字符4: '1'是数字，连续计数: 1
字符5: '2'是数字，连续计数: 2
字符6: '3'是数字，连续计数: 3
字符7: 'x'不是数字，重置计数: 0
字符8: 'y'不是数字，重置计数: 0
字符9: '4'是数字，连续计数: 1
字符10: '5'是数字，连续计数: 2
字符11: '6'是数字，连续计数: 3
字符12: '7'是数字，连续计数: 4
字符13: 'z'不是数字，重置计数: 0

发现最长连续数字: '4567' (位置:8-11)
最长连续数字长度: 4

=== 测试用例2：复杂密码 ===
分析密码: 'P@ssw0rd2023!Safe789'
密码长度: 20

开始检查每个字符...
字符1: 'P'不是数字，重置计数: 0
字符2: '@'不是数字，重置计数: 0
字符3: 's'不是数字，重置计数: 0
字符4: 's'不是数字，重置计数: 0
字符5: 'w'不是数字，重置计数: 0
字符6: '0'是数字，连续计数: 1
字符7: 'r'不是数字，重置计数: 0
字符8: 'd'不是数字，重置计数: 0
字符9: '2'是数字，连续计数: 1
字符10: '0'是数字，连续计数: 2
字符11: '2'是数字，连续计数: 3
字符12: '3'是数字，连续计数: 4
字符13: '!'不是数字，重置计数: 0
字符14: 'S'不是数字，重置计数: 0
字符15: 'a'不是数字，重置计数: 0
字符16: 'f'不是数字，重置计数: 0
字符17: 'e'不是数字，重置计数: 0
字符18: '7'是数字，连续计数: 1
字符19: '8'是数字，连续计数: 2
字符20: '9'是数字，连续计数: 3

发现最长连续数字: '2023' (位置:8-11)
最长连续数字长度: 4

=== 空间优化版本测试 ===
密码 'a1b22c333' 的最长数字序列: 3
密码 '123abc456' 的最长数字序列: 3
密码 'no-digits' 的最长数字序列: 0

试题24：智能家居设备网络（图结构应用）

【题目描述】

模拟一个智能家居设备网络，使用图结构（邻接表）表示设备间的连接关系，并实现网络遍历、最短路径查找和连通性检查功能。

【题目要求】

  1. 实现SmartHomeNetwork类，使用defaultdict(list)表示邻接表。
  2. 提供add_device（添加设备）、add_connection（添加双向连接）方法。
  3. 实现bfs_traversal（广度优先遍历）、find_shortest_path（BFS求无权图最短路径）和check_network_connectivity（检查网络是否全连通）方法。
  4. 构建一个包含至少5个设备的网络并添加连接。
  5. 测试并输出BFS遍历顺序、设备间最短路径和网络连通性。

【题目说明】

# 设备名称列表
my_home.add_device('d1', '客厅主灯', 'light')
my_home.add_device('d2', '卧室空调', 'ac')
my_home.add_device('d3', '智能音箱', 'speaker')
my_home.add_device('d4', '门锁', 'lock')
my_home.add_device('d5', '路由器', 'router')

【输出示例】

BFS遍历顺序: ['d5', 'd1', 'd2', 'd3', 'd4']
客厅主灯到门锁的最短路径: ['d1', 'd3', 'd4']
网络是否完全连通: True
断开连接后网络是否连通: True

试题25：巧克力分块比赛（分治算法）

【题目描述】

将一块由N个小方格组成的长条形巧克力全部掰成1×1的小块，每次只能沿直线掰开一块巧克力。使用分治算法计算所需的最少掰断次数。

【题目要求】

  1. 实现递归函数chocolate_breaks，参数为小方格总数n。
  2. 基线条件：当n为1时，返回0（无需再掰）。
  3. 递归关系：将n对半分开（或尽可能接近），当前掰1次加上左右两部分各自需要掰的次数。
  4. 计算并输出掰断不同大小巧克力所需的最少次数。

【输出示例】

4块巧克力需要掰: 3 次
8块巧克力需要掰: 7 次
12块巧克力需要掰: 11 次

试题26：滑动窗口找最甜的3颗糖

【题目描述】

给定一个表示糖果甜度的列表，使用固定大小为3的滑动窗口，找出连续3颗糖甜度总和最高的组合。

【题目要求】

  1. 实现find_sweetest_3candies函数，接收甜度列表。
  2. 若列表长度小于3，返回提示信息。
  3. 计算初始窗口（前3颗糖）的甜度和。
  4. 滑动窗口：每次减去离开窗口的糖果甜度，加上新进入窗口的糖果甜度，更新当前和。
  5. 跟踪最大和及其起始位置。
  6. 输出最甜的3颗糖的起始位置、甜度总和以及具体甜度值。

【输出示例】

例如：糖果甜度：[5, 2, 8, 3, 1]，连续3颗糖的甜度总和：
•	5+2+8=15
•	2+8+3=13
•	8+3+1=12
最高总和是15，对应第1-3颗糖（5, 2, 8）

【输出示例】

最甜的3颗糖是第1-3颗，甜度总和是15，它们是[5, 2, 8]

试题27：图书借阅排行榜（堆排序算法）

【题目描述】

使用堆排序算法，根据图书的借阅次数对图书列表进行降序排序，生成热门图书排行榜

【题目要求】

  1. 实现heap_sort函数，接收图书列表（每个图书是包含name和count键的字典）。
  2. 使用heapq模块构建最小堆，通过将借阅次数取负值来模拟最大堆。
  3. 将所有图书插入堆后，依次弹出堆顶元素，恢复正数后得到降序列表。
  4. 输出原始数据和排序后的排行榜（从高到低）。

【输出示例】

原始图书借阅数据:
Python编程入门: 借阅45次
科学小实验: 借阅78次
动物世界: 借阅32次
童话故事集: 借阅91次
数学趣味题: 借阅56次
历史大发现: 借阅23次

热门图书排行榜(从高到低):
第1名: 童话故事集, 借阅91次
第2名: 科学小实验, 借阅78次
第3名: 数学趣味题, 借阅56次
第4名: Python编程入门, 借阅45次
第5名: 动物世界, 借阅32次
第6名: 历史大发现, 借阅23次

试题28：食堂多窗口打饭调度（负载均衡-最小堆）

【题目描述】

模拟食堂多个打饭窗口的排队调度。使用最小堆数据结构，始终将新来的同学分配到当前排队人数最少的窗口。

【题目要求】

  1. 实现CanteenScheduler类，初始化指定数量的窗口（初始人数为0）。
  2. 使用heapq.heapify将窗口列表转化为最小堆。
  3. add_student方法：弹出堆顶（人数最少的窗口），将其人数加1后重新入堆。
  4. 模拟连续多个同学到来的分配过程，输出每次分配的结果。
  5. 最终输出各窗口的排队人数。

【输出示例】

=== 食堂多窗口打饭调度系统 ===
初始化：有3个打饭窗口，开始都为空

开始模拟同学们来打饭：
第1个同学：新同学分配到原来有0人的窗口，现在有1人
第2个同学：新同学分配到原来有0人的窗口，现在有1人
第3个同学：新同学分配到原来有0人的窗口，现在有1人
第4个同学：新同学分配到原来有1人的窗口，现在有2人
第5个同学：新同学分配到原来有1人的窗口，现在有2人
第6个同学：新同学分配到原来有1人的窗口，现在有2人
第7个同学：新同学分配到原来有2人的窗口，现在有3人
第8个同学：新同学分配到原来有2人的窗口，现在有3人
第9个同学：新同学分配到原来有2人的窗口，现在有3人
第10个同学：新同学分配到原来有3人的窗口，现在有4人

最终各窗口排队人数：[3, 3, 4]

试题29：走楼梯的算法探索（递归算法）

【题目描述】

爬一个n阶的楼梯，每次可以跨1阶或2阶。使用递归算法计算爬到第n阶有多少种不同的走法。

【题目要求】

  1. 实现递归函数climb_stairs，参数为楼梯阶数n。
  2. 基线条件：n == 1时返回1（一种走法）；n == 2时返回2（两种走法：1+1或2）。
  3. 递归关系：爬到第n阶的走法数 = 爬到第n-1阶的走法数 + 爬到第n-2阶的走法数。
  4. 计算并输出爬1到10阶楼梯的走法数。

【生活案例】​

• 1阶 + 1阶 + 1阶
• 1阶 + 2阶
• 2阶 + 1阶

【输出示例】

=== 基础递归版本 ===
爬1阶楼梯有 1 种走法
爬2阶楼梯有 2 种走法
爬3阶楼梯有 3 种走法
爬4阶楼梯有 5 种走法
爬5阶楼梯有 8 种走法
爬6阶楼梯有 13 种走法
爬7阶楼梯有 21 种走法
爬8阶楼梯有 34 种走法
爬9阶楼梯有 55 种走法
爬10阶楼梯有 89 种走法

试题30：迷宫寻宝游戏（回溯算法）

【题目描述】

在一个5×5的数字迷宫中，从起点(0,0)出发，使用回溯算法寻找一条到达宝藏（值为9）的路径。0为道路，1为墙壁，不能重复走。

【题目要求】

  1. 定义迷宫地图（二维列表）。
  2. 实现递归回溯函数find_treasure，参数为当前位置(x, y)和当前路径列表。
  3. 函数需检查边界、墙壁和重复访问。
  4. 若找到宝藏，返回True；否则依次尝试四个方向（右、下、左、上）进行递归探索。
  5. 若所有方向都不通，则回溯（返回False）。
  6. 使用字符图案可视化显示迷宫和探索路径。
  7. 输出完整的探索过程及最终结果。

【题目说明】

关键技巧：使用递归来自动”返回”到上一个位置，用列表记录走过的路径。

# 创建迷宫地图
# 0 = 道路, 1 = 墙壁, 9 = 宝藏
maze = [
[0, 0, 1, 0, 0],
[0, 1, 1, 0, 0],
[0, 0, 0, 0, 0],
[1, 1, 0, 1, 0],
[0, 0, 0, 0, 9]
]

【输出示例】

============================================================
           迷宫寻宝游戏 - 回溯算法大冒险 
============================================================
规则：从起点(0,0)出发，找到宝藏🎁！
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径
============================================================

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

🟦 🟦 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

🚀 开始冒险！从起点 (0, 0) 出发...
============================================================
走到位置 (0, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (0, 1)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 👣 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
← 向左走
↑ 向上走
❌ 位置 (0, 1) 是死路，需要回溯
↓ 向下走
走到位置 (1, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (2, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 1)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 2)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 3)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (3, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 👣 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (4, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 👣 
🟦 🟦 🟦 🟦 👣 

太棒了！找到宝藏啦！
冒险成功！你找到了宝藏！

游戏结束！你学会了回溯算法！