小信初赛 21 天闯关
厦门市小学生计算机竞赛(C++)初赛 · 21 天打卡体系。全站零输入框, 所有客观题、程序填空一律点选项即时判分,答完自动统计首答正确率。 真题覆盖 2022–2025 四届初赛全部 180 题,另以 GESP C++ 真机考题补足同考点练习, 并附 2 套全真模拟卷(各 45 题 100 分)供冲刺自测。
每天每篇讲义含:① 今日考情 → ② 知识地图(思维导图) → ③ 核心精讲 → 真题演练 → ④ 易错点自测 → ⑤ 今日打卡(可点选清单,勾满即算完成打卡)。 进度自动保存在本机浏览器(localStorage);登录后每次打卡会自动同步到 OJ,老师可以查看全班同学的打卡进度。换设备登录后会重新开始,顶栏「重置进度」可清空重来。
计算机发展与前沿科技时事
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 1 题 | 单项选择 | 1 分 |
| 2022 | 第 2 题 | 单项选择 | 1 分 |
| 2022 | 第 3 题 | 单项选择 | 1 分 |
| 2022 | 第 4 题 | 单项选择 | 1 分 |
| 2022 | 第 5 题 | 单项选择 | 1 分 |
| 2023 | 第 1 题 | 单项选择 | 1 分 |
| 2023 | 第 2 题 | 单项选择 | 1 分 |
| 2023 | 第 3 题 | 单项选择 | 1 分 |
| 2024 | 第 1 题 | 单项选择 | 1 分 |
| 2024 | 第 2 题 | 单项选择 | 1 分 |
| 2024 | 第 3 题 | 单项选择 | 1 分 |
| 2024 | 第 6 题 | 单项选择 | 1 分 |
| 2025 | 第 1 题 | 单项选择 | 2 分 |
| 2025 | 第 2 题 | 单项选择 | 2 分 |
| 2025 | 第 3 题 | 单项选择 | 2 分 |
| 2025 | 第 6 题 | 单项选择 | 2 分 |
难易度:易(★☆☆☆☆) 近 4 年合计:16 题 / 20 分
2026 年备考建议
站在出题人的视角,时事与发展史是整卷最「稳」的分,不需要计算和推理,只看有没有背过,所以命题人爱把它放在卷首当开胃菜,用它保住基础分,再考一两道最新动态区分高下。它又极易和前沿科技组合——光量子、超导量子、开源大模型、火箭回收,随手一挑就是一题。
因此本日不能只背 ENIAC、摩尔定律这些老底子,还要把 2025—2026 年的动态逐条过一遍:四代计算机的核心元件、UNIVAC 面向数据处理、阿帕网才是互联网起源、图灵奖由 ACM 颁发、北斗是导航定位,都要张口就来。
最后记死一句:四大技术里负责存储、加工与处理信息的是计算机技术。
②知识地图 · 本考点思维导图
- 信息技术基础
- 信息的四大特征:依附性 / 可伪性 / 转递性 / 时效性(+共享性)
- 四大主导技术:传感(获取)· 通信(传递)· 计算机(处理·核心)· 网络(共享)
- 计算机发展史
- 里程碑:算盘 → 差分机 → ENIAC → 冯·诺依曼机 → 微处理器 → 互联网 → AI
- 四代划分:电子管 → 晶体管 → 集成电路 → 大规模集成电路
- 关键人物:图灵 · 冯·诺依曼 · 摩尔 · 高德纳 · 姚期智
- 计算机分类与应用
- 分类:巨型机 / 大型机 / 小型机 / 微型机 / 工作站 / 嵌入式
- 应用:科学计算 · 数据处理 · 过程控制 · CAD/CAM · 人工智能 · 网络通信
- 前沿技术速览(8 个必背方向)
- AI 与 LLM(大模型 · AIGC · Agent)
- 量子技术(九章·光量子 / 祖冲之·超导 / 墨子号·量子通信)
- 航天(北斗 · 神舟 · 天问 · 嫦娥 · 天宫)
- 机器人(人形机器人 · 具身智能 · 四足)
- 新型计算(光子 · 类脑 · 超算 · 云计算 · 边缘计算)
- 通信(5G / 6G · 卫星互联网 · 光纤)
- 新一代交互(VR / AR / MR · 脑机接口)
- 新一代信息技术(物联网 · 大数据 · 区块链 · 数字孪生)
- 奖项与荣誉
- 图灵奖(计算机界"诺贝尔奖")· 诺贝尔物理学奖 · 国家最高科学技术奖
- 近期动态(2025—2026)
③核心精讲
3.1 信息与信息技术
信息的四大特征(2022 年第 1 题直接考):
| 特征 | 含义 | 例子 |
|---|---|---|
| 依附性 | 信息必须依附在某种载体上 | 消息要登在报纸上 |
| 可伪性 | 信息可以被加工、篡改 | 谣言、假新闻 |
| 转递性 | 信息可以从一个地方/载体传到另一个 | 二十大消息经报纸广播电视网络传遍全国 |
| 时效性 | 信息的价值随时间变化 | 昨日天气对今天无用 |
| 共享性 | 信息可以多方同时使用而不减少 | 一份课件全班传阅 |
看到「通过…传递给…」「传播到…」「传到千家万户」→ 一律选转递性。
四大主导技术(2022 年第 3 题):
传感技术 → 获取信息(相当于"眼睛耳朵")
通信技术 → 传递信息(相当于"神经网络")
计算机技术 → 存储、加工与处理信息 —— ★是信息技术的核心技术
网络技术 → 信息共享与互联
3.2 计算机发展史(高频)
里程碑时间线
| 时间 | 事件 | 关键点 |
|---|---|---|
| 1946 年 | ENIAC 诞生(宾夕法尼亚大学) | 世界第一台电子计算机,但不是存储程序式 |
| 1945 年 | 冯·诺依曼提出 EDVAC 报告 | 存储程序原理:程序和数据以同等地位存于存储器 |
| 1951 年 | UNIVAC | 第一台商用计算机,面向数据处理 |
| 1969 年 | 阿帕网 ARPANET | 互联网的雏形 |
| 1983 年 | TCP/IP 协议 | 现代互联网真正成型 |
| 1991 年 | 万维网 WWW(蒂姆·伯纳斯-李) | 互联网走向大众 |
| 1971 年 | Intel 4004 微处理器 | 微处理器时代开启 |
四代计算机划分
| 代 | 年代 | 核心元件 | 特点 |
|---|---|---|---|
| 第一代 | 1946–1957 | 电子管 | 体积大、功耗高、速度慢 |
| 第二代 | 1958–1964 | 晶体管 | 体积小、功耗低、可靠性高 |
| 第三代 | 1965–1970 | 集成电路 | 体积进一步缩小,软件出现操作系统 |
| 第四代 | 1971 至今 | 大规模/超大规模集成电路 | 微型化、网络化、智能化 |
关键人物与定律
- 艾伦·图灵:1936 年提出「图灵机」模型,被称「计算机科学之父」「人工智能之父」;图灵测试。
- 冯·诺依曼:存储程序体系结构,现代计算机的理论奠基人。
- 戈登·摩尔:摩尔定律——集成电路上可容纳的晶体管数量约每 18~24 个月翻一番。
- 赫伯特·西蒙:1975 年图灵奖 + 1978 年诺贝尔经济学奖,是著名的「双料」得主(2024 年第 1 题的选项 A)。
3.3 计算机分类与应用
| 按规模/用途分类 | 说明 |
|---|---|
| 巨型机(超算) | 如「神威·太湖之光」「天河」系列,用于气象、核爆模拟 |
| 大型机 / 小型机 | 银行、电信核心业务 |
| 微型机(PC/笔记本) | 最常见 |
| 工作站 | 高性能专业计算 |
| 嵌入式系统 | 家电、汽车、工控中的计算机 |
六大应用领域:科学计算、数据处理(信息管理)、过程控制(实时控制)、计算机辅助(CAD/CAM/CAI)、人工智能、网络通信。
信息技术的热点应用(对应真题的「新名词判断」题): 物联网(智能家居、传感器网络)· 云计算 · 大数据 · 区块链 · 虚拟现实 VR · 增强现实 AR · 混合现实 MR · 人工智能 AI · 数字孪生 · 元宇宙。
3.4 前沿技术:8 个方向速记
| 方向 | 要记住的关键词 |
|---|---|
| 人工智能 | 机器学习 · 深度学习 · 神经网络 · 大语言模型 LLM · AIGC · 智能体 Agent · AGI 通用人工智能 |
| 量子计算 | 光量子:九章系列(潘建伟、陆朝阳团队)/超导量子:祖冲之系列(潘建伟、朱晓波团队) |
| 量子通信 | 「墨子号」量子科学实验卫星;量子密钥分发 QKD,理论上「绝对安全」 |
| 航天 | 北斗导航 · 神舟载人 · 天舟货运 · 天问探火/小行星 · 嫦娥探月 · 天宫空间站 |
| 机器人 | 人形机器人 · 具身智能 · 四足机器狗 · 宇树 Unitree · 工业机器人 |
| 新型计算 | 光子计算 · 神经拟态(类脑)· 超算 · 云计算 · 边缘计算 |
| 通信 | 5G / 6G · 卫星互联网 · 全频段光电融合 |
| 交互 | VR / AR / MR · 脑机接口 BCI |
常见英文缩写对照表(选择题常考「XX 是指」)
| 缩写 | 全称 | 中文 |
|---|---|---|
| AI | Artificial Intelligence | 人工智能 |
| AGI | Artificial General Intelligence | 通用人工智能 |
| LLM | Large Language Model | 大语言模型 |
| AIGC | AI Generated Content | 人工智能生成内容 |
| VR | Virtual Reality | 虚拟现实 |
| AR | Augmented Reality | 增强现实 |
| MR | Mixed Reality | 混合现实 |
| IoT | Internet of Things | 物联网 |
| BCI | Brain-Computer Interface | 脑机接口 |
| QKD | Quantum Key Distribution | 量子密钥分发 |
| HPC | High Performance Computing | 高性能计算 |
| CAD / CAM | — | 计算机辅助设计 / 制造 |
3.5 计算机领域的重要奖项
| 奖项 | 颁发机构 | 地位 |
|---|---|---|
| 图灵奖 | 美国计算机协会 ACM(1966 年设立) | 计算机界的诺贝尔奖,计算机领域最高奖 |
| 诺贝尔物理学奖 | 瑞典皇家科学院 | 2024 年授予霍普菲尔德与辛顿(人工神经网络、机器学习基础性发现) |
| 国家最高科学技术奖 | 中国 | 中国科技界最高荣誉 |
| 冯·诺依曼奖 | IEEE | 计算机科学与工程 |
2024 年图灵奖:安德鲁·巴托(Andrew Barto)与理查德·萨顿(Richard Sutton),表彰强化学习领域的奠基性贡献。
3.6 近期科技动态速览(2025—2026 · 必背)
2025 年——中国十大科技进展(两院院士评选)
- 「人造太阳」EAST 创造「亿度千秒」世界纪录——首次完成 1 亿摄氏度 1066 秒「高质量燃烧」。
- DeepSeek 另辟蹊径推出中国 AI——2025 年 1 月 20 日发布 DeepSeek-R1,性能比肩 OpenAI o1,超低训练成本 + 全面开源;创始人 梁文锋(幻方量化 → 深度求索)。
- 钍基熔盐堆建成——首次实现钍铀核燃料转换。
- 中国肝癌预测系统登《自然》封面(AI 辅助诊断)。
- 「北脑一号」完成首批无线人体全植入——全球首例无线植入式中文语言脑机接口。
- 发现帕金森病原始创新靶点。
- 超导量子计算原型机「祖冲之三号」——105 个可读取比特 + 182 个耦合比特,「量子随机线路采样」速度比最快超算快千万亿倍。
- 新型制氢技术。
- 「黑土粮仓」科技会战。
- 6G 无线通信新突破——超宽带光电融合集成系统,覆盖 0.5 GHz~115 GHz。
其他 2025 大事(央视十大科技新闻)
- 全球首个人形机器人半程马拉松在北京开跑(2025-04-19,20 支队伍)。
- 量子密码「双重加密」:全球首个融合 QKD + 后量子加密算法 PQC 的分布式密码体系,量子密信电话跨 1000 公里接通。
- 嫦娥六号月球样品系列成果首次揭开月球背面演化历史。
- 雅鲁藏布江下游水电工程开工(规模约等于 3 个三峡水电站)。
- 神经拟态类脑计算机「悟空」(Darwin Monkey)——脉冲神经元超 20 亿,接近猕猴大脑规模。
- 福建舰入列——我国第一艘电磁弹射型航母,人民海军进入「三航母时代」。
- 天问二号成功发射——开启小行星探测与采样返回之旅。
- 神舟二十二号应急发射;江门中微子实验正式运行;天舟十号(2026-05)开展世界首次「人工胚胎」空间发育研究。
2026 年最新进展
- 九章四号光量子计算原型机:1024 个量子压缩态输入 8176 个模式,量子优势比达 10⁵⁴。
- 长征十号乙首飞成功,全球首次实现海上网系回收;朱雀三号完成国内首次一子级陆地回收 → 中国可复用火箭体系成形。
- 神舟二十三号(2026-05-24)发射成功,「十五五」阶段首发载人飞船。
- C919 累计交付 41 架;CR450 高速动车组整车试验完成。
- 国产 T1200 级超高强度碳纤维实现规模化量产。
- 全球首款侵入式脑机接口医疗器械获批上市。
- 我国智能算力规模达 2185 EFLOPS;《2026 年全球创新指数》中国拥有 25 个全球百强创新集群,连续四年世界第一。
- 具身智能产业爆发:四足机器人占全球销量份额接近 70%,超 230 家企业发布 400 多款整机产品。
2022年10月16 日上午10时,中国共产党第二十次全国代表大会在北京人民大会堂开幕,这一信息通过报纸、广播、电视、网络等方式传递给寻常百姓。这主要体现了信息具有( )
答案:C
破题点:抓住「通过报纸、广播、电视、网络等方式传递给百姓」——强调的是传递途径。
信息具有依附性(必须依附载体)、可伪性、传递性(可转移/扩散)、时效性、共享性等特征。题干四个分句都在说同一件事:同一信息可以经由多种渠道流传给很多人,对应「转递性」。选 C。
现如今智能家居越来越广泛使用,例如通过手机可开关灯、调节恒温器、开关窗帘、控制洗衣机等,这体现了信息技术中的( )应用。
答案:D
破题点:手机远程控制家电 = 物与物/人与物互联。
物联网(IoT)指把家电、传感器等实物接入网络,实现远程感知与控制。人工智能侧重机器自主学习,云计算侧重算力与存储按需租用,虚拟现实侧重沉浸式模拟。手机开关灯、控窗帘是典型的物联网应用,选 D。
在现代信息处理技术中,传感技术、计算机技术、通信技术和网络技术是主导技术。( )是存储、加工与处理信息的技术,是信息技术的核心技术。
答案:B
破题点:「存储、加工与处理」对应的就是计算机。
信息技术的四大主导技术各有分工:传感技术负责获取信息,通信技术负责传递,网络技术负责互联共享,计算机技术负责存储、加工与处理。题目明说「是信息技术的核心技术」,因此是计算机技术,选 B。
2020年7月31 日,中国向全世界郑重宣告,中国自主建设、独立运行北斗系统全面建成,开启了高质量服务全球、造福人类的崭新篇章。你知道该技术应用属于什么方面的应用?( )
答案:A
破题点:北斗 = 中国自主的卫星导航系统。
北斗卫星导航系统提供定位、导航、授时与短报文通信服务,属于导航定位应用;与区块链(分布式账本)、搜索引擎、数据挖掘无直接关系。选 A。
VR是指( )
答案:C
破题点:VR ← Virtual Reality。
VR = Virtual Reality = 虚拟现实技术。AI = 人工智能,因特网 = Internet。这类英文缩写的送分题必须背熟:VR 虚拟现实、AR 增强现实、AI 人工智能、IoT 物联网、Big Data 大数据、Cloud Computing 云计算。选 C。
中国科学技术大学官网 2023 年 10 月 11 日发布的消息,中国科学技术大学中国科学院量子信息与量子科技创新研究院潘建伟、陆朝阳、刘乃乐等组成的研究团队与中国科学院上海微系统所、国家并行计算机工程技术研究中心合作,成功构建了 255 个光子的量子计算原型机“九章三号”,再度刷新了光量子信息的技术水平和量子计算优越性的世界纪录。中国科学家宣布已成功构建量子计算原型机“九章三号”,求解高斯玻色取样问题的速度比目前全球最快的超级计算机快( )。
答案:D
破题点:「九章三号」核心数据:255 个光子、一亿亿倍。
2023 年 10 月,潘建伟团队构建的 255 光子量子计算原型机「九章三号」,在处理高斯玻色取样问题上比当时全球最快的超级计算机快一亿亿倍。这类时事题的数字要专门记忆,选 D。
北京时间 2023 年 10 月 26 日 11 时 14 分,搭载神舟十七号载人飞船的长征二号 F 遥 十七运载火箭在酒泉卫星发射中心点火发射,约 10 分钟后,神舟十七号载人飞船与 火箭成功分离,进入预定轨道,航天员乘组状态良好,发射取得圆满成功。1992 年9 月,中央决策实施载人航天工程,并确定了中国载人航天“三步走 ”的发展战略,目 前我们正处于哪个阶段?( )
答案:C
破题点:中国载人航天「三步走」:①载人飞船 ②出舱与交会对接、空间实验室 ③建造空间站。
1992 年确定的三步走:第一步发射载人飞船,第二步突破出舱与交会对接、建立空间实验室,第三步建造空间站、解决较大规模长期有人照料的空间应用。2023 年在轨建造空间站,正处于第三步,选 C。
以下和计算机领域密切相关的奖项是( )。
答案:B
破题点:计算机领域的「诺贝尔奖」是图灵奖。
图灵奖由美国计算机协会(ACM)颁发,是计算机科学领域的最高荣誉,被称为「计算机界的诺贝尔奖」。奥斯卡是电影奖,普利策是新闻奖,诺贝尔奖不含计算机学科。选 B。
北京时间 2024 年 10 月 8 日下午 5 点 45 分许,2024 年诺贝尔物理学奖揭晓。( ) 成为了历史上第一位诺贝尔物理学奖和图灵奖双料得主。
答案:B
破题点:「第一位诺贝尔物理学奖 + 图灵奖双料得主」是辛顿。
2024 年诺贝尔物理学奖授予约翰·霍普菲尔德与杰弗里·辛顿,表彰他们在人工神经网络与机器学习方面的奠基性贡献。辛顿早在 2018 年已获图灵奖(与 Bengio、LeCun 共享),因此成为史上第一位「诺贝尔物理学奖 + 图灵奖」双料得主。赫伯特·西蒙是「图灵奖 + 诺贝尔经济学奖」。选 B。
中国科学院、国家航天局、中国载人航天工程办公室于 2024 年 10 月联合发布《国家空间科学中长期发展规划(2024—2050 年)》,规划明确了我国空间科学发展目标,提出我国拟突破的五大科学主题和 17 个优先发展方向,下列选项中不属于“五大科学主题 ” 的是( )
答案:B
破题点:五大主题:极端宇宙、时空涟漪、日地全景、宜居行星、太空格物。
《国家空间科学中长期发展规划(2024—2050 年)》提出五大科学主题:极端宇宙、时空涟漪、日地全景、宜居行星、太空格物。「时空穿越」不在其中,选 B。
量子通信是一种基于量子力学原理进行信息传输的技术,主要特点是它利用量子比特 (qubits)进行数据编码和传输,具有极高的安全性和保密性。在量子通信领域,中国 的突破性成就包括以下哪项? ( )
答案:D
破题点:中国量子通信的标志性成就是「墨子号」量子科学实验卫星。
2016 年发射的「墨子号」是世界首颗量子科学实验卫星,实现了星地量子密钥分发,标志中国在量子通信领域的突破。世界首台量子计算机、商业化、量子激光武器均与事实不符(我国量子计算原型机是「九章」系列,但题干限定在「量子通信领域」)。选 D。
互联网是将全球计算机网络连接起来的技术,它的诞生和发展改变了人们的生活、工 作和娱乐方式,催生了新兴产业和社会现象。互联网起源可以追溯到 20 世纪 60 年代的 ( )。
答案:A
破题点:互联网前身 = 美国的阿帕网(ARPANET,1969)。
ARPANET 于 1969 年由美国国防部高级研究计划局(ARPA)建立,最初连接四所大学,是互联网的前身。万维网(WWW)是 1989 年伯纳斯-李发明的应用层服务,IPv4/IPv6 是网络层协议。选 A。
DeepSeek 是一家专注于通用人工智能(AGI)与大型语言模型(LLM)的创新型科技
公司,其创始人和首席执行官为梁文锋,他的本科及研究生阶段均就读于浙江大学信息
与电子工程学系。2008 年起,他带领团队探索机器学习等技术在全自动量化交易中的应
用,2015 年创立幻方量化,2023 年又创立 DeepSeek,投身于人工智能领域。关于
DeepSeek 2025 年的重要动态,下列描述正确的是( )
答案:B
破题点:DeepSeek:开源、国际化、与国产算力合作。
DeepSeek-R1 是开源模型而非闭源(A 错);2025 年春节期间 DeepSeek 应用登顶中美等多个国家和地区的应用商店,并非仅限国内(C 错);与华为的合作涉及昇腾算力支持而非仅手机端优化(D 错)。DeepSeek-R1-0528 版本在中文评测 SuperCLUE 上表现优异,B 为正确描述。选 B。
宇树科技(Unitree)是中国领先的民用机器人企业,成立于 2016 年,专注于足式
机器人及人形机器人的研发与产业化,凭借全自研核心零部件和运动控制算法,在全球
足式机器人市场占据重要地位,其产品多次亮相春晚、CES 等国内外重大场合。关于中
国机器人企业宇树科技创始人的相关信息,下列描述正确的是( )
答案:D
破题点:宇树创始人王兴兴:大学期间做四足机器人,2016 年创办宇树。
宇树科技创始人王兴兴在上海大学读研期间就研发了四足机器人,这为其创业奠定基础(D 对)。他并非为解决工业机器人成本过高而创业(A 错),也未在华为任职(B 错);首款面向市场的是四足机器人 Laikago 系列,H1 是后来推出的人形机器人(C 错)。选 D。
2025 世界人形机器人运动会是全球首个聚焦人形机器人的综合性竞技赛事,吸引了
16 个国家的 280 支队伍参赛,赛事覆盖田径、舞蹈、足球及工业场景应用等多个项目。
比赛期间,参赛机器人在标志性场馆内完成了 1500 米竞速、原地跳高世界纪录挑战及
5V5 足球赛等精彩赛事。以下关于该运动会举办地的描述,正确的是( )
答案:C
破题点:2025 世界人形机器人运动会 → 中国北京。
2025 世界人形机器人运动会于 2025 年 8 月在北京举办,主场地为国家体育场(鸟巢)与国家速滑馆(冰丝带)。选 C。
下列关于计算机发展史上关键成果的描述,正确的是( )
答案:B
破题点:冯·诺依曼体系结构的核心 = 程序与数据同等地位存储。
「存储程序」思想由冯·诺依曼提出,核心是把程序和数据都以二进制形式同等地位存放在存储器中(B 对)。ENIAC 没有实现存储程序,首次实现存储程序的是 EDVAC/EDSAC(A 错);电子管比晶体管体积大、功耗高(C 错);UNIVAC 是第一台商用计算机,主要用于数据处理而非复杂科学计算(D 错)。选 B。
#include <iostream>
using namespace std;
int main(){
cout << "AI" << 2025 << endl;
cout << 2 + 3 * 4 << endl;
return 0;
}程序运行后第一行输出的内容是( )。
程序运行后第二行输出的内容是( )。
这段程序是用高级语言编写的,需要经过编译(或解释)才能被 CPU 执行。
- 第 1 题B cout 是「流式输出」,默认不加空格、不换行。"AI" 与 2025 依次写入同一行,所以…
- 第 2 题A 先乘后加:3*4=12,再加 2 得 14。乘除取余的优先级高于加减,同级从左到右。…
- 第 3 题A C++ 属高级语言(第三代语言)。CPU 只能执行机器语言,因此高级语言必须先经编译器翻译成…
- 第 1 题A ENIAC 的程序靠外接开关和插线设置,并没有存在机器里,所以它不是存储程序式;存储程序原理的提出者是冯·诺依曼,图灵提出的是图灵机模型。
- 第 2 题C 电子管又大又费电、运行也慢,所以第一代计算机是庞然大物;晶体管正好相反,体积小、功耗低、速度快。
- 第 3 题D 「九章」走光量子路线,「祖冲之」走超导量子路线,二者方向相反,考试最爱把这两个名字对调。
- 第 4 题B UNIVAC 是第一台商用计算机,面向数据处理;为计算弹道等科学计算服务的是第一台电子计算机 ENIAC,两者用途不要记混。
- 第 5 题A 图灵奖由美国计算机协会 ACM 于 1966 年设立,被称为「计算机界的诺贝尔奖」;IEEE 是电气电子工程师学会,最容易和 ACM 记混。
- 第 6 题D 互联网起源于 20 世纪 60 年代(1969 年)的阿帕网 ARPANET;万维网 1991 年才出现,只是互联网上的一项服务,不是起源。
- 第 7 题B 北斗是我国自主研制的卫星导航定位系统,提供定位、导航、授时和短报文服务;它不做搜索和数据挖掘,别被「大数据」类选项带偏。
- 第 8 题C 把家电接入网络、实现物与物、人与物的互联互通,属于物联网应用;人工智能解决的是让机器「会思考」,控制家电本身并不需要它。
- 第 9 题D 四大技术分工不同:传感负责获取、通信负责传递、网络负责共享,只有计算机技术负责信息的存储、加工与处理,是其中的核心技术。
- 第 10 题C 时事素材年年换新,旧真题只能覆盖已考过的内容,必须额外补背 2025—2026 年的动态;这一块纯靠背记就能拿分,放弃很可惜。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 通读讲义 §3.1–3.6,重点背 §3.6「近期科技动态速览」
- 默写计算机四代划分的核心元件:电子管 → 晶体管 → 集成电路 → 大规模(超大规模)集成电路
- 分清「九章三号 = 光量子」「祖冲之三号 = 超导量子」两条技术路线,各抄一遍
- 记住第一台电子计算机是 1946 年的 ENIAC,注明它不是存储程序式;存储程序原理由冯·诺依曼提出
- 记住互联网起源于 1969 年的阿帕网 ARPANET,万维网是 1991 年才出现的
- 记住图灵奖由美国计算机协会 ACM 于 1966 年设立,是计算机界的最高奖
- 背下 2025—2026 两条最新动态:DeepSeek-R1 性能比肩 OpenAI o1、训练成本极低且全面开源;长征十号乙全球首次实现运载火箭一子级海上网系回收
- 完成客观题 14 题(
DAY01-01~DAY01-14) - 完成阅读程序小片段 1 组
本日关键记忆:转递性 · 计算机技术是核心 · ENIAC≠存储程序 · 冯·诺依曼 · 四代元件 · 九章=光量子/祖冲之=超导 · 图灵奖=ACM · 阿帕网 1969 · 2025 DeepSeek/祖冲之三号/福建舰 · 2026 九章四号/长征十号乙海上回收
计算机体系结构与软硬件基础
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 6 题 | 单项选择 | 1 分 |
| 2022 | 第 14 题 | 单项选择 | 2 分 |
| 2022 | 第 15 题 | 单项选择 | 2 分 |
| 2024 | 第 10 题 | 单项选择 | 1 分 |
| 2024 | 第 14 题 | 单项选择 | 2 分 |
| 2024 | 第 17 题 | 单项选择 | 2 分 |
| 2025 | 第 10 题 | 单项选择 | 2 分 |
| 2025 | 第 14 题 | 单项选择 | 2 分 |
| 2025 | 第 18 题 | 单项选择 | 2 分 |
难易度:较易(★★☆☆☆) 近 4 年合计:9 题 / 16 分
2026 年备考建议
站在出题人的视角,体系结构是初赛的计算题担当:位图容量、单位换算、压缩比几乎年年出现,命题人改几个数字就能出一题,答案客观、阅卷省事,性价比极高;它还能和数据范围、编译调试概念串成一条线,出题空间很大。
所以这一块不能只背结论,必须会算:容量 = 宽 × 高 × 色深 ÷ 8,题目问 B 还要再除以 8;16 色对应色深 4 位,256 色才是 8 位;压缩比 5:1 是压缩后为原来的五分之一,要除不要乘;单位一律按 1024。
概念题集中在软件分类和扩展名:操作系统属系统软件,C++ 源文件是 .cpp,mpeg 属视频,编译器只查语法错误。
②知识地图 · 本考点思维导图
- 冯·诺依曼体系结构(五大部件)
- 运算器(ALU)+ 控制器(CU)= CPU
- 存储器:寄存器 → Cache → 内存 → 外存
- 输入设备 / 输出设备
- 硬件基础
- CPU:主频 / 核心数 / 字长 / 缓存
- 存储器:RAM(易失) / ROM(非易失) / 硬盘 / U盘 / 光盘 / 固态
- 存储单位:bit → B → KB → MB → GB → TB → PB
- 输入/输出设备清单
- 软件基础
- 系统软件:操作系统 / 语言处理程序 / 数据库管理系统 / 服务程序
- 应用软件:办公 / 图像 / 浏览器 / 游戏 / 编程工具
- 文件与扩展名
- 图像 / 视频 / 音频 / 文档 / 表格 / 演示 / 压缩 / 源码 / 可执行 / 网页
- 容量计算
- 位图:像素数 × 色深 ÷ 8
- 色深 = log₂(颜色数)
- 音频:采样率 × 量化位数 × 声道数 × 时长 ÷ 8
- 视频:帧率 × 时长 × 分辨率 × 色深 ÷ 8
- 程序生命周期
- 编辑 → 编译 → 链接 → 运行 → 调试(编译型 vs 解释型)
③核心精讲
3.1 冯·诺依曼体系结构:五大部件
┌──────────────────────────┐
│ 存储 器 │ ← 存放程序和数据(同等地位)
└────────┬─────────────────┘
│ 数据/指令
┌─────────────┴──────────────┐
│ CPU = 运算器 + 控制器 │
│ 运算器 ALU:算术与逻辑运算 │
│ 控制器 CU :取指、译码、控制│
└──┬───────────────────────┬─┘
输入设备 输出设备
(键盘/鼠标/扫描仪…) (显示器/打印机/音箱…)
五大部件:运算器、控制器、存储器、输入设备、输出设备。
核心思想(必背原话):程序和数据以同等地位存储在计算机中,计算机自动按顺序取出指令并执行。
CPU 相关概念
| 概念 | 说明 |
|---|---|
| 主频 | 单位 GHz,越高运算越快 |
| 核心数 | 多核可并行处理 |
| 字长 | 一次能处理的二进制位数(32 位 / 64 位) |
| 缓存 Cache | CPU 与内存之间的高速小容量存储器,分 L1/L2/L3 |
| 寄存器 | CPU 内部,速度最快、容量最小 |
3.2 存储体系:速度与容量的反向关系 ★高频
| 层次 | 容量 | 速度 | 价格 | 断电 |
|---|---|---|---|---|
| 寄存器 | 最小(几十字节) | 最快 | 最贵 | 丢失 |
| 高速缓存 Cache | 小(KB~MB) | 快 | 贵 | 丢失 |
| 内存(主存 RAM) | 中(GB) | 中 | 中 | 丢失 |
| 外存(硬盘/U盘/光盘) | 最大(TB) | 最慢 | 最便宜 | 不丢失 |
口诀:越靠近 CPU,速度越快、容量越小、价格越贵。 2025 年第 14 题就考这个:「硬盘 → 内存 → 寄存器」体现的是 速度递增、容量递减。
内存 vs 外存(2022 年第 14 题)
| 对比项 | 内存 | 外存 |
|---|---|---|
| 速度 | 快 | 慢 |
| 容量 | 小 | 大 |
| 断电后 | 数据丢失(易失) | 数据保留 |
| 作用 | 直接与 CPU 交换数据 | 长期保存 |
ROM 与 RAM:RAM 可读可写、断电丢失;ROM 只读(或需特殊方式写入)、断电不丢失,用来存放 BIOS 等固件。
3.3 存储单位换算
1 bit = 1 个二进制位(0 或 1)
1 B(Byte) = 8 bit
1 KB = 1024 B 1 MB = 1024 KB 1 GB = 1024 MB
1 TB = 1024 GB 1 PB = 1024 TB
⚠️ 计算机内部一律按 1024(2¹⁰)换算;硬盘厂商标称容量有时按 1000 计算,所以会出现「买 1 TB 只有 931 GB」的现象。做题时除特别说明,一律用 1024。
3.4 容量计算(必考 · 三类公式)
① 位图(图像)
图像容量(bit) = 水平像素 × 垂直像素 × 色深(位/像素)
图像容量(B) = 上式 ÷ 8
色深 = log₂(颜色数)
压缩后容量 = 原容量 ÷ 压缩比
- 例(2022·15):30 × 20 × 32 = 19200 bit ÷ 8 = 2400 B。
- 例(2025·18):800×600、16 色 → 16 = 2⁴,所以色深 = 4 位;800×600×4 = 1 920 000 bit ÷ 8 = 240 000 B ÷ 1024 = 234.375 KB;压缩比 5:1 → 234.375 ÷ 5 = 46.875 KB。
② 音频
音频容量(B) = 采样率(Hz) × 量化位数(bit) × 声道数 × 时长(s) ÷ 8
- 例:44.1 kHz、16 位、双声道、10 秒 → 44100 × 16 × 2 × 10 ÷ 8 = 1 764 000 B ≈ 1.68 MB。
③ 视频
视频容量(B) = 帧率(fps) × 时长(s) × 分辨率像素数 × 色深(bit) ÷ 8
- 例(2024·17):30 × 10 × 1024 × 768 × 24 ÷ 8 = 707 788 800 B ÷ 1024 ÷ 1024 = 675 MB。
「真彩色 24 位」的含义:每个像素用 3 字节(R/G/B 各 1 字节),可表示 2²⁴ ≈ 1677 万种颜色。
3.5 输入设备与输出设备
| 类别 | 设备 |
|---|---|
| 输入 | 键盘、鼠标、扫描仪、摄像头、麦克风、手写板、光笔、条码/二维码阅读器、触摸屏(兼具输入输出)、游戏手柄 |
| 输出 | 显示器、打印机(针式/喷墨/激光)、音箱、投影仪、绘图仪 |
| 既是输入又是输出 | 触摸屏、硬盘/内存(在「读写」意义上)、网卡 |
3.6 软件的分类
软件
├── 系统软件(管理计算机本身)
│ ├── 操作系统:Windows / macOS / Linux / Android / iOS / 鸿蒙 HarmonyOS
│ ├── 语言处理程序:编译程序、解释程序、汇编程序
│ ├── 数据库管理系统 DBMS
│ └── 服务性程序:诊断程序、调试程序、链接程序
└── 应用软件(解决某个具体问题)
├── 办公类:WPS/Office、PDF 阅读器
├── 图像/音视频类:Photoshop、剪映、播放器
├── 网络类:浏览器、下载工具、聊天软件
└── 开发类:DEV C++、VS Code、Python IDE、OJ 系统
记忆要点:操作系统是系统软件,不是应用软件;语言处理程序(编译器)也属于系统软件。
3.7 常见文件扩展名对照表 ★高频
| 类别 | 扩展名 |
|---|---|
| 图像 | .bmp .jpg/.jpeg .gif .png .tif/.tiff .webp .psd |
| 视频 | .mp4 .avi .mov .wmv .rmvb .flv .mpeg/.mpg |
| 音频 | .mp3 .wav .wma .flac .aac .midi |
| 文档 | .txt .doc/.docx .pdf .md .rtf .wps |
| 表格 | .xls/.xlsx .csv .et |
| 演示文稿 | .ppt/.pptx .dps |
| 压缩包 | .zip .rar .7z .tar .gz |
| 程序源文件 | .cpp .c .h .hpp .py .java .pas |
| 可执行文件 | .exe .com .msi .bat |
| 网页 | .html/.htm .css .js .php |
2024 年第 10 题就考「
mpeg不属于图像」;2025 年第 10 题考「不能用文档软件编辑.zip」。
3.8 程序的编辑、编译、解释与调试 ★
编译型语言 vs 解释型语言
| 编译型(C / C++) | 解释型(Python) | |
|---|---|---|
| 处理方式 | 一次性把源程序整体翻译成机器码再运行 | 边翻译边执行,逐行解释 |
| 生成文件 | 生成 .obj 目标文件 → 链接成 .exe | 不生成可执行文件 |
| 速度 | 运行快 | 运行相对慢 |
| 跨平台 | 差(换平台要重新编译) | 好 |
C++ 程序的完整生命周期
① 编辑 :用编辑器写源代码 game.cpp ← 源文件后缀是 .cpp
② 编译 :翻译成目标代码 game.obj(.o)
③ 链接 :与库函数合并 game.exe
④ 运行 :执行 输出结果
⑤ 调试 :发现并修正错误 断点 / 单步 / 观察变量
错误三分类
| 类型 | 编译器能否发现 | 例子 |
|---|---|---|
| 语法错误 | 能(编译阶段报错) | 少分号、括号不匹配、关键字拼错 |
| 逻辑错误 | 不能 | 把 + 写成 -、循环边界写错 |
| 运行时错误 | 不能(运行时崩溃) | 数组越界、除以 0、栈溢出 |
注意区分「编辑」和「编译」:编辑是写代码(记事本、DEV C++ 的编辑器);编译是把代码翻译成机器能懂的形式。大纲把「编辑/编译/解释/调试」列成同一条,就是要你分清这四个动词。
内存和外存相比,内存的主要特点是( )。
答案:C
破题点:内存 vs 外存:内存快、外存大。
内存(主存)直接与 CPU 交换数据,存取速度快但容量小、断电即失;外存(辅存)容量大、可长期保存但速度慢。A、B 是外存的特点,D 是两者共有的特点。选 C。
一张水平像素 30、垂直像素 20 的 32 位色的位图,存储图像信息所需的空间为( )。(原卷 B、C 两项印刷重复,正确答案以 A 为准)
答案:A
破题点:位图容量 = 水平像素 × 垂直像素 × 每像素位数 ÷ 8。
30 × 20 = 600 个像素;32 位色 = 每像素 4 字节;600 × 4 = 2400B。注意原卷 B、C 两项都印成 1200B(试卷印刷重复),正确答案仍为 2400B。选 A。
下列文件扩展名中个,不属于图像的是( )
答案:A
破题点:看扩展名认文件类型:图像 = jpeg / bmp / png。
jpeg、bmp、png 都是图像格式;mpeg(.mpg/.mpeg)是视频压缩格式,属于视频文件。选 A。
在存储器中,访问速度最快的是( )。
答案:D
破题点:存储体系速度排序:寄存器 > 缓存 > 内存 > 外存。
访问速度从快到慢:CPU 寄存器 → 高速缓存(Cache)→ 内存 → 外存(硬盘/U盘)。题目问「最快」,答案是寄存器。选 D。
一部 30 帧每秒,共 10 秒,分辨率为 1024*768,24 位真彩色的短视频,若未经压缩, 所需的存储空间为( )
答案:B
破题点:视频容量 = 宽 × 高 × 每像素字节 × 帧率 × 秒数。
1024 × 768 = 786432 像素;24 位真彩色 = 3 字节/像素;每帧 786432 × 3 = 2359296B ≈ 2.25MB;30 帧/秒 × 10 秒 = 300 帧;2.25MB × 300 = 675MB。选 B。
下列文件操作中,不能通过文件扩展名直接判断可行性的是( )。
答案:C
破题点:扩展名要与软件用途匹配。
.png 用图像软件打开、.avi 用视频软件播放、.py 用代码编辑器打开都可行;.zip 是压缩包格式,文档软件无法直接编辑,需要先解压。选 C。
计算机执行程序时,数据从硬盘加载到内存,再从内存加载到 CPU 寄存器,这一过
程体现了存储体系的( )特性。
答案:A
破题点:存储器层次:越靠近 CPU 越快越小。
硬盘 → 内存 → CPU 寄存器,这条路径上速度不断提高、容量不断减小,这正是存储体系「速度递增、容量递减」的分层特性。选 A。
一幅分辨率为 800×600 的 16 色图像(每个像素用 4 位表示),经压缩比为 5:1
的算法压缩后,存储该图像需要的空间约为( )。
答案:A
破题点:先算原始大小,再除以压缩比。
16 色 = 4 位 = 0.5 字节/像素;800 × 600 = 480000 像素;原始大小 = 480000 × 0.5 = 240000B = 234.375KB;压缩比 5:1,压缩后 = 234.375 ÷ 5 = 46.875KB。选 A。
以下哪个 C++源代码文件命名是正确的?( )
答案:D
破题点:C++ 源文件扩展名 = .cpp。
C++ 源程序文件的标准扩展名是 .cpp(也有 .cc/.cxx,但考题只认 .cpp)。.c 是 C 语言源文件,.cbb 与 .c++ 都不是合法扩展名。选 D。
以下不属于计算机输入设备的有( )。
答案:B
输入设备负责「把信息送进电脑」。键盘、鼠标、传感器都是输入设备;音箱是输出设备。答案 B。
在Windows 系统中通过键盘完成对选定文本移动的按键组合是先Ctrl+X,移动到目标位置后按Ctrl+V。
答案:A
Ctrl+X 剪切、Ctrl+V 粘贴是 Windows 通用快捷键,说法正确。答案 A(正确)。
高级语言编写的程序需要经过以下( )操作,可以生成在计算机上运行的可执行代码。
答案:D
高级语言 → 编译 → 可执行代码。编译(compile)把源代码翻译成机器能执行的二进制。答案 D。
C++代码中while(1){...} 的判断条件不是逻辑值,将导致语法错误。( )
答案:B
C++ 中「非 0 即真」,while(1) 是完全合法的写法,不会语法错误。答案 B(错误)。
#include <iostream>
using namespace std;
int main(){
cout << sizeof(int) << " ";
cout << sizeof(char) << " ";
cout << sizeof(double) << endl;
return 0;
}程序输出为( )。
一个容量为 1KB 的存储空间,最多可以存放 ______ 个 int 型整数。(1KB = 1024B)
sizeof 运算符返回的是某个类型或变量所占的位数。
- 第 1 题A 32/64 位环境下 int 占 4 字节、char 占 1 字节、double 占 8 字…
- 第 2 题256 1024 ÷ 4 = 256(个)。存储容量题的通用做法:先把容量换成 B,再除以单个元素的…
- 第 3 题B sizeof 返回的是**字节数**(byte),不是位数。1 字节 = 8 位,所以 si…
- 第 1 题B 位图容量的原始结果是 bit,而 1 B = 8 bit,所以题目要 B 就必须再除以 8;除以 1024 是 B 转 KB 时才做的事。
- 第 2 题D 16 色是 2⁴,所以色深 4 位;256 色才是 2⁸ 即 8 位,把 16 色当成 16 位是最常见的错法。
- 第 3 题A 压缩比 5:1 表示压缩后与压缩前的容量之比为 1:5,算容量要除以 5;把比值反过来乘 5 是典型错误。
- 第 4 题C 存储单位一律按 2¹⁰ = 1024 换算,1 KB = 1024 B;用 1000 是把十进制单位混进了二进制存储单位。
- 第 5 题B 速度顺序是寄存器 > 高速缓存 Cache > 内存 > 外存,与容量大小正好相反;Cache 比寄存器慢但比内存快,位置最容易记错。
- 第 6 题A 内存是易失性的,断电即丢;要长期保存数据必须靠外存,外存容量更大但速度更慢。
- 第 7 题C 操作系统负责管理硬件和软件资源,属于系统软件;应用软件是 Word、浏览器这类面向具体任务的程序。
- 第 8 题D C++ 源文件是 .cpp,.c 是 C 语言的源文件;.obj 是编译产生的目标文件,.exe 是链接后的可执行文件。
- 第 9 题A .mpeg 是视频格式,.bmp、.png、.jpg 都是图像格式;名字里带「m」不代表图片,别按字母猜。
- 第 10 题C 编译器只管语法是否合法,程序「语法没错但算错了」属于逻辑错误,只能靠运行结果和调试排查;少写分号属于语法错误。
- 第 11 题D 编辑就是敲代码、改代码;把源程序翻译成机器码是编译,链接和运行又是另外的环节,几个词最容易混为一谈。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 通读讲义,重点记 §3.2 存储体系、§3.4 容量计算、§3.7 扩展名表
- 默写位图容量公式:宽 × 高 × 色深 ÷ 8,并算出 100×200 的 24 位真彩色图像未压缩时占 60000 字节
- 记住色深对照:16 色 = 4 位、256 色 = 8 位,并会用 2ⁿ 反推色数
- 写出存储器速度排序:寄存器 > 高速缓存 > 内存 > 外存,并标出「内存易失、外存可长期保存」
- 背下软件分类:操作系统属于系统软件,Word、浏览器一类属于应用软件
- 抄写常见扩展名对照:图像 .bmp/.jpg/.png,视频 .mp4/.avi/.mpeg,并记住 C++ 源文件是 .cpp
- 说清 C++ 程序从编写到运行的四个阶段:编辑 → 编译 → 链接 → 运行,并区分「编译器只查语法错误、逻辑错误靠调试」
- 完成客观题 13 题(
DAY02-01~DAY02-13) - 完成阅读程序小片段 1 组
本日关键记忆:五大部件 · 程序=数据同等存储 · 寄存器>Cache>内存>外存 · 1B=8bit/1024进制 · 容量=像素×色深÷8 · 16色=4位 · 压缩比 = 除以 · .cpp 才是 C++ 源文件 · 操作系统是系统软件
进制转换与信息编码
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 12 题 | 单项选择 | 2 分 |
| 2022 | 第 18 题 | 单项选择 | 2 分 |
| 2022 | 第 21 题 | 填空题 | 3 分 |
| 2023 | 第 9 题 | 单项选择 | 1 分 |
| 2023 | 第 14 题 | 单项选择 | 2 分 |
| 2023 | 第 15 题 | 单项选择 | 2 分 |
| 2023 | 第 21 题 | 填空题 | 3 分 |
| 2024 | 第 7 题 | 单项选择 | 1 分 |
| 2024 | 第 8 题 | 单项选择 | 1 分 |
| 2024 | 第 9 题 | 单项选择 | 1 分 |
| 2024 | 第 20 题 | 单项选择 | 2 分 |
| 2024 | 第 21 题 | 填空题 | 3 分 |
| 2025 | 第 7 题 | 单项选择 | 2 分 |
| 2025 | 第 8 题 | 单项选择 | 2 分 |
| 2025 | 第 9 题 | 单项选择 | 2 分 |
| 2025 | 第 20 题 | 单项选择 | 2 分 |
难易度:中等(★★★☆☆) 近 4 年合计:16 题 / 31 分
2026 年备考建议
站在出题人的视角,进制转换是「方法固定、答案唯一」的题型,命题人最爱拿它填填空的三个空——错一步后面全错,区分度拉满;它还能顺手带出原码反码补码、ASCII 和容量折算,一条线串下来能出好几题,所以从未缺席。
因此这一块没有捷径,必须算到形成肌肉记忆:除基取余倒着读,乘基取整正着读,二进制转十六进制四位一组、最左边补 0,小数点右侧从左往右分组。补码要背死:负数「原码 → 数值位取反 → 加一」,符号位一动不动;−128 只有补码,没有原码和反码。
再记一句:8 位补码的范围是 −128 ~ 127。
②知识地图 · 本考点思维导图
- 四种常用进制
- 二进制 B(0-1)八进制 O(0-7)十进制 D(0-9)十六进制 H(0-9,A-F)
- 进制转换四类
- 任意 → 十进制:按权展开相加
- 十进制 → 任意:整数除基取余(倒读)、小数乘基取整(正读)
- 二进制 ↔ 八进制:三位一组
- 二进制 ↔ 十六进制:四位一组
- 小数的进制转换
- 机器数编码
- 原码 / 反码 / 补码
- ★补码:取反加一;计算机内部一律用补码
- 字符编码
- ASCII(128 / 扩展 256)
- 汉字编码 GB2312 / GBK / UTF-8
- Unicode
- 存储单位与容量换算(bit→B→KB→MB→GB→TB)
③核心精讲
3.1 四种进制与「权」的概念
| 进制 | 基数 | 数字符号 | 后缀写法 |
|---|---|---|---|
| 二进制 | 2 | 0 1 | 1101B 或 0b1101 |
| 八进制 | 8 | 0–7 | 1760O |
| 十进制 | 10 | 0–9 | 2022D |
| 十六进制 | 16 | 0–9 A–F | 7E6H 或 0x7E6 |
十六进制对照表(必背)
| 十 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 十六 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
| 二 | 0000 | 0001 | 0010 | 0011 | 0100 | 0101 | 0110 | 0111 | 1000 | 1001 | 1010 | 1011 | 1100 | 1101 | 1110 | 1111 |
「权」的概念:从右往左数第 k 位(从 0 起)的权 = 基数^k。
二进制 1 1 0 1
权 2³ 2² 2¹ 2⁰
值 8 4 2 1 → 8+4+0+1 = 13
2 的幂次速查(强烈建议背熟)
| 2⁰ | 2¹ | 2² | 2³ | 2⁴ | 2⁵ | 2⁶ | 2⁷ | 2⁸ | 2⁹ | 2¹⁰ |
|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 |
3.2 进制转换四大方法
方法 ① 任意进制 → 十进制:按权展开相加
例:二进制 111101 → 十进制 32 + 16 + 8 + 4 + 0 + 1 = 61 (2023·14 答案 D)
例:八进制 2024 → 十进制 2×8³ + 0×8² + 2×8¹ + 4×8⁰ = 1024 + 0 + 16 + 4 = 1044(2024·21 答案)
方法 ② 十进制 → 任意进制:整数「除基取余、倒着读」
例:十进制 1008 → 八进制(2023·21)
1008 ÷ 8 = 126 …… 余 0 126 ÷ 8 = 15 …… 余 6 15 ÷ 8 = 1 …… 余 7 1 ÷ 8 = 0 …… 余 1余数从下往上读:1 7 6 0 → 答案 1760
例:十进制 2022 → 十六进制(2022·21)
2022 ÷ 16 = 126 …… 余 6 126 ÷ 16 = 7 …… 余 14 → E 7 ÷ 16 = 0 …… 余 7倒读:7 E 6
方法 ③ 二进制 ↔ 八进制:三位一组(从小数点向两侧分组,不足补 0)
二进制
1 101 011→ 补成001 101 011→1 5 3→ 八进制 153
方法 ④ 二进制 ↔ 十六进制:四位一组 ★最常用
二进制
110 1011→ 补成0110 1011→6 B→ 十六进制 6B反过来:十六进制
7E6→0111 1110 0110→ 二进制11111100110
为什么用这两招? 因为 8 = 2³、16 = 2⁴,二进制与它们之间是「整数倍分组」的关系,所以二进制 ↔ 十六进制不用经过十进制,直接四位一组即可,又快又准。
3.3 小数的进制转换
二进制小数 → 十进制:小数点后第 k 位的权 = 2⁻ᵏ
0.101₂ = 1×0.5 + 0×0.25 + 1×0.125 = 0.625₁₀
十进制小数 → 二进制:小数部分乘 2 取整,正着读
0.625 × 2 = 1.25 → 取 10.25 × 2 = 0.5 → 取 00.5 × 2 = 1.0 → 取 1正读:0.101
二进制小数 → 十六进制(2024·9):仍按四位一组,但方向是从小数点向右分组
0.01₂→ 补零成0.0100₂→ 四位一组 =0100=4→ 0.4₁₆(答案 C)
3.4 原码、反码、补码 ★必考
为什么需要补码? 计算机只能做加法。为了让「减法」变成「加一个负数」,人们设计了补码——这样 A − B 可以直接写成 A + (−B) 的补码,硬件只需要一个加法器。
以 8 位二进制为例:
| 编码 | 正数 | 负数(以 −7 为例) |
|---|---|---|
| 原码 | 符号位 0 + 数值 | 符号位 1 + 数值:1000 0111 |
| 反码 | 与原码相同 | 符号位不变,其余各位取反:1111 1000 |
| 补码 | 与原码相同 | 反码 +1:1111 1001 ← 2023·15 答案 B |
从补码求真值(逆向操作):符号位是 1 → 说明是负数 → 整体取反加一,得到绝对值,前面加负号。
例(2025·20):
1110 0110→ 符号位 1 → 取反0001 1001= 25 → +1 = 26 → 真值 −261111 0010→ 取反0000 1101= 13 → +1 = 14 → 真值 −14 x + y = −26 + (−14) = −40(答案 B)
例(2024·20):把三个十六进制数当 8 位补码比大小
FA=1111 1010→ 取反0000 0101=5 → +1=6 → −6F6=1111 0110→ 取反0000 1001=9 → +1=10 → −107F=0111 1111→ 符号位 0,是正数 → +127 所以 127 > −6 > −10,即 z > x > y(答案 D)
8 位补码的表示范围
最小:1000 0000 = −128
最大:0111 1111 = +127
范围:−128 ~ 127(共 256 个数)
n 位补码范围公式:−2ⁿ⁻¹ ~ 2ⁿ⁻¹ − 1
| 位数 | 范围 |
|---|---|
| 8 位 | −128 ~ 127 |
| 16 位(short) | −32768 ~ 32767 |
| 32 位(int) | −2147483648 ~ 2147483647 |
⚠️ 注意「−128 没有原码和反码」。所以补码能比原码多表示一个数。
3.5 ASCII 码 ★必背
ASCII(美国信息交换标准码)用 7 位二进制表示 128 个字符(2022·18、2024·8 都考这个点)。
必背关键值
| 字符 | 十进制 | 十六进制 |
|---|---|---|
| 空格 | 32 | 20 |
'0' | 48 | 30 |
'9' | 57 | 39 |
'A' | 65 | 41 |
'Z' | 90 | 5A |
'a' | 97 | 61 |
'z' | 122 | 7A |
三条规律
- 数字 < 大写字母 < 小写字母(48 < 65 < 97)。
'0'~'9'、'A'~'Z'、'a'~'z'各自连续递增,所以可以用减法求字母序号:
'D' − 'A' = 3(D 是第 4 个字母,从 0 起数)'m' − 'a' = 12
- 大小写转换:
'a' − 'A' = 32(差 32,第 6 位翻转)。
2023·9:
'8'=56、'm'=109、'g'=103、'G'=71 → 最大是m。 2025·8:第 2 字节0001 0100= 20 → 第 20 个(从 1 起数)大写字母是 T。
扩展 ASCII:用 8 位表示 256 个字符。
3.6 汉字编码与 Unicode
| 编码 | 说明 |
|---|---|
| GB2312 | 国标简体中文,一个汉字占 2 字节 |
| GBK | GB2312 的扩展,兼容更多汉字 |
| UTF-8 | 国际通用变长编码,一个汉字通常占 3 字节,一个英文字母占 1 字节 |
| Unicode | 统一码,为全世界所有字符编号(码点) |
常考对比:一段含 10 个汉字的文本,GB2312/GBK 下占 20 字节;UTF-8 下占 30 字节。
3.7 单位与容量折算(2025·9 的考法)
1 B = 8 bit 1 KB = 1024 B 1 MB = 1024 KB 1 GB = 1024 MB
2025·9:十六进制
40= 4×16 + 0 = 64 字节 → 64 ÷ 1024 = 0.0625 KB(答案 A)关键是先做一次进制转换(十六进制 → 十进制),再做一次单位换算。两步都不能省。
3.8 用「二进制思想」解题(新题型)
近两年出题人喜欢把进制包装成故事,但本质不变:
2024·7 烽火台:权值从右到左 1、2、4、8;点燃记 1,未点燃记 0。 → 这就是二进制按权展开,把 1/0 序列读成二进制数再转十进制即可(答案 10)。
2025·7 古埃及「十进制累加计数法」:
|=1、∩=10、⊕=100、□=1000。 符号串□⊕⊕∩∩∩||→ 1000 + 100 + 100 + 30 + 2 = 1232 → 转十六进制 4D0(答案 A)。2025·8 自定义双字节编码:第 1 字节最高位定大小写,第 2 字节给序号。
0100 0001 0001 0100→ 第 1 字节最高位 0 → 大写;第 2 字节 = 20 → 第 20 个字母 T。
破题套路:遇到「新奇的计数/编码系统」,先问自己三个问题—— ① 每一位的权是多少?② 有几种符号,也就是基数是多少?③ 问的是哪个进制的结果?
二进制数1101011 加上二进制数101,运算结果转换成十进制是多少?( )
答案:D
破题点:先做二进制加法,再转十进制。
1101011₂ = 107;101₂ = 5;107 + 5 = 112。也可直接二进制相加:1101011 + 101 = 1110000₂ = 64+32+16 = 112。选 D。
标准ASCII码(American Standard Code forInformationInterchange,美国信息交换标准码)使用二进制数组合来表示( )种可能的字符,包括大写和小写字母、数字0~9、标点符号,以及在美式英语中使用的特殊控制字符。
答案:B
破题点:标准 ASCII(7 位)= 2⁷ = 128 个字符。
标准 ASCII 用 7 位二进制编码,可表示 2⁷ = 128 个字符;扩展 ASCII 才用 8 位、表示 256 个字符。题目明确说「标准 ASCII」,选 B。
二进制数 111101 转换成十进制是多少?( )
答案:D
破题点:按权展开:111101₂ = 32+16+8+4+1。
111101₂ = 32 + 16 + 8 + 4 + 0 + 1 = 61。选 D。
原码、反码和补码是计算机中用来表示带符号整数的三种编码方式,它们在计算机内部的运算和表示过程中发挥重要作用。对于 8 位二进制来说,-7 的补码是( )
答案:B
破题点:负数补码 = 原码取反加 1。
-7 用 8 位表示:绝对值 7 = 00000111(原码 10000111)→ 取反得 11111000 → 加 1 得 11111001。注意 8 位补码范围是 -128~127。选 B。
在下列字符中,其 ASCII 码值最大的一个是( )
答案:B
破题点:ASCII 大小:数字 < 大写字母 < 小写字母。
ASCII 码值:'0'~'9' 是 48~57,'A'~'Z' 是 65~90,'a'~'z' 是 97~122。四者中 'm' = 109 最大。选 B。
计算机中,有符号整数常用补码表示,变量 x,y,z 中分别存储着 FA,F6,7F(都为16进制), 他们的大小关系应该是( )。
答案:D
破题点:先看最高位判断正负,再比大小。
FA₁₆ = 11111010₂,最高位为 1 是负数;F6₁₆ = 11110110₂,也是负数;7F₁₆ = 01111111₂,最高位 0,是正数 127。负数中绝对值越大值越小:FA 的补码对应 -6,F6 对应 -10,故 -6 > -10。所以 z > x > y,选 D。
通讯不发达的年代,常利用烽火台传递有多少城镇正在求援。每座烽火台都有他所代 表的值,从右到左,分别代表 1,2,4,8。若烽火台点燃,则用 1 标记;未点燃,则用0 标记。现烽火台点燃情况如下图所示,则共有( )城镇需要救援。
答案:C
破题点:烽火台 = 二进制权值 1、2、4、8。
从右到左权值 1、2、4、8,点燃记 1、熄灭记 0,拼出的是一个 4 位二进制数。若图形显示 1010₂ → 8+2 = 10。按官方答案,该图对应十进制 10,即 10 座城镇需要救援。选 C。
ASCII码是美国国家交换标准代码,可表示 128 个不同字符,计算机内至少需要( ) 位二进制编码来表示。
答案:B
破题点:2ⁿ ≥ 128,求最小 n。
要区分 128 个不同字符,需要 2ⁿ ≥ 128。2⁷ = 128,所以至少 7 位二进制。注意 8 位是扩展 ASCII 才需要的。选 B。
与二进制小数 0.01对应的十六进制数是( )
答案:C
破题点:每 4 位二进制对应 1 位十六进制。
二进制小数 0.01₂ = 2⁻² = 1/4 = 0.25。十六进制的 0.4 = 4/16 = 0.25。所以对应十六进制数 0.4。选 C。
若 8 位有符号整数 x 的补码为 11100110(二进制),8 位有符号整数 y 的补码为
11110010(二进制),则 x+y 的十进制值是( )。
答案:B
破题点:补码相加直接按二进制算,再翻译成十进制。
11100110 + 11110010 = 1 1101 1000,丢掉溢出位得 1101 1000。这是负数:取反得 0010 0111 = 39,加 1 得 40,所以原值是 -40。选 B。
古埃及采用 “十进制累加计数法”,使用特殊符号表示不同量级:“|” 代表 1,
“∩” 代表 10,“⊕” 代表 100,“□” 代表 1000;计数时,相同量级的符号并列
累加(如 30 表示为 “∩∩∩”),不同量级从左到右按 “千→百→十→个” 排列。
则符号组合 “□⊕⊕∩∩∩||” 对应的十六进制数是( )
答案:A
破题点:先按符号数量还原十进制,再转十六进制。
□ = 1000,⊕⊕ = 200,∩∩∩ = 30,|| = 2,合计 1000 + 200 + 30 + 2 = 1232。十进制 1232 → 十六进制:1232 ÷ 16 = 77 余 0;77 ÷ 16 = 4 余 13(D);4 ÷ 16 = 0 余 4。从下往上读得 4D0。选 A。
某编码系统采用双字节编码(每个字符用 2 个字节表示),每个字节由 8 位二进制
组成,且规定:第 1 个字节的最高位为 0 时表示大写字母,为 1 时表示小写字母;第
2 个字节用于区分具体字符,其中大写字母 "A" 对应 "00000001","B" 对应
"00000010",…,依次递增;小写字母 "a" 对应 "00000001","b" 对应 "00000010",…,
依次递增。则编码 "01000001 00010100" 对应的字符是( )
答案:A
破题点:第 1 字节最高位定大小写,第 2 字节定第几个字母。
双字节编码中,第 1 字节最高位为 0 表示大写、为 1 表示小写;第 2 字节的数值决定是第几个字母(A/a 对应 00000001)。按官方答案推得该字符为大写字母表中第 20 个字母 T(A=1 → T=20)。选 A。
某智能设备的存储空间以十六进制数 “40” 表示剩余容量(单位:字节),若需将
其转换为十进制的“KB”单位,则下列结果正确的是( )
答案:A
破题点:先十六进制转十进制,再换单位。
40₁₆ = 4 × 16 = 64 字节。64B ÷ 1024 = 0.0625KB。选 A。
十进制数 2022 转化为十六进制数为:( )
答案:7E6 或 7e6
破题点:除 16 取余,从下往上读。
2022 ÷ 16 = 126 余 6;126 ÷ 16 = 7 余 14(E);7 ÷ 16 = 0 余 7。从下往上读得 7E6。大小写均可,写成 7e6 也对。答案:7E6(或 7e6)。
十进制数 1008 转化为八进制数为:( )
答案:1760
破题点:除 8 取余,从下往上读。
1008 ÷ 8 = 126 余 0;126 ÷ 8 = 15 余 6;15 ÷ 8 = 1 余 7;1 ÷ 8 = 0 余 1。从下往上读得 1760。验算 1×512 + 7×64 + 6×8 + 0 = 512 + 448 + 48 = 1008 ✓。答案:1760。
八进制数 2024 转化为十进制数为: ( )
答案:1044
破题点:按权展开:2024₈ = 2×512 + 0×64 + 2×8 + 4。
2 × 8³ + 0 × 8² + 2 × 8¹ + 4 × 8⁰ = 1024 + 0 + 16 + 4 = 1044。答案:1044。
#include <iostream>
using namespace std;
int main(){
int n = 45;
cout << n % 2;
n = n / 2;
cout << n % 2;
cout << n / 2 << endl;
return 0;
}程序输出为( )。
十进制数 45 转换成二进制数是 ______。
十进制数 45 转换成十六进制数是 ______。(字母用大写)
- 第 1 题A 逐步跟踪:n=45 时 45%2=1 输出「1」,n 变为 22;22%2=0 输出「0」,…
- 第 2 题101101 短除法:45÷2=22 余 1,22÷2=11 余 0,11÷2=5 余 1,5÷2=2 余…
- 第 3 题2D 45 ÷ 16 = 2 余 13,13 记为 D,从下往上读得 2D。也可先转二进制 101…
- 第 1 题B 除基取余得到的是低位在前、高位在后,必须从最后一个余数倒着读;正着读会得到完全颠倒的结果。
- 第 2 题A 小数部分乘基取整得到的是高位在前,要正着读;这与整数部分的「倒着读」正好相反,最容易记混。
- 第 3 题C 二进制转十六进制是「从右往左四位一组」,最左边一组不足四位要在最左边补 0;在右边补 0 会改变整个数的大小。
- 第 4 题D 小数点右侧要从小数点开始从左往右分组、不足四位在末尾补 0;右侧照搬「从右往左」是典型错法。
- 第 5 题C 原码求反码只对数值位取反,符号位保持不变;「全部取反再加一」是从补码求相反数时才用的操作。
- 第 6 题D 求绝对值要「取反再 +1」,只取反不加一会比真值小 1;顺序颠倒成「先加一再取反」也是错的。
- 第 7 题D 8 位原码和反码的数值位只有 7 位,表示不出 128,所以 −128 只有补码 10000000,它是 8 位补码能表示的最小负数。
- 第 8 题A 顺序是数字 < 大写字母 < 小写字母,对应 '0'=48、'A'=65、'a'=97;大小写相差 32,大写反而比小写小。
- 第 9 题B A=10、B=11、C=12、D=13、E=14、F=15,十六进制里没有 16 这个数字,容易整体记错一位。
- 第 10 题B 64 ÷ 1024 = 0.0625 KB,单位换算一律用 1024 而不是 1000;用 1000 会算成 0.064 KB,是常见的错项。
- 第 11 题C 这类题常先用二进制推理,最后一步要求换成指定进制,漏掉「再转一次」就白算了;题干要求什么进制就必须以什么进制作答。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 通读讲义,动手把 §3.2 的四道例题各算一遍
- 用除基取余法把十进制 255 转成十六进制(答 FF),并写出「余数倒着读」的完整过程
- 用四位一组法把二进制 11110011 转成十六进制(答 F3),并说明最左边不足四位要补 0
- 演算 −7 的 8 位补码三步过程:原码 10000111 → 反码 11111000 → 补码 11111001
- 默写 8 位补码的表示范围 −128 ~ 127,并注明 −128 只有补码、没有原码和反码
- 背下 '0'=48、'A'=65、'a'=97 三个 ASCII 值,并按「数字 < 大写 < 小写」排序
- 对比一段 10 个汉字的文本在 GBK 下占 20 字节、在 UTF-8 下占 30 字节,并把十六进制 40 折算成 64 B 与 0.0625 KB
- 背熟:2 的幂次表、十六进制对照表、ASCII 三个关键值、补码三步法
- 完成客观题 12 题(
DAY03-01~DAY03-12) - 完成阅读程序小片段 1 组
本日关键记忆:按权展开 · 除基取余(倒读)· 四位一组 ↔ 十六进制 · 补码 = 取反 +1 · −128~127 · ASCII 48/65/97 · 数字<大写<小写 · 1KB = 1024B · 新题型先问「权、基数、目标进制」
计算机网络与信息安全
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 11 题 | 单项选择 | 2 分 |
| 2023 | 第 5 题 | 单项选择 | 1 分 |
| 2024 | 第 19 题 | 单项选择 | 2 分 |
| 2025 | 第 19 题 | 单项选择 | 2 分 |
难易度:较易(★★☆☆☆) 近 4 年合计:4 题 / 7 分
2026 年备考建议
站在出题人的视角,网络与信息安全属于「记忆集中、几乎不用推理」的板块,命题人喜欢用一两道题考几个缩写和一次 IP 判断。考点很稳定——网络分类、交换机与路由器、DNS 与 DHCP、子网掩码、病毒特征,年年翻来覆去。
因此要记牢几组易混对:LAN 局域网、MAN 城域网、WAN 广域网,范围从小到大;交换机连接局域网内部,路由器连接不同网络;DNS 负责域名解析,DHCP 负责自动分配 IP;SMTP 发信,POP3/IMAP 收信。判 IP 还要看每段是否在 0~255。
再记一句:病毒五大特征是传染、潜伏、隐蔽、破坏、可触发,最本质的是传染性。
②知识地图 · 本考点思维导图
- 网络基础
- 定义与功能:资源共享(硬件/软件/数据)+ 数据通信
- 分类(按范围):局域网 LAN → 城域网 MAN → 广域网 WAN
- 拓扑结构:星型 / 总线型 / 环型 / 网状
- 网络硬件:网卡 / 交换机 / 路由器 / 调制解调器 / 传输介质
- 网络协议
- TCP/IP(互联网的基础协议)
- HTTP / HTTPS(网页)· FTP(文件)· SMTP/POP3(邮件)
- DNS(域名解析)· DHCP(自动分配 IP)
- IP 地址与域名
- IPv4:32 位,点分十进制,4 段,每段 0–255
- 子网掩码:判断是否同一网段
- IPv6:128 位
- 域名:www.xxx.com.cn(从右到左级别降低)
- 互联网简史
- 1969 ARPANET → 1983 TCP/IP → 1991 万维网 → 1994 中国全功能接入
- 信息安全
- 计算机病毒(5 大特征)
- 木马 / 蠕虫 / 钓鱼 / 勒索软件
- 防护:防火墙 · 杀毒软件 · 系统更新 · 强密码 · 数据备份
- 法律法规与信息道德(著作权 · 网络安全法 · 个人信息保护)
③核心精讲
3.1 计算机网络是什么
定义:把地理上分散的、具有独立功能的多台计算机,通过通信线路和设备连接起来,在协议控制下实现资源共享和数据通信的系统。
三大功能
| 功能 | 说明 |
|---|---|
| 资源共享 | 硬件(打印机、存储)、软件、数据共享 |
| 数据通信 | 电子邮件、即时通讯、文件传输 |
| 分布式处理 | 把大任务分给多台计算机协作完成 |
3.2 网络的分类 ★
按覆盖范围分类(最常考)
| 类型 | 英文缩写 | 覆盖范围 | 典型例子 |
|---|---|---|---|
| 局域网 | LAN(Local Area Network) | 一个房间 / 一栋楼 / 一个校园(几十米~几公里) | 学校机房、家庭 WiFi、企业内网 |
| 城域网 | MAN(Metropolitan Area Network) | 一座城市(约 10~100 公里) | 城市有线电视网 |
| 广域网 | WAN(Wide Area Network) | 跨城市、跨国家 | 互联网、电信骨干网 |
口诀:Local 局域网,Metropolitan 城域网,Wide 广域网。范围由小到大:LAN < MAN < WAN。
按拓扑结构分类
| 拓扑 | 特点 | 优缺点 |
|---|---|---|
| 星型 | 所有节点连到中心设备 | 好管理;中心一坏全网瘫痪 |
| 总线型 | 共用一条主干线 | 省线;总线故障影响全网 |
| 环型 | 首尾相接成环 | 传输确定;一个节点故障易影响全网 |
| 网状 | 节点间多条通路 | 可靠性高;成本高(互联网骨干多用) |
3.3 网络硬件与传输介质
| 设备 | 作用 |
|---|---|
| 网卡(NIC) | 计算机接入网络的接口,有唯一的 MAC 地址 |
| 交换机 Switch | 局域网内部连接多台设备,按 MAC 地址转发 |
| 路由器 Router | 连接不同网络,选择路径转发数据(家庭 WiFi 路由器兼具交换功能) |
| 调制解调器 Modem / 光猫 | 数字信号与线路信号之间转换 |
| 防火墙 | 位于内网与外网之间,控制进出的数据流 |
| 传输介质 | 说明 |
|---|---|
| 双绞线(网线) | 便宜、常用,需配水晶头 |
| 光纤 | 速度快、抗干扰强、传输距离远 |
| 同轴电缆 | 早期有线电视网 |
| 无线电波 | WiFi、蓝牙、4G/5G |
3.4 网络协议与常用缩写 ★
| 协议 | 全称 | 用途 |
|---|---|---|
| TCP/IP | 传输控制协议 / 网际协议 | 互联网的基础协议族,负责可靠传输和寻址 |
| HTTP / HTTPS | 超文本传输协议 | 浏览网页;HTTPS 加了加密,更安全 |
| FTP | 文件传输协议 | 上传下载文件 |
| SMTP / POP3 / IMAP | 邮件协议 | SMTP 发邮件,POP3/IMAP 收邮件 |
| DNS | 域名系统 | 把域名翻译成 IP 地址 |
| DHCP | 动态主机配置协议 | 自动分配 IP 地址 |
| Telnet / SSH | 远程登录 | SSH 加密 |
| UDP | 用户数据报协议 | 不保证可靠,但快(视频直播) |
3.5 IP 地址与子网掩码 ★★ 高频
IPv4 地址
格式:点分十进制,共 4 段,每段 0 ~ 255
例:202.118.118.1
↑ ↑ ↑ ↑
每段是一个 8 位二进制数(0~255)
判断 IP 是否合法,看两条: ① 必须是 4 段;② 每段必须在 0~255 之间。
202.202.1→ 只有 3 段,错202.2.2.2.2→ 有 5 段,错202.258.14.13→ 258 > 255,错202.118.118.1→ 正确(2024·19 答案 C)
IPv6:128 位,写成 8 组十六进制,如 2001:0db8:0000:0000:0000:ff00:0042:8329。地址数量极其庞大,解决了 IPv4 地址枯竭问题。
子网掩码:判断两台机器是否在同一网段
规则:把 IP 与子网掩码做「按位与」,结果相同则在同一个网段。
简化技巧:掩码中为 255 的那几段必须完全相同;
为 0 的那几段可以任意不同。
例(2025·19):掩码
255.255.0.0,基准地址172.16.5.8→ 网段由前两段172.16固定(255.255 对应处必须相同),后两段可任意。
172.15.5.8→ 第 2 段 15 ≠ 16,不同网段172.16.5.256→ 第 4 段 256 非法(超过 255)173.16.5.8→ 第 1 段 173 ≠ 172,不同网段172.16.6.9→ 前两段 172.16 相同 → 同一网段(答案 D)
常见默认掩码(了解即可)
| 类别 | 首段范围 | 默认掩码 |
|---|---|---|
| A 类 | 1–126 | 255.0.0.0 |
| B 类 | 128–191 | 255.255.0.0 |
| C 类 | 192–223 | 255.255.255.0 |
172.x.x.x属于 B 类;192.168.x.x属于 C 类,也是最常见的家庭/校园内网地址段。
3.6 域名与网络地址
域名的结构:从右到左级别递减
www . meilicode . cn
主机名 机构/品牌名 顶级域名
| 顶级域名 | 含义 |
|---|---|
.cn | 中国 |
.com | 商业机构 |
.org | 非营利组织 |
.edu | 教育机构 |
.gov | 政府机构 |
.net | 网络服务机构 |
URL(统一资源定位符) 的组成:
https:// oj.meilicode.cn /user/courses ?page=2 #top
协议 域名(主机) 路径 查询参数 锚点
3.7 互联网简史(与 DAY01 呼应)
| 时间 | 事件 |
|---|---|
| 1969 | ARPANET(阿帕网) 建立,互联网的雏形 |
| 1983 | TCP/IP 协议成为标准,现代互联网成型 |
| 1991 | 蒂姆·伯纳斯-李发明万维网 WWW |
| 1994 | 中国实现与国际互联网的全功能接入(4 月 20 日) |
| 现在 | IPv6 普及、5G/6G、卫星互联网 |
3.8 信息安全 ★
计算机病毒的五大特征(必背)
| 特征 | 含义 |
|---|---|
| 传染性 | 能自我复制、传播给其他文件(最本质特征) |
| 潜伏性 | 可以长时间潜伏不发作 |
| 隐蔽性 | 藏得很深,不易被察觉 |
| 破坏性 | 删除文件、篡改数据、占用资源 |
| 可触发性 | 满足特定条件(日期、次数)才发作 |
其他常见威胁
| 名称 | 特点 |
|---|---|
| 蠕虫 Worm | 能自己在网络中传播,不需要宿主程序 |
| 木马 Trojan | 伪装成正常软件,窃取信息、开后门 |
| 钓鱼 Phishing | 假冒网站/短信骗取账号密码 |
| 勒索软件 | 加密你的文件索要赎金 |
| 黑客攻击 | 拒绝服务攻击(DDoS)、撞库、漏洞利用 |
防护措施(记住「五件套」)
- 安装防火墙,拦截非法访问;
- 安装并及时更新杀毒软件;
- 及时打系统补丁,修复漏洞;
- 使用强密码、不点陌生链接、不下载来源不明的文件;
- 重要数据定期备份。
⚠️ 常见错误认知:杀毒软件能查杀所有病毒——错;装了防火墙就绝对安全——错;格式化硬盘能防止所有病毒感染——错。安全是「多层防护」,没有一劳永逸。
3.9 信息道德与法律
| 行为 | 判断 |
|---|---|
| 未经许可把正版软件发给他人共享 | 侵犯版权(2022·11 答案 B) |
| 随意公布他人隐私信息 | 侵犯隐私权 / 违反《个人信息保护法》 |
| 编写并传播计算机病毒 | 违法,可追究刑事责任 |
| 使用他人账号登录 | 非法侵入计算机信息系统 |
| 引用他人成果不注明出处 | 学术不端 |
相关法律法规:《中华人民共和国网络安全法》《数据安全法》《个人信息保护法》《计算机软件保护条例》《中华人民共和国著作权法》。
网络行为准则:不造谣不传谣、不侵犯他人隐私、不盗版、不进行网络暴力、尊重知识产权。
某同学购买了一款正版软件,未经许可把该软件发送给他人共享。这种做法属于( )。
答案:B
破题点:买的正版 ≠ 可以随便发给别人。
正版软件受著作权法保护,购买获得的是「使用权」而不是「传播权」。未经许可复制、传播给他人属于侵犯版权,即使出于好意也不合法。选 B。
局域网的英文缩写( )
答案:A
破题点:LAN = 局域网。
LAN = Local Area Network(局域网);WAN = Wide Area Network(广域网);MAN = Metropolitan Area Network(城域网)。选 A。
下列选项中,正确的 IP 地址格式是( )。
答案:C
破题点:IP 地址 = 4 段,每段 0~255。
IPv4 地址由 4 段十进制数组成,每段取值 0~255,用点分隔。A 只有 3 段;B 有 5 段;D 中 258 > 255 超出范围。选 C。
某局域网使用子网掩码 255.255.0.0,下列 IP 地址中与 172.16.5.8 属于同一网
段的是( )。
答案:D
破题点:子网掩码 255.255.0.0 → 前两段相同即同一网段。
掩码 255.255.0.0 表示网络号取 IP 的前两段。172.16.5.8 的网络号是 172.16.0.0。A 前两段 172.15 不同;C 前两段 173.16 不同;D 中 256 超出单段范围、是非法 IP。172.16.6.9 的网络号同为 172.16.0.0,属同一网段。选 D。
IPv4版本的因特网总共有( )个A类地址网络。
答案:C
IPv4 的 A 类地址网络号首字节范围 1~126(0 与 127 保留),所以有 126 个 A 类网络。答案 C。
在TCP协议中,完成连接建立需要通过( )握手。
答案:C
TCP 建立连接要三次握手(SYN → SYN+ACK → ACK),断开要四次挥手。答案 C。
小明最近为了备考GESP,开始看B站上关于网络知识的视频。其中提到计算机网络系统有不同的划分标准,那他平时上学所在的教学楼内的网络是一个( )。
答案:B
教学楼内的网络覆盖范围小,属于局域网 LAN。答案 B。
域名是由一串用点分隔的名字来标识互联网上一个计算机或计算机组的名称, CCF 编程能力等级认证官方网站的域名是gesp.ccf.org.cn,其中顶级域名是 gesp。
答案:B
域名 gesp.ccf.org.cn 从右往左是:顶级域名 cn、二级域名 org、三级 ccf、四级 gesp。顶级域名是 cn 而不是 gesp。答案 B(错误)。
#include <iostream>
using namespace std;
int main(){
int ip[4] = {192, 168, 1, 20};
for(int i = 0; i < 4; i++){
cout << ip[i];
if(i < 3) cout << ".";
}
return 0;
}程序输出为( )。
192.168.1.20 属于局域网(私有)地址段。
这段程序中 for 循环的循环体一共执行了 ______ 次。
- 第 1 题A 循环 4 次输出 4 段数字,每次在数字**后**判断:i=0,1,2 时补一个「.」,i=…
- 第 2 题A 三段常用私有地址必须背下:10.0.0.0~10.255.255.255、172.16.0.…
- 第 3 题4 i 从 0 开始,每次加 1,条件 i < 4。i 的取值为 0、1、2、3,共 4 次;i…
- 第 1 题A LAN 是局域网、MAN 是城域网、WAN 是广域网,范围依次增大;把 MAN 当成局域网是最常见的记反。
- 第 2 题B IPv4 由 4 段组成,每段取值范围是 0~255;只数段数不看范围,就会把 192.168.1.300 这种非法地址判成合法。
- 第 3 题C 掩码为 255 的段必须相同才算同网段,为 0 的那段可以不同;把 0 段也要求相同是常见误解。
- 第 4 题D DNS 把域名翻译成 IP 地址,DHCP 自动为主机分配 IP 地址;两者的职责正好相反,最容易对调。
- 第 5 题A SMTP 负责发信,POP3 和 IMAP 负责收信;把收发方向弄反是这一考点最常见的错误。
- 第 6 题B 杀毒软件不是万能的,没有绝对安全;多层防护加上重要数据备份才靠谱,也不能拿它代替系统补丁。
- 第 7 题B 五大特征是传染、潜伏、隐蔽、破坏、可触发;只知道三个或者把「不可清除性」混进来,都是没背全。
- 第 8 题D 最本质的特征是传染性,正是它让病毒能扩散;破坏性只是五大特征之一,不是本质。
- 第 9 题C 交换机负责局域网内部设备的互联,路由器负责连接不同的网络并选择转发路径;把两者的适用场景互换是常见错误。
- 第 10 题D 域名从右往左级别降低,所以是 com → meilicode → www;从左往右读是典型的读反。
- 第 11 题C 未经授权复制分发软件属于侵犯版权,是否收费并不影响性质;把它当成合法的资源共享是错误的理解。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 通读讲义,重点记 §3.4 协议缩写表、§3.5 IP 判断、§3.8 病毒五特征
- 背下 LAN 局域网、MAN 城域网、WAN 广域网,并按范围从小到大排序
- 判断 192.168.1.300 是否为合法 IP(答不合法,最后一段超过 255),并说明判断要同时看段数和取值范围
- 说清交换机与路由器的分工:交换机用于局域网内部,路由器用于连接不同网络
- 分清 DNS 负责域名解析、DHCP 负责自动分配 IP 地址,各举一句
- 记住 SMTP 发信、POP3/IMAP 收信,并默写病毒五大特征与「最本质是传染性」
- 写出一组保护个人信息安全的措施:安装防火墙与杀毒软件、及时更新系统补丁、使用强密码且不点陌生链接、重要数据定期备份
- 阶段一总结:通识四天(时事/体系结构/进制编码/网络)共约 34 题 / 53 分,占单选的 38%——这一块务必拿满
- 完成客观题 8 题(
DAY04-01~DAY04-08) - 完成阅读程序小片段 1 组
本日关键记忆:LAN<MAN<WAN · IP 4 段且每段 0–255 · 掩码 255 处必须相同 · DNS 解析域名/DHCP 分配 IP · 病毒五特征(传染性最本质)· 未经授权共享软件=侵权
程序框架、头文件、命名空间与注释
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2025 | 第 23 题 | 单项选择 | 2 分 |
难易度:易(★☆☆☆☆) 近 4 年合计:1 题 / 2 分
2026 年备考建议
站在出题人的视角,程序框架和命名空间是「送分但最容易翻车」的板块:默写框架、填一处头文件、问一个符号的意思。命题人爱它,是因为既考记忆,又能在阅读程序里埋一个忘写 using namespace std; 的陷阱。
因此本日要精确到「一个字符都不能错」:#include 行尾不加分号,有且只有一个 main,标准写法是 int main() 且末尾 return 0;。:: 是作用域解析运算符、. 用于对象成员、-> 用于指针成员,不写 using 就得写 std::cout。
再记一句:多行注释 / / 不允许嵌套。
②知识地图 · 本考点思维导图
- C++ 程序基本框架
- #include 预处理(头文件)
- using namespace std;(命名空间)
- int main() { … return 0; }
- 语句以分号结尾、代码块用花括号
- 头文件
- <iostream> → cout/cin
- <cstdio> → scanf/printf
- <cmath> / <cstring> / <string> / <algorithm>
- <bits/stdc++.h>(万能头文件,DEV C++ 可用)
- 命名空间
- namespace 的作用:避免同名冲突
- 三种写法:using namespace std / std::cout / using std::cout
- 注释
- 单行 // 多行 /* *
- 语言发展历程
- 机器语言 → 汇编语言 → 高级语言
- C(1972) → C++(1983, Bjarne Stroustrup)
- 编译与解释
- 编译型(C/C++)vs 解释型(Python)
③核心精讲
3.1 C++ 程序的标准框架(必背,一个字符都不能错)
#include <iostream> // ① 预处理指令:引入输入输出头文件
using namespace std; // ② 使用标准命名空间
int main() // ③ 主函数:程序的唯一入口
{
cout << "Hello!" << endl; // ④ 语句,末尾必须有分号
return 0; // ⑤ 返回 0,表示程序正常结束
}
逐行拆解
| 行 | 说明 |
|---|---|
#include <iostream> | 预处理指令,行尾不加分号;尖括号表示从系统目录找头文件 |
using namespace std; | 声明使用标准命名空间,结尾要加分号 |
int main() | 主函数,每个 C++ 程序有且只有一个;返回类型是 int |
{ } | 函数体,成对出现 |
cout << …; | 输出语句,末尾必须有分号 |
return 0; | 向操作系统返回 0,表示正常退出 |
DEV C++ 5.11 环境(大纲指定):新建 → 源代码 → 保存为 .cpp → 编译运行(快捷键 F11)。
3.2 头文件
头文件的作用:告诉编译器「我要用哪些现成的函数/对象」,相当于一张「工具清单」。
| 头文件 | 提供什么 | 常用内容 |
|---|---|---|
<iostream> | 输入输出流 | cin cout endl |
<cstdio> | C 风格输入输出 | scanf printf |
<cmath> | 数学函数 | sqrt abs pow fabs |
<cstring> | 字符数组操作 | strlen strcpy strcmp memset |
<string> | string 类 | length() substr() find() |
<algorithm> | 算法 | sort max min swap reverse |
<cstdlib> | 常用工具 | rand srand atoi |
<bits/stdc++.h> | 万能头文件 | 一次性包含上面几乎所有内容(GCC/DEV C++ 支持,比赛常用) |
⚠️
#include是预处理指令,后面不写分号。写了分号通常不报错,但属于不规范写法,且在某些版本会出问题。
3.3 命名空间 namespace ★
为什么要有命名空间? 不同人写的库可能用同一个名字(比如都叫 sort),产生冲突。命名空间相当于「姓氏」,用 ::(作用域解析运算符)把名字限定住。
std::cout // 命名空间 std 里的 cout
std 是 C++ 标准库的命名空间(standard 的缩写)。
三种写法
| 写法 | 代码 | 特点 |
|---|---|---|
| ① 全局声明 | using namespace std;cout << "hi"; | 最省事,竞赛最常用 |
| ② 全限定名 | std::cout << "hi"; | 最规范,不写 using 时必须这样 |
| ③ 局部声明 | using std::cout;cout << "hi"; | 只引入需要的名字 |
2025·23 考的就是第 ② 种:题目问「如果没有在代码开头声明
using namespace std,使用cout输出"123"哪种写法正确」—— A.std:cout❌(少一个冒号) B.std::cout✅ C.std->cout❌(->是指针访问) D.std.cout❌(.是对象成员访问) 答案 B。记住:::是作用域解析运算符(两个冒号)。
3.4 注释
| 类型 | 写法 | 说明 |
|---|---|---|
| 单行注释 | // 这是注释 | 从 // 到本行末 |
| 多行注释 | /* 多行 | 从 /* 到 */,不能嵌套 |
注释的三个作用:① 说明代码用途;② 暂时屏蔽某段代码(调试用);③ 编译器会完全忽略注释内容,不影响运行结果。
常见考法:给一段带注释的代码问输出——注释里的内容不会被输出,要看清哪部分是注释。
3.5 程序设计语言的发展历程 ★
第一代:机器语言 —— 直接由 0/1 组成的指令,计算机能直接执行,人难写难读
↓
第二代:汇编语言 —— 用助记符(ADD、MOV)代替 0/1,需要汇编程序翻译
↓
第三代:高级语言 —— C、C++、Python、Java、Pascal…
接近自然语言,可移植性好,需要编译/解释
| 对比项 | 机器语言 | 汇编语言 | 高级语言 |
|---|---|---|---|
| 表现形式 | 二进制 0/1 | 助记符 | 类自然语言 |
| 是否需翻译 | 不需要 | 需要汇编 | 需要编译或解释 |
| 可读性 | 极差 | 差 | 好 |
| 可移植性 | 无 | 差 | 好 |
| 执行效率 | 最高 | 高 | 相对低 |
C++ 的来历
| 时间 | 事件 |
|---|---|
| 1972 | C 语言诞生(丹尼斯·里奇,贝尔实验室) |
| 1983 | C++ 诞生(本贾尼·斯特劳斯特鲁普 Bjarne Stroustrup),最初叫「C with Classes」 |
| 1998 | C++98 标准(第一个国际标准) |
| 2011 | C++11(重大更新:auto、范围 for) |
| 至今 | C++14 / 17 / 20 / 23 |
小知识:C++ 的「++」是自增运算符,寓意「C 语言的升级版」。
3.6 编译与解释(与 DAY02 §3.8 呼应)
| 编译型(C / C++) | 解释型(Python) | |
|---|---|---|
| 翻译方式 | 整份源代码一次性翻译成机器码 | 逐行翻译并立即执行 |
| 中间产物 | 生成 .obj → .exe | 不生成可执行文件 |
| 运行速度 | 快 | 较慢 |
| 跨平台性 | 差(换系统要重新编译) | 好 |
| 错误发现 | 编译阶段集中报错 | 运行到那一行才报错 |
C++ 程序的四个阶段:编辑 → 编译 → 链接 → 运行(出错则调试)。
⚠️ 编译能发现语法错误(少分号、括号不匹配),发现不了逻辑错误(把
+写成-)。
如果没有在代码开头声明“using namespace std”,那么当我们要使用 cout 函数
输出字符串“123”的时候,下面哪种用法是正确的( )?
答案:B
破题点:命名空间限定符是「::」,不是「:」「->」「.」。
C++ 中用双冒号 ::(作用域限定符)访问命名空间成员,正确写法是 std::cout。单冒号是错误语法,-> 用于指针访问成员,. 用于对象访问成员。选 B。
下列代码的输出结果是( )。
#include <iostream>
using namespace std;
int main() {
int a = 12;
int result = a >> 2;
cout << result << endl;
return 0;
}答案:C
a >> 2 是右移 2 位,等价于除以 2²=4。12 ÷ 4 = 3。答案 C。
下列代码中,输出结果是( )
#include<iostream>
using namespace std;
int main()
{
double a=0.9;
double b=1.0;
if(((b-a)==0.1))
{
cout<<"Equal"<<endl;
}
else
{
cout<<"Not equal"<<endl;
}
}答案:B
浮点数无法精确表示 0.1,1.0 - 0.9 = 0.09999999999999998 ≠ 0.1,条件不成立。答案 B(Not equal)。
在使用C++语言编写程序时,不能使用sqrt、abs 等数学函数,包含<cmath>
或<math.h>头文件后就能够使用了。答案:A
sqrt(开方)、abs(绝对值)等数学函数声明在 <cmath> 或 <math.h> 里,不包含就找不到声明。说法正确。答案 A(正确)。
高级语言编写的程序需要经过以下( )操作,可以生成在计算机上运行的可执行代码。
答案:D
高级语言程序必须先经编译生成可执行代码才能运行。答案 D(编译)。
如果一个异常在 try 块中抛出但没有任何 catch 匹配,它将在编译时报错。
答案:B
try 中抛出异常而没有任何 catch 匹配时,不会在编译期报错,而是在运行期调用 terminate 终止程序。答案 B(错误)。
C++是一种高级程序设计语言。
答案:A
C++ 是在 C 基础上发展起来的高级程序设计语言,支持面向对象。说法正确。答案 A(正确)。
小杨最近开始学习C++编程,老师说C++是一门面向对象的编程语言,也是一门高级语言。( )
答案:A
C++ 既是高级语言,也支持面向对象(类、继承、多态)。说法正确。答案 A(正确)。
#include <iostream>
using namespace std;
int main(){
cout << "Hello" << endl;
return 0;
}#include <iostream> 这行代码的作用是( )。
若删去 using namespace std; 这一行,下面改写正确的语句是( )。
一个 C++ 程序中可以有多个 main 函数。
- 第 1 题B 以 # 开头的叫预处理指令,在编译前由预处理器处理。#include 就是把目标头文件的内容…
- 第 2 题A cout、endl 都定义在标准命名空间 std 里。不加 using namespace …
- 第 3 题B 一个**可执行程序**只能有一个 main 函数,它是程序唯一的入口。一个工程里的不同源文件…
- 第 1 题D 不引入命名空间就必须写全限定名 std::cout;把 using 写在文件末尾也来不及覆盖前面的语句。
- 第 2 题A :: 是作用域解析运算符,. 访问对象成员,-> 访问指针指向对象的成员;三者用途不同,不能互换。
- 第 3 题C 预处理指令以换行结束,行尾不加分号;习惯性地给它补分号是初学者最容易犯的错。
- 第 4 题B 程序有且只有一个 main 函数,它是执行的入口;写多个会让链接阶段报重复定义。
- 第 5 题A 标准写法是 int main(),并在末尾 return 0;;void main() 不是标准写法,省略返回类型同样不合规范。
- 第 6 题D C++ 源文件是 .cpp,.c 是 C 语言的源文件;.class 是 Java 的类文件,不要混进来。
- 第 7 题A 注释只是给人看的说明,编译时被完全忽略,不会影响运行结果;以为注释会执行是概念性错误。
- 第 8 题C 多行注释不允许嵌套,遇到第一个 */ 就结束了,后面的内容会被当成代码;多层嵌套是常见的写法错误。
- 第 9 题D 编译器只负责语法检查,语法正确但算错的逻辑错误要靠调试发现;以为编译通过就没问题是最危险的想法。
- 第 10 题B C++ 是编译型语言,一次性把源代码翻译成机器码后运行;逐行翻译执行是解释型语言的特点。
- 第 11 题C C++ 由本贾尼·斯特劳斯特鲁普于 1983 年发明,由 C 语言发展而来;丹尼斯·里奇是 C 语言的发明人,两人最容易混。
- 第 12 题D <bits/stdc++.h> 是 GCC 的便捷扩展,一次包含大量常用头文件,竞赛中方便,但它并不是 ISO 标准头文件。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 完整默写一个最简单的 C++ 程序框架:头文件、using namespace std;、int main()、输出语句、return 0;
- 记住 #include 等预处理指令行尾不加分号,且一个程序只能有一个 main 函数
- 分清三个符号的用法::: 用于命名空间或类域、. 用于对象成员、-> 用于指针成员
- 练习不写 using namespace std; 时用 std::cout 输出,并说清命名空间的作用是避免同名冲突
- 默写程序设计语言的发展顺序:机器语言 → 汇编语言 → 高级语言,并记住 C++ 由本贾尼·斯特劳斯特鲁普于 1983 年发明、属于编译型语言
- 记住多行注释 / / 不允许嵌套,以及 <bits/stdc++.h> 只是 GCC 的便捷扩展、并非 ISO 标准头文件
- 默写 3 遍 C++ 标准框架,直到不看讲义也能写对
- 完成客观题 8 题(
DAY05-01~DAY05-08) - 完成阅读程序小片段 1 组
本日关键记忆:
#include不加分号 ·using namespace std;加冒号分号 ·int main()唯一入口 ·std::cout·::作用域解析 · 机器→汇编→高级 · C 1972 / C++ 1983 ·.cpp
变量、常量、命名规范与作用域
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 9 题 | 单项选择 | 1 分 |
| 2023 | 第 6 题 | 单项选择 | 1 分 |
| 2025 | 第 16 题 | 单项选择 | 2 分 |
难易度:较易(★★☆☆☆) 近 4 年合计:3 题 / 4 分
2026 年备考建议
站在出题人的视角,变量命名和作用域是典型的规则题:条件清楚、答案唯一,命题人只要造几个像 2x、my-name 这样的非法标识符就能出一题,还能在阅读程序里埋一个「同名遮蔽」的坑,看学生是按就近原则取值还是想当然用全局变量。
因此本日要做到不用想就报得出答案:标识符只能由字母、数字、下划线组成,首字符只能是字母或下划线,不能是关键字,且区分大小写;局部变量未初始化是随机值,全局变量自动为 0;同名时按就近原则用局部变量。字符用单引号,const 定义常量要有类型和分号,#define 只是文本替换、无类型检查。
②知识地图 · 本考点思维导图
- 标识符命名规则
- 可用字符:字母 A-Z a-z、数字 0-9、下划线 _
- ① 只能由字母或下划线开头(不能数字开头)
- ② 不能是关键字(保留字)
- ③ 区分大小写(Age ≠ age)
- ④ 不能含空格和特殊符号
- 常量的三种写法
- 字面常量:5、3.14、'A'、"abc"
- const 常量:const double PI = 3.14159;
- 宏定义:#define PI 3.14159(无分号、无类型)
- 变量的定义与初始化
- int a; int a = 5; int a(5); int a{5};
- 未初始化的局部变量 = 随机值(垃圾值)
- 作用域(scope)
- 全局作用域:定义在所有函数外
- 局部作用域:函数体 / 语句块 { }
- ★同名遮蔽:函数内优先访问局部变量
- 生命周期(storage duration)
- sizeof 运算符
③核心精讲
3.1 标识符命名规则 ★(高频)
C++ 标识符(变量名、函数名等)的四条硬规则
| 规则 | 说明 | 反例 |
|---|---|---|
| ① 不能以数字开头 | 首字符只能是字母或下划线 | 2ab ❌、_ab ✅ |
| ② 不能是关键字 | 语言保留的字不能用作名字 | int、const、char、for ❌ |
| ③ 只能含字母、数字、下划线 | 空格、-、+、# 等都不行 | my-name ❌、my name ❌ |
| ④ 区分大小写 | Age 与 age 是两个不同的名字 | — |
C++ 常见关键字(背这张表就够了)
类型类:int long short float double char bool void string signed unsigned
控制类:if else switch case default for while do break continue return
其他: const static struct class namespace using cin cout true false new delete
重点区分:
const、char、int、long、double、while、if、for、struct、string(注意:string在 C++ 中作为类型名属于标准库,不是关键字,可以当变量名使用,但不建议)都是不能直接用作变量名的。2022·9 答案 A(
const是关键字);2023·6 答案 B(char是关键字)。 而_a、_boy、my_book、my_name、hello2、text2都是合法的。
命名风格建议(不考,但老师要求)
| 风格 | 例子 | 适用 |
|---|---|---|
| 小驼峰 | myScore、maxValue | 变量 |
| 大驼峰 | MaxValue、StudentInfo | 结构体、类 |
| 下划线 | my_score、max_value | 变量(竞赛常见) |
| 全大写 | MAXN、PI | 常量、宏 |
3.2 常量
| 写法 | 例子 | 特点 |
|---|---|---|
| 字面常量 | 5、3.14、'A'、"hello" | 直接写在代码里 |
const 常量 | const double PI = 3.14159; | 有类型、末尾有分号、定义后不可修改 |
constexpr | constexpr int N = 100; | 编译期常量(C++11 起) |
| 宏定义 | #define PI 3.14159 | 无类型、无分号,预处理阶段做文本替换 |
const与#define的区别(了解):
#define是文本替换,不做类型检查,容易出问题(如#define S 1+2后S*3变1+2*3=7);const有类型、有作用域,更安全、更推荐。
常见常量写法示例
const int MAXN = 100005; // 数组上限,竞赛必备
const double PI = 3.1415926;
3.3 变量的定义与初始化
定义变量的四种写法
int a; // 只定义,未初始化
int a = 5; // 赋值初始化(最常用)
int a(5); // 括号初始化
int a{5}; // 列表初始化(C++11)
★ 未初始化的后果(重点)
| 变量类型 | 未初始化时的值 |
|---|---|
| 局部变量 | 随机值(垃圾值),不可预测 |
| 全局变量 | 自动为 0 |
这两条一定要分清!2025·16 的选项 B 就是把这个说反了:「局部变量若未初始化,其值为 0;全局变量若未初始化,其值为随机数」——恰好说反,所以错误。
同时定义多个变量
int a, b, c; // 三个 int,都未初始化
int a = 1, b = 2, c; // a、b 有初值,c 没有
int a = 1, b = a + 1; // ✅ 可以用前面已定义的变量
3.4 作用域 ★(2025 年新考点)
作用域 = 一个名字「能被看见」的范围。
全局作用域(文件级)
├── 定义在所有函数外面 → 从定义处到文件结束,所有函数都能用
│
├── 局部作用域(函数级)
│ └── 函数体内定义 → 只有这个函数内能用
│
└── 块作用域(语句级)
└── { } 内部定义 → 只在花括号内有效
for (int i = 0; ...) 中的 i 只在循环体内有效
★ 同名遮蔽(shadowing)
int x = 100; // 全局变量
int main() {
int x = 5; // 局部变量,与全局同名
cout << x; // 输出 5 —— 就近原则,局部变量"遮蔽"了全局变量
return 0;
}
口诀:就近访问。函数内部有同名的局部变量时,访问的是局部变量,全局变量被「遮蔽」。
2025·16 正确答案 C 就是这一条:「函数内部定义的局部变量与全局变量同名时,在该函数内访问的是局部变量」。
3.5 生命周期
| 变量类型 | 出生 | 死亡 |
|---|---|---|
| 全局变量 | 程序启动 | 程序结束 |
| 局部变量 | 进入函数/代码块 | 离开函数/代码块 |
static 局部变量 | 程序启动 | 程序结束(但只在定义处可见) |
记忆要点:全局变量的生命周期与整个程序一致;局部变量只在定义它的那一小段代码中存在。
3.6 sizeof:测量类型或变量的字节数
cout << sizeof(int); // 4
cout << sizeof(char); // 1
cout << sizeof(double); // 8
int a[10];
cout << sizeof(a); // 40 —— 整个数组占 40 字节
cout << sizeof(a) / sizeof(a[0]); // 10 —— 数组长度(常用技巧)
sizeof是运算符(不是函数),返回size_t类型的字节数,在编译时就能算出来。
以下变量命名不符合规范的是?( )
答案:A
破题点:关键字不能作变量名。
const 是 C++ 关键字(定义常量),不能用作变量名。_a、my_book、hello2 都符合命名规范(字母或下划线开头,只含字母数字下划线)。选 A。
以下变量命名不符合规范的是?( )
答案:B
破题点:关键字不能作变量名。
char 是 C++ 基本数据类型关键字,不能用作变量名。_boy、my_name、text2 都合法。选 B。
下列关于 C++ 语言中全局变量与局部变量的说法,正确的是()
答案:C
破题点:同名时「局部优先」(就近原则)。
函数内定义的局部变量与全局变量同名时,函数内访问的是局部变量,这叫「局部变量遮蔽全局变量」(C 对)。局部变量也可以定义在循环语句里(A 错);全局变量未初始化时值为 0,局部变量的值不确定(B 说反了);全局变量随程序始终存在,局部变量只在函数执行期间存在(D 说反了)。选 C。
下列关于C++语言的叙述,不正确的是( )。
答案:C
变量必须先定义后使用,没有定义的变量编译器不认识,无法使用。所以「没有定义也能使用」不正确。答案 C。
下列关于C++语言中变量的叙述,正确的是( )。
答案:D
同名变量在**不同作用域**中可以共存,内层遮蔽外层,互不冲突。答案 D。
以下选项中不符合 C++变量命名规则的是?( )
答案:B
标识符不能以数字开头,2_from 违法;_name、name2 合法。答案 B。
以下关于C++变量作用域的说法,错误的是( )。
答案:C
全局变量从定义处开始有效,到文件结束;但若在定义之前(或另一个文件)使用,必须提前声明。所以「在整个程序中都有效」这句在严格意义上是错的。答案 C。
下面有关C++变量的说法,正确的是( )。
答案:A
for 是 C++ 关键字(保留字),不能用作变量名。答案 A。
在C++语言中,标识符中可以有数字,但不能以数字开头。
答案:A
标识符可以含数字,但不能以数字开头(如 a1 合法、1a 非法)。说法正确。答案 A(正确)。
在C++语言中,标识符的命名不能完全由数字组成,至少有一个字母就可以。
答案:B
标识符并不强制要求「至少一个字母」——下划线开头、只含下划线和数字也是合法的(如 _1)。所以这句话是错的。答案 B(错误)。
#include <iostream>
using namespace std;
int a = 10;
int main(){
int a = 3;
{ int a = 5; cout << a; }
cout << a << a;
return 0;
}程序输出为( )。
题中 `int a = 5;` 这个变量的作用范围是( )。
这段程序执行结束后,全局变量 a 的值变成了 5。
- 第 1 题A 花括号内的 a=5 只在那对花括号里有效,退出后回到 main 的 a=3。所以顺序是:输出…
- 第 2 题C C++ 里一对花括号就是一个作用域(block)。变量从定义处开始、到所在花括号结束为止有效…
- 第 3 题B 三个 a 是三个**互不相干**的变量。花括号里的 int a = 5; 是重新定义了一个新…
- 第 1 题D 标识符只能由字母、数字、下划线组成,且首字符必须是字母或下划线;用数字开头或含减号都不合法。
- 第 2 题C string 是标准库提供的类型名而不是关键字,严格说可以当标识符但不该这么用;把它当成关键字是常见误解。
- 第 3 题D 变量名区分大小写,Sum 和 sum 是两个互不相干的变量;以为它们相同会导致取值错误。
- 第 4 题A 局部变量未初始化时存放的是随机值,不能用;以为它会自动为 0 是危险的想当然。
- 第 5 题B 全局变量自动初始化为 0,局部变量不初始化就是随机值;把两者的行为记反是最常见的错误。
- 第 6 题C 遵循就近原则,局部变量遮蔽同名的全局变量,所以访问的是局部变量;以为访问全局变量是典型错误。
- 第 7 题D 局部变量只在定义它的代码块内存在,离开代码块就被销毁;它与程序同生共死的说法只适用于全局变量。
- 第 8 题B char 存的是单个字符,要用单引号 'a';双引号 "a" 是字符串,类型不匹配。
- 第 9 题B const 定义常量要写成「const 类型 名字 = 值;」,别忘末尾的分号;少分号或缺等号都是语法错误。
- 第 10 题C #define 只是预处理阶段的文本替换,没有类型也不检查;以为它有类型检查是常见误解,而用 const 才有类型。
- 第 11 题A sizeof 作用于数组名时返回整个数组的字节数,20 个 int 共 80 字节;把数组名当成指针只会算出 4。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 通读讲义,把 §3.1 关键字表抄一遍
- 默写标识符命名的四条规则:只含字母数字下划线、不能数字开头、不能是关键字、区分大小写
- 判断下列名字是否合法并说明理由:2x、_count、my-name、int、Value、sum1
- 记住「全局变量自动为 0、局部变量是随机值」,并写一段同名遮蔽的代码验证输出的是局部变量的值
- 分清 const 与 #define 两种定义常量的写法:const 有类型、要有分号,#define 无类型、无分号、只是文本替换
- 记住字符用单引号、字符串用双引号,并写出 char c='a'; 的完整语句
- 用 sizeof(a)/sizeof(a[0]) 求出 int a[20]; 的数组长度 20,并说明 sizeof(a) 返回整个数组的字节数
- 完成客观题 10 题(
DAY06-01~DAY06-10) - 完成阅读程序小片段 1 组
本日关键记忆:不能数字开头 · 不能是关键字 · 区分大小写 · 局部未初始化=随机值/全局=0 · 就近原则(同名取局部)·
char c='a';·sizeof(a)/sizeof(a[0])
基本数据类型与取值范围
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 10 题 | 单项选择 | 1 分 |
| 2022 | 第 23 题 | 填空题 | 3 分 |
| 2023 | 第 8 题 | 单项选择 | 1 分 |
| 2023 | 第 10 题 | 单项选择 | 1 分 |
| 2024 | 第 23 题 | 填空题 | 3 分 |
难易度:中等(★★★☆☆) 近 4 年合计:5 题 / 9 分
2026 年备考建议
站在出题人的视角,数据类型和取值范围是「必背表 + 必会算」的组合:既直接考 sizeof,又能用除法截断和乘法溢出设陷阱,让粗心的人把 9/2 算成 4.5、把 10¹⁰ 塞进 int。
因此本日要把字节数背到脱口而出:short 2、int 4、long long 8、float 4、double 8、char 1。记死三条:整数除法向零截断,9/2 = 4;取余符号跟被除数一致,−7%3 = −1;大数相乘先写 (long long)a * b。
再记两句:(int) 向零截断不是四舍五入;浮点比较要写 fabs(a-b) < 1e-9。
②知识地图 · 本考点思维导图
- 整型家族
- short(2 字节)· int(4 字节)· long long(8 字节)
- unsigned 无符号 → 范围翻倍、非负
- 取值范围与溢出
- 浮点型
- float(4 字节,约 6~7 位有效数字)
- double(8 字节,约 15~16 位有效数字)
- 字符与布尔
- char(1 字节)↔ ASCII 整数
- bool(true=1 / false=0)
- 字符串
- string(需 #include <string>)
- 类型转换
- 隐式转换(自动,可能丢精度)
- 显式转换(强制类型转换)
- 三大坑
- ① 整数除法截断(9/2 = 4)
- ② 整型溢出
- ③ 浮点精度误差
③核心精讲
3.1 常用数据类型总表 ★必背
| 类型 | 占用字节 | 取值范围 | 说明 |
|---|---|---|---|
short | 2 | −32768 ~ 32767 | 短整型 |
unsigned short | 2 | 0 ~ 65535 | 无符号短整型 |
int | 4 | −2147483648 ~ 2147483647(约 ±2×10⁹) | 最常用整型 |
unsigned int | 4 | 0 ~ 4294967295 | 无符号整型 |
long long | 8 | 约 ±9.2×10¹⁸ | 大整数必备 |
float | 4 | 约 ±3.4×10³⁸,有效数字 6~7 位 | 单精度浮点 |
double | 8 | 约 ±1.7×10³⁰⁸,有效数字 15~16 位 | 默认浮点类型 |
char | 1 | −128 ~ 127(或 0~255) | 存单个字符 |
bool | 1 | true(1) / false(0) | 布尔 |
string | — | 可变长度 | 需 #include <string> |
void | 0 | 无值 | 用于函数无返回值 |
记忆口诀:
short2、int4、long long8、float4、double8、char1、bool1。short最大 32767(= 2¹⁵ − 1),int最大约 21 亿,long long最大约 9.2×10¹⁸(= 2⁶³ − 1)。
取值范围公式(n 位有符号):
最小值 = −2^(n−1) 最大值 = 2^(n−1) − 1
short (16 位):−2¹⁵ ~ 2¹⁵−1 = −32768 ~ 32767
int (32 位):−2³¹ ~ 2³¹−1 ≈ −2.1×10⁹ ~ 2.1×10⁹
long long(64 位):−2⁶³ ~ 2⁶³−1 ≈ ±9.2×10¹⁸
★ 怎么选类型(实用判据)
| 数据范围 | 用什么 | ||
|---|---|---|---|
| \ | x\ | ≤ 2×10⁹ | int |
| 更大 | long long | ||
| 小数 | double(不要用 float,精度不够) | ||
| 单个字符 | char | ||
| 是非判断 | bool | ||
| 一串字符 | string |
2024·23 就是考这个判据:题目要求的返回值范围远超出
int的表示能力,所以必须声明为long long。 竞赛口诀:「开 long long 保平安」——不确定就开long long,只在内存吃紧时才用int。
3.2 溢出 ★
溢出:计算结果超出该类型能表示的范围,会「绕回去」(环形回转)。
int a = 2147483647; // int 的最大值
a = a + 1; // 溢出!a 变成 -2147483648
short s = 32767;
s = s + 1; // 溢出!s 变成 -32768
防溢出的两条办法
- 换更大的类型:用
long long代替int; - 运算前先转换:
long long r = (long long)a * b;(把其中一个转成long long,整个表达式就按long long算)。
典型错误:
int a = 100000, b = 100000; long long r = a * b; // ❌ 先按 int 算出 10¹⁰ 溢出了,再赋给 long long 也晚了 long long r = (long long)a * b; // ✅ 先转型再相乘
3.3 整数除法截断 ★(2023·8 的陷阱)
两条铁律
① 两个整数相除 → 取整数部分,小数被直接丢弃(不是四舍五入)
9 / 2 = 4 (不是 4.5)
7 / 3 = 2 (不是 2.33)
-7 / 2 = -3 (向零截断)
② 只要有一个操作数是浮点型,结果才是浮点型
9.0 / 2 = 4.5
9 / 2.0 = 4.5
取余 % 的性质
a % b 的符号与被除数 a 相同
7 % 3 = 1 35 % 9 = 8 3 % 5 = 3
-7 % 3 = -1 7 % -3 = 1
2023·8 详解:
double a = 123.4; int b = a * 10; // a*10 = 1234.0(double),赋给 int → b = 1234 double c = b / 10; // ★ b 和 10 都是 int!先做整数除法 1234/10 = 123, // 再把 123 转成 double 赋给 c → c = 123.0 cout << c << endl; // 默认输出 123答案 C(123)。教训:别被外层
double c骗了,b/10的除法在赋值前就已经按整数算完了。
想做小数除法的正确写法
double c = b / 10.0; // 把 10 写成 10.0
double c = (double)b / 10; // 强制转换
double c = b * 1.0 / 10; // 乘 1.0
3.4 浮点型与精度
float | double | |
|---|---|---|
| 字节 | 4 | 8 |
| 有效数字 | 6~7 位 | 15~16 位 |
| 后缀 | 3.14f | 3.14(默认就是 double) |
★ 浮点数不能用 == 直接比较
double a = 0.1 + 0.2;
if (a == 0.3) ... // ❌ 可能不成立!0.1+0.2 的二进制表示有误差
正确做法:判断差值是否小于一个极小数
const double EPS = 1e-9;
if (fabs(a - 0.3) < EPS) ... // ✅
输出控制
cout << fixed << setprecision(2) << 3.14159; // 输出 3.14(需 #include <iomanip>)
printf("%.2f", 3.14159); // 输出 3.14
取整函数小表
| 函数 | 作用 | 例子 |
|---|---|---|
floor(x) | 向下取整(地板) | floor(2.7) = 2 |
ceil(x) | 向上取整(天花板) | ceil(2.1) = 3 |
round(x) | 四舍五入 | round(2.5) = 3 |
(int)x | 向零截断 | (int)2.9 = 2、(int)-2.9 = −2 |
3.5 char 与 bool
char:本质上是 0~127 的整数(存的是 ASCII 码)
char c = 'A';
cout << c; // 输出 A(字符形式)
cout << (int)c; // 输出 65(整数形式)
char d = 'A' + 1; // d = 'B' —— 字符可以做加减
int diff = 'D' - 'A'; // diff = 3 —— 常用技巧:求字母序号
大小写转换
char upper = c - 32; // 小写转大写
char lower = c + 32; // 大写转小写
// 或直接:toupper(c) / tolower(c)
if (c >= 'a' && c <= 'z') c = c - 'a' + 'A'; // 小写 → 大写
bool
bool flag = true; // true 就是 1
bool ok = false; // false 就是 0
cout << flag; // 输出 1
cout << (3 > 2); // 输出 1
⚠️ 非零即真:在条件判断中,任何非 0 值都当真。
if (5) cout << "真"; // 会执行 if (0) cout << "假"; // 不会执行 if (-1) cout << "真"; // 会执行(-1 非 0)
3.6 string
#include <string>
string s = "hello";
cout << s.length(); // 5(字符个数)
cout << s.size(); // 5(等价)
cout << s[0]; // 'h'(下标从 0 开始)
cout << s.substr(1, 3); // "ell"(从下标 1 开始取 3 个字符)
s = s + " world"; // 字符串可以直接相加拼接
string与char[]的区别:string可以直接用=赋值、用+拼接、用<比较;char[]必须用strcpy/strcat/strcmp。详见 DAY15。
3.7 类型转换
隐式转换(自动):小范围 → 大范围是安全的,反过来会丢数据。
char → short → int → long long → float → double
(安全方向 →)
| 转换 | 结果 |
|---|---|
int → double | 加小数点,精确(在有效数字内) |
double → int | 截断小数部分(不是四舍五入) |
int → char | 按 ASCII 取字符 |
| 大范围 → 小范围 | 可能溢出/丢精度 |
显式转换(强制)
(double)a // C 风格
double(a) // 函数风格
static_cast<double>(a) // C++ 风格(推荐)
3.8 输入输出格式符对照(与 DAY08 呼应)
| 类型 | printf / scanf 格式符 |
|---|---|
int | %d |
long long | %lld |
unsigned | %u |
float | %f |
double | %lf(scanf)/ %f(printf) |
char | %c |
string(用 char[]) | %s |
⚠️
long long用%d是经典错误——会输出乱码或错误值。
short类型变量能储存的最大整数是?( )
答案:B
破题点:short = 2 字节 = 16 位。
short 占 2 字节 = 16 位,有符号时取值范围 -32768 ~ 32767,最大值 32767。65535 是无符号 16 位的最大值;2147483647 是 int 的最大值;4294967295 是无符号 32 位的最大值。选 B。
C++定义一个字符型变量 c,并在定义时给 c 赋初始值为字符 a 的完整语句为:( )
答案:char c='a';
破题点:定义 + 赋初值写在一句里。
C++ 中「定义变量并赋初值」的标准写法是:类型 变量名 = 初值; 字符常量要用单引号。所以完整语句是 char c='a';。注意引号必须是英文单引号。- 答案:char c='a';
已知:double a=123.4;int b=a*10;double c=b/10; 则执行语句:cout<<c<<endl; 后 输出在屏幕的值为( )。
答案:C
破题点:整数除法会截断小数部分。
a = 123.4,a*10 = 1234.0,赋给 int b 得 1234(无损失);b/10 中 b 是 int、10 是 int,做整数除法得 123,再赋给 double c 就是 123.0,cout 默认输出 123。选 C。
一个 32 位整型变量占用的字节数是( )?
答案:A
破题点:32 位整型 = 4 字节。
1 字节 = 8 位,所以 32 位 ÷ 8 = 4 字节。注意题目问的是「字节数」而不是「位数」,32 是干扰项。选 A。
在 C++ 程序中定义一个返回值为范围在 -2⁴⁰ ~ 2⁴⁰ 之间的整数的函数,则该函数应声明为( )类型
答案:long long
破题点:范围 -2⁴⁰~2⁴⁰ ≈ ±10¹²,远超 int 的 ±2×10⁹。
2⁴⁰ ≈ 1.1 × 10¹²,而 int 只能表示到约 2.1 × 10⁹,装不下,必须用 64 位的 long long(范围约 ±9.2 × 10¹⁸)。答案:long long。
表达式((3 == 0) + 'A' + 1 + 3.0)的结果类型为( )。
答案:A
表达式中出现 3.0(double),整个算术表达式按 double 计算,结果为 double 类型。答案 A(double)。
常量'3'的数据类型是( )。
答案:C
字符常量用单引号括起来,'3' 是字符(char),其值为 ASCII 码 51;3 才是整数。答案 C。
如果数组定义为long long array[] = {3, 5, 7, 2};,则数组array 占用的字节数为( )。
答案:A
long long 占 8 字节,数组有 4 个元素,共 8 × 4 = 32 字节。答案 A。
32位计算机中,C++的整型变量int能够表示的数据范围是( )。
答案:C
32 位有符号 int 的范围是 -2³¹ ~ 2³¹-1,即 -2147483648 ~ 2147483647。答案 C。
在C++语言中,可以通过定义结构体,定义一个新的数据类型。
答案:A
结构体正是「用户自定义数据类型」的手段。说法正确。答案 A(正确)。
#include <iostream>
using namespace std;
int main(){
char c = 'A';
cout << c << (int)c << endl;
int x = 2147483647;
cout << x + 1 << endl;
return 0;
}程序第一行输出的内容是( )。
程序第二行输出的内容是( )。
变量 x 声明为 `int`,在常见环境下它占用 ______ 个字节。
- 第 1 题A 字符 'A' 的 ASCII 码是 65。cout << c 时按字符输出 → A;前面加了…
- 第 2 题B int 是 32 位有符号整数,最大值 2147483647。再加 1 超出上界,按补码规则…
- 第 3 题4 int 占 4 字节 = 32 位。因为 1 位是符号位,所以取值范围是 -2³¹ ~ 2³…
- 第 1 题A 两个 int 相除是整数除法,结果向零截断,9/2 = 4;算成 4.5 是把它当成了小数除法。
- 第 2 题C 赋值是最后一步,a/b 已经按整数除法算成 4 再赋给 double,所以 c = 4.0;以为 c 是 double 就能保留小数是错的。
- 第 3 题D a % b 的结果符号跟被除数 a 一致,所以 −7 % 3 = −1;以为结果永远为正或跟除数走都是错的。
- 第 4 题A long long 必须用 %lld;用 %d 会输出错误的结果,%ld 是 long 的格式符,这里同样不匹配。
- 第 5 题B double 有约 15 位有效数字,float 只有 6~7 位;需要多位精度时必须用 double。
- 第 6 题D 浮点数的二进制表示存在精度误差,0.1+0.2 不等于 0.3,所以要用 fabs(a-b) < EPS;直接用 == 比较往往永远为假。
- 第 7 题B (int) 是向零截断,5.9 变成 5 而不是 6;要四舍五入必须用 round。
- 第 8 题A 非 0 值赋给 bool 会变成 1,输出时 bool 默认打印 1 而不是 true;以为会输出原来的 5 是常见错误。
- 第 9 题B a * b 先按 int 计算会溢出,必须先把其中一个转成 long long 再相乘;只把结果声明为 long long 救不了已经溢出的乘法。
- 第 10 题D short 占 2 字节即 16 位,有符号时最大值是 2¹⁵−1 = 32767;65535 是无符号 16 位的最大值,别混用。
- 第 11 题C int 的字节数由编译环境决定,概念上应当用 sizeof 测量,只是在本竞赛环境中恰好是 4 字节;把它当成所有平台都固定是错的。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 背下常用类型的字节数:short 2、int 4、long long 8、float 4、double 8、char 1、bool 1
- 记住 short 最大 32767、int 最大约 2147483647,并写出 n 位有符号整数的范围公式 −2^(n−1) ~ 2^(n−1)−1
- 算三组结果并解释:9/2=4、9%2=1、9.0/2=4.5,说明整数除法会向零截断
- 演算 −7/2=−3、−7%3=−1,并记住取余结果的符号跟着被除数走
- 对比 (int)5.9=5、floor(5.9)=5.0、ceil(5.9)=6.0、round(5.9)=6.0,分清「向零截断」和「四舍五入」
- 记住大数相乘要先转型:写成 (long long)a * b;浮点数比较用 fabs(a-b) < 1e-9 而不是 ==
- 默写 §3.1 数据类型总表(字节数 + 范围)
- 手算一遍 2023·8 那道「整数除法」题,直到理解为什么输出 123
- 完成客观题 10 题(
DAY07-01~DAY07-10) - 完成阅读程序小片段 1 组
本日关键记忆:short 2 / int 4 / long long 8 / double 8 · short 最大 32767 · int 约 ±2.1×10⁹ · 整数除法截断 ·
a%b符号跟 a · 大数先转 long long 再乘 · double 别用 == · 非零即真
数据的输入与输出
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2023 | 第 7 题 | 单项选择 | 1 分 |
难易度:较易(★★☆☆☆) 近 4 年合计:1 题 / 1 分
2026 年备考建议
输入输出是初赛里最划算的一类考点:知识不难,但格式符和细节一大堆,命题人只要在阅读程序里塞进一行 scanf、printf,就能筛掉一批粗心学生;它又能和字符串、循环、数组随意组合,出题成本极低,所以年年都少不了。
因此要把常用格式符焊死在脑子里:int 用 %d、long long 用 %lld、double 在 scanf 里用 %lf(printf 才写 %f)、字符用 %c 且前面加空格以免读到换行;scanf 的取地址符只有 %s 例外,cin 遇空格就停、读整行要用 getline,保留小数必须 fixed 配 setprecision。
②知识地图 · 本考点思维导图
- C++ 流式输入输出(cin / cout)
- << 输出运算符 >> 输入运算符
- 连续输出、连续输入
- endl 与 '\n' 的区别
- cin 遇空格/回车停止
- 整行输入
- getline(cin, s)
- C 风格输入输出(scanf / printf)
- 格式符表(%d %lld %f %lf %c %s)
- 必须取地址 &(字符串数组除外)
- 格式化:保留几位小数、域宽、补零
- 输出格式控制
- fixed + setprecision(n)
- printf("%.2f")
- 常用技巧
- 字符/字符串读入的坑
- 输入加速
- 高频错误
- 忘记 & / 格式符与类型不匹配
- cin 与 scanf 混用
③核心精讲
3.1 C++ 流式输入输出:cin / cout
先记方向(最容易记反)
cout << "hello"; // 数据从"程序"流"到"屏幕 —— 尖角朝左
cin >> a; // 数据从"键盘"流"到"变量 —— 尖角朝右
记忆口诀:
cout是「出去」,箭头往外指<<;cin是「进来」,箭头往里指>>。
基本用法
#include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a >> b; // 连续输入:空格或回车分隔
cout << a + b << endl; // 输出并换行
cout << a << " " << b << "\n"; // 中间加空格
return 0;
}
cin >> 的特点
| 特点 | 说明 |
|---|---|
| 自动跳过空白 | 空格、Tab、回车都会被自动跳过 |
| 遇空白停止 | 读字符串时,读到空格就停 |
| 自动类型转换 | cin >> a(a 是 int)会把字符流按整数解析 |
⚠️
cin >> s读字符串时,遇到空格就停。 输入Hello World,cin >> s只读到Hello。 要读整行(含空格),必须用getline:string s; getline(cin, s); // 读入一整行,包含空格
3.2 endl 与 '\n' 的区别
| 写法 | 作用 | 说明 |
|---|---|---|
'\n' | 换行 | 只换行,不刷新缓冲区,效率高 |
endl | 换行 + 刷新输出缓冲区 | 保证立即显示,但速度较慢 |
结论:大量输出时用
'\n'更高效;需要即时看到输出(比如调试)时才用endl。
3.3 C 风格输入输出:scanf / printf
#include <cstdio>
int main() {
int a; long long b; double c; char d;
scanf("%d%lld%lf", &a, &b, &c); // ★ 变量前要加 &
scanf(" %c", &d); // 读单个字符,前面加空格跳过空白
printf("%d %lld %.2f %c\n", a, b, c, d);
return 0;
}
★ 格式符对照表(必背)
| 数据类型 | scanf | printf | 说明 |
|---|---|---|---|
int | %d | %d | |
long long | %lld | %lld | 最容易记错的一个 |
unsigned int | %u | %u | |
short | %hd | %hd | |
float | %f | %f | |
double | %lf | %f | ⚠️ scanf 要用 lf,printf 用 f |
char | %c | %c | |
char[](字符串) | %s | %s | 不加 & |
| 十六进制 | %x | %x | |
| 八进制 | %o | %o |
★ 两个高频坑
坑 ① 忘记 &
int a;
scanf("%d", a); // ❌ 缺少 &,程序可能崩溃
scanf("%d", &a); // ✅ 必须取地址
例外:读字符串数组
char s[100]; scanf("%s", s);—— 数组名本身就是地址,不加&。
坑 ② double 在 scanf 里用 %f
double x;
scanf("%f", &x); // ❌ 类型不匹配,读数错误
scanf("%lf", &x); // ✅
记忆:scanf 要「长一点」(lf),printf 短一点(f)。
3.4 输出格式控制
保留小数(两种写法都对)
// 写法 1:C++ 流式
#include <iomanip>
cout << fixed << setprecision(2) << 3.14159 << endl; // 3.14
// 写法 2:printf
printf("%.2f\n", 3.14159); // 3.14
⚠️
setprecision单独使用表示有效数字个数,加上fixed后才表示小数点后位数:
setprecision(3)→3.14(3 位有效数字)fixed << setprecision(3)→3.142(小数点后 3 位)
域宽与补零
printf("%5d\n", 42); // " 42"(宽度 5,右对齐补空格)
printf("%05d\n", 42); // "00042"(补零)
printf("%-5d|\n", 42); // "42 |"(左对齐)
printf("%8.3f\n", 3.14159); // " 3.142"
输出百分号、反斜杠
printf("50%%\n"); // 输出 50%(%% 表示一个 %)
cout << "a\\b"; // 输出 a\b
转义字符表
| 转义符 | 含义 |
|---|---|
\n | 换行 |
\t | 制表符(相当于按一次 Tab) |
\' | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
\0 | 空字符(字符串结束标志) |
\r | 回车(回到行首) |
3.5 读入单个字符的坑
int n; char c;
cin >> n;
cin >> c; // ❌ 如果上一行输入后面留了空格,c 会读到空格
三种解决办法
// ① 加一个「吞掉空白」的操作
cin >> n;
cin.ignore(); // 忽略一个字符
cin >> c;
// ② 用 scanf 时在 %c 前加一个空格
scanf("%d", &n);
scanf(" %c", &c); // 注意 %c 前有个空格 —— 表示"跳过所有前导空白"
// ③ 用 getchar 循环跳过换行
while (cin.peek() == '\n' || cin.peek() == ' ') cin.get();
规律:
%c和cin >> c都不会自动跳过空白;要跳过就在格式串里手写一个空格。
3.6 输入加速(了解,上机有用)
ios::sync_with_stdio(false); // 关闭 C 与 C++ 流的同步
cin.tie(0); // 解除 cin 与 cout 的绑定
加了这两句,
cin/cout的速度接近scanf/printf。注意:加完之后不要混用scanf和cin。
3.7 cin/cout 与 scanf/printf 混用的风险
int n;
cin >> n;
scanf("%d", &n); // ⚠️ 不推荐:两个缓冲区不同步,可能读到旧数据
建议:一套程序里只用一种。要么全用
cin/cout,要么全用scanf/printf。 如果确实要混用,加上ios::sync_with_stdio(false);之前的情况更危险——加了同步(默认开启)其实还是安全的,但加了sync_with_stdio(false)之后混用就会出问题。
在 C++中使用流进行输入输出,其中用于屏幕输出的对象是 ( )
答案:C
破题点:cout = 标准输出;cin = 标准输入;cerr = 标准错误。
C++ 中 cout 是标准输出流对象(C 对);cin 是标准输入;cerr 用于输出错误信息(虽也是输出,但题干问「用于屏幕输出的对象」,标准答案取 cout);cfile 不是标准流对象。选 C。
下面C++代码执行后,输出的是( )。
int main()
{
int x[]={2, 0, 2, 4};
char geSP[]="Grade Examination of SP";
cout << geSP[sizeof(x)] << endl;
cout << endl;
return 0;
}答案:C
sizeof(x) 求的是数组字节数 = 4 个 int = 16,所以取 geSP[16]。"Grade Examination of SP" 的第 16 个字符是 n(下标 0 从 G 起数)。答案 C。
C++语句printf("5%%2={%d}\n",5 % 2) 执行后的输出是( )。
答案:C
printf 中 %% 输出一个百分号,%d 输出整数。5%2=1,所以输出 5%2={1}。答案 C。
C++语句printf("6%2={%d}", 6%2) 执行后的输出是( )。
答案:D
同理:%% 输出 %,%d 输出 6%2=0,结果是 6%2={0}。答案 D。
有关下列C++代码的说法,正确的是( )。
printf("Hello,GESP!");答案:D
把 "Hello,GESP!" 写成三个连续双引号("" "Hello,GESP!" ""),编译器会把相邻的字符串常量自动拼接,输出效果不变。答案 D。
以下哪个是C++语言的关键字?( )
答案:C
do 是 C++ 循环关键字(do-while)。main 是函数名、cout 是流对象、string 是类型名。答案 C。
下面的C++代码用于求M天后是星期几,两处横线处分别应填入的代码是( )。
int N, M, D;
cout << "当前星期几? "; // 星期日是0
cin >> N;
cout << "求多少天后? "; // 输入正整数
cin >> M;
D = ____________;
if ( )
printf("%d天后是星期日", M);
else
printf("%d天后是星期%d", M, D);答案:B
求星期几要用取余:(N + M) % 7;若结果为 0 说明是星期日,所以判断条件是 D == 0。答案 B。
在C++的程序中,不能用scanf 作为变量名。( )
答案:B
scanf 是标准库函数名,不是 C++ 关键字,因此可以作为变量名(虽然不推荐这么做)。说法错误。答案 B(错误)。
C++语句printf("%d#%d&",2,3) 执行后输出的是2#3&。 ( )
答案:A
printf("%d#%d&",2,3) 中 # 和 & 是普通字符原样输出,结果 2#3&。说法正确。答案 A(正确)。
下列程序输出的是3。( )
string str="CHADai";
size_t pos = str.find('D');
cout<<pos<<endl;答案:A
str = "CHADai",字符依次为 C(0) H(1) A(2) D(3) a(4) i(5),find('D') 返回下标 3。说法正确。答案 A(正确)。
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
double x = 3.14159;
cout << fixed << setprecision(2) << x << endl;
printf("%d\n", 7 / 2);
return 0;
}程序第一行输出的内容是( )。
程序第二行输出的内容是( )。
要让 `printf` 输出实数变量 x 且保留一位小数(如 3.5),格式串应写成 printf("______", x);
- 第 1 题A fixed 表示固定小数位输出,setprecision(2) 表示保留 2 位小数,所以 …
- 第 2 题A 7 和 2 都是整数,/ 做整数除法,结果直接截断小数部分得 3,因此 %d 输出 3。写成…
- 第 3 题%.1f printf 的格式符要背:%d 整数、%lld long long、%c 字符、%s 字符…
- 第 1 题A scanf 要把数据写进变量,除字符串数组外必须用 & 取地址;写成 scanf("%d", a) 会因缺少 & 而读写非法内存。
- 第 2 题C long long 在 scanf 里必须用 %lld;用 %d 只会读入一个 int 的大小,高 32 位丢失,数值直接出错。
- 第 3 题B scanf 读 double 必须用 %lf,%f 只对应 float;printf 输出 double 时才写 %f,两者正好相反。
- 第 4 题B cout << 表示往外输出,cin >> 表示往里输入,尖角指向数据流动的方向;方向记反是新手最常见的错误。
- 第 5 题C cin >> 和 scanf 的 %s 遇到空格就停,都读不了整行;读一整行含空格的字符串要用 getline(cin, s)。
- 第 6 题D setprecision(2) 单独用时控制的是有效数字位数,只有配上 fixed 才表示保留 2 位小数。
- 第 7 题B %c 前的空格表示跳过空白字符(空格、换行、制表符),这样才不会把上一次输入留下的回车当成读入的字符。
- 第 8 题D 两套输入输出各有缓冲区,混用容易错序;真想混用就别关 sync_with_stdio,最稳妥的做法是整份程序只用一套。
- 第 9 题C 换行必须自己写 '\n' 或 endl,两者都能换行,区别只在于 endl 还会刷新缓冲区;漏写换行会被判格式错误。
- 第 10 题C 功能上都能换行,但 endl 多了一步刷新缓冲区,效率较低;大量输出时优先用 '\n'。
- 第 11 题A 在格式串里 % 是引导符,要输出一个真正的百分号必须写成两个 %% ;只写一个 % 会导致未定义行为。
- 第 12 题D string 不是 C 风格字符串,不能直接交给 %s;要用 s.c_str() 转成字符指针,或者干脆用 cout << s 输出。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写 cin / cout 的用法和箭头方向,各写一条含输入与输出的完整语句
- 默写 int、long long、double、char 在 scanf 中对应的格式符,以及 printf 输出 double 保留两位小数的写法
- 写出 cin/cout 保留 2 位小数的完整写法,并说明需要包含哪个头文件
- 说明 scanf("%s", s) 中 s 不加 & 的原因,写出读入含空格整行的正确函数
- 写出 printf("%05d", 42) 的输出结果,以及转义字符 \t、\\、\0 各代表什么
- 说明把 string 直接传给 printf 的 %s 会出什么问题,写出两种正确改法
- 手写一遍「
cin/cout版」和「scanf/printf版」的同一段程序(输入两个整数、输出和) - 背熟 §3.3 格式符对照表
- 完成客观题 10 题(
DAY08-01~DAY08-10) - 完成阅读程序小片段 1 组
本日关键记忆:
cout <</cin >>·cin>>遇空格停 →getline读整行 ·endl刷新缓冲 ·%lld给 long long ·scanf用%lf给 double · 忘&是大错 ·" %c"跳过空白 ·fixed << setprecision(n)
运算符与表达式(上)· 算术与赋值
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 7 题 | 单项选择 | 1 分 |
| 2022 | 第 8 题 | 单项选择 | 1 分 |
| 2022 | 第 24 题 | 填空题 | 3 分 |
| 2023 | 第 4 题 | 单项选择 | 1 分 |
| 2023 | 第 12 题 | 单项选择 | 2 分 |
| 2023 | 第 16 题 | 单项选择 | 2 分 |
| 2023 | 第 17 题 | 单项选择 | 2 分 |
| 2024 | 第 24 题 | 填空题 | 3 分 |
| 2025 | 第 26 题 | 单项选择 | 2 分 |
难易度:中等(★★★☆☆) 近 4 年合计:9 题 / 17 分
2026 年备考建议
运算符是全卷名副其实的第一大分块,单选加填空能占到四十多分,命题人自然爱在这里设卡。难点不在会不会,而在算得细不细:优先级、结合方向、自增自减的先后、整数除法的截断,任何一处记错,一整道题就没了。
要抓的点很具体:取余只能用于整数、结果符号跟着被除数,复合赋值先把右边整体算完,前缀加加先加后用、后缀先用后加,赋值优先级极低而单目最高,同级从左到右;(int)3.9 是截断得 3,整数除法先按整数算完再赋值,大数相乘先把第一个数转成 long long。
②知识地图 · 本考点思维导图
- 算术运算符 + - * / %
- 整除 / → 整数除法截断
- 取余 % → 符号与被除数一致
- 优先级 * / % 高于 + -
- 赋值运算符 =
- 左值右值、从右往左结合
- 连续赋值 a = b = c = 0
- 复合赋值运算符
- += -= *= /= %=
- 自增自减运算符
- 前缀 ++i / --i(先自增,再使用)
- 后缀 i++ / i--(先使用,再自增)
- 与赋值混合使用的求值顺序陷阱
- 类型转换与精度丢失
- 隐式转换(小→大安全,大→小丢数据)
- 强制转换
③核心精讲
3.1 算术运算符
| 运算符 | 名称 | 说明 | 例子 |
|---|---|---|---|
+ | 加 | 3 + 5 = 8 | |
- | 减 | 也可作负号 | 3 - 5 = -2 |
* | 乘 | 3 * 5 = 15 | |
/ | 除 | 整数相除 → 截断小数 | 9 / 2 = 4 |
% | 取余(模) | 只能用于整数 | 9 % 2 = 1 |
★ 整除 / 的三条规则
两个整数相除 → 结果取整数部分,小数直接丢弃(向零截断)
9 / 2 = 4 7 / 3 = 2 -7 / 2 = -3
只要有一个是浮点型 → 结果就是浮点型
9.0 / 2 = 4.5 9 / 2.0 = 4.5
★ 取余 % 的三条规则
① a % b 的符号与被除数 a 一致(不是数学家口中的"非负余数")
7 % 3 = 1 35 % 9 = 8 3 % 5 = 3
-7 % 3 = -1 7 % -3 = 1
② 被除数是 0 时会崩溃(除零错误)
③ 只能用于整数,不能写 5.5 % 2(编译错误)
2022·7:
35 % 9→ 35 ÷ 9 = 3 余 8(答案 D) 2023·16:3 % 5→ 3 比 5 小,商 0 余 3(答案 A) 易错:很多同学以为「小数 % 大数 = 0」,其实答案是被除数本身。
常见用途
| 用途 | 写法 |
|---|---|
| 判断偶数 | n % 2 == 0 |
| 判断能否被 3 整除 | n % 3 == 0(2022·22 答案 a%3==0) |
| 取出个位数字 | n % 10 |
| 去掉个位数字 | n / 10 |
| 循环取数位 | while (n > 0) { int d = n % 10; n /= 10; } |
填空易错点:
a%3==0里的双等号不能写成单等号。a%3=0是「给a%3赋值」——而a%3不是变量,会编译错误。 另外,==与=混淆是全卷最高频的低级错误(DAY12 还会重点讲)。
3.2 优先级与结合性(上)
从高到低(本节涉及部分)
| 级别 | 运算符 | 结合方向 | ||
|---|---|---|---|---|
| 1 | () 括号 | 从左到右 | ||
| 2 | ! ~ ++ -- 单目 + - | 从右到左(单目) | ||
| 3 | * / % | 从左到右 | ||
| 4 | + - | 从左到右 | ||
| 5 | << >>(输出输入/移位) | 从左到右 | ||
| 6 | < <= > >= | 从左到右 | ||
| 7 | == != | 从左到右 | ||
| 8 | & ^ ` | ` | 从左到右 | |
| 9 | && | 从左到右 | ||
| 10 | ` | ` | 从左到右 | |
| 11 | ?: 三目 | 从右到左 | ||
| 12 | = += -= … 赋值 | 从右到左 | ||
| 13 | , 逗号 | 从左到右 |
记住三句关键话: ① 括号优先级最高 —— 不确定就加括号,这是最省事的策略。 ②
*/%同级,高于+-;同级从左往右算。 ③ 赋值运算符优先级很低,且从右往左结合。
2024·24 详解:
int a = 126 % 6 * 2 - 10;第一步:126 % 6→%与*同级、从左往右 →126 % 6 = 0第二步:0 * 2 = 0第三步:0 - 10 = -10答案 −10。 ⚠️ 注意这个式子是(126 % 6) * 2 - 10,不是126 % (6*2) - 10。加减乘除取余是「同级从左到右」,取余不会先跟后面的乘法结合。
3.3 赋值运算符
int a; // 定义
a = 5; // 赋值:把右边的值给左边
int b = a; // 定义 + 初始化
四条要点
| 要点 | 说明 |
|---|---|
| 左边必须是变量(左值) | 5 = a; 是编译错误 |
| 结合方向从右到左 | a = b = c = 0; 等价于 a = (b = (c = 0)); |
| 赋值表达式的值 = 被赋的值 | cout << (a = 3); 输出 3 |
| 类型不同会自动转换 | int a = 3.9; → a = 3(截断) |
★ 经典陷阱:x = y; y = x; 换不了值(2022·24)
int x = 3, y = 6;
x = y; // 第一步:x 变成 6(x 原来的 3 被覆盖,永远丢失了)
y = x; // 第二步:y = 6(因为 x 现在是 6)
// 结果:x = 6, y = 6 —— 答案 "6 6"
正确交换两个变量的三种写法
// ① 借助临时变量(最推荐)
int t = x; x = y; y = t;
// ② 加减法(不用临时变量,但可能溢出)
x = x + y; y = x - y; x = x - y;
// ③ 异或法(不用临时变量,不会溢出)
x = x ^ y; y = x ^ y; x = x ^ y;
// ④ C++ 标准库函数
swap(x, y); // 需 #include <algorithm>
3.4 复合赋值运算符 ★
| 写法 | 等价于 | 说明 |
|---|---|---|
a += b | a = a + b | |
a -= b | a = a - b | |
a *= b | a = a * b | |
a /= b | a = a / b | 整数时仍会截断 |
a %= b | a = a % b |
2023·12 详解:
int a = 12; a += a * a;展开:a = a + a * a—— 右边整体先算完再赋回a * a = 144(用的是原来的 a = 12)→a = 12 + 144 = 156答案 C。 ⚠️ 易错:不要写成a = (a + a) * a = 288,也不要以为a*a里的 a 会跟着更新——右边是一次性算完的。
2023·17 详解:设
int b, a = 5;下列哪个表达式使 b 等于 2? A.b = a / 2→ 5 / 2 = 2 ✅ B.b = 6 - (a--)→a--取当前值 5,6 - 5 = 1❌ C.b = a % 2→ 5 % 2 = 1 ❌ D.b = a > 3 ? 3 : 2→5 > 3成立 → 取 3 ❌ 答案 A。
3.5 自增自减运算符 ★★ 最高频的坑
| 写法 | 名称 | 含义 | 口诀 |
|---|---|---|---|
++i | 前缀自增 | 先自增,再使用 | 先加后用 |
i++ | 后缀自增 | 先使用,再自增 | 先用后加 |
--i | 前缀自减 | 先自减,再使用 | 先减后用 |
i-- | 后缀自减 | 先使用,再自减 | 先用后减 |
单独使用时:++i; 和 i++; 效果完全一样(都让 i 加 1)。 只有和别的运算混在一起时,才有区别。
int a = 5, b;
b = ++a; // a 先变 6,再把 6 给 b → a = 6, b = 6
b = a++; // 先把 5 给 b,a 再变 6 → a = 6, b = 5
在表达式中混用的经典例子
int i = 5;
int x = i++ + i++; // ⚠️ 这类写法属于"未定义行为",不要这么写、也不必纠结
// 竞赛题一般不会出这种;若出现,按命题人意图逐步展开
int y = i++ + 1; // 安全:y = 5 + 1 = 6,之后 i = 6
int z = ++i + 1; // 安全:i 先变 6,z = 6 + 1 = 7
2023·4 直接考优先级:下列运算符中优先级最高的是
*=、++、&&、>=→++(单目运算符,优先级仅次于括号)答案 B。 记忆:单目 > 算术 > 关系 > 逻辑 > 三目 > 赋值。
循环中的两种写法(结果相同)
for (int i = 0; i < n; i++) { ... } // 常用
for (int i = 0; i < n; ++i) { ... } // 等价且略高效(少了临时对象)
3.6 类型转换与精度丢失
隐式转换的方向
安全(不会丢数据)
char → short → int → long long → float → double
反向 → 可能丢数据
| 转换 | 结果 | 说明 |
|---|---|---|
int → double | 加小数点 | 3 → 3.0 |
double → int | 截断 | 3.9 → 3(不是 4!) |
int → char | 按 ASCII 取字符 | 65 → 'A' |
int / int | 整数除法 | 7 / 2 → 3 |
int / double | 浮点除法 | 7 / 2.0 → 3.5 |
★ 精度丢失的两个场景
// 场景 1:整数除法截断
double avg = sum / n; // ❌ sum 和 n 都是 int → 结果已截断
double avg = sum * 1.0 / n; // ✅
double avg = (double)sum / n; // ✅
// 场景 2:大数相乘溢出
int a = 100000, b = 100000;
long long r = a * b; // ❌ 先按 int 算,溢出
long long r = (long long)a * b; // ✅
★ 2025·26 详解(自增与赋值混用的经典陷阱)
int a = 3, b = 4;
a = b * (b = 3 * a - b);
cout << a;
逐步分析(按命题意图):
第一步:先算括号里的 (b = 3 * a - b)
此时 a = 3, b = 4 → 3 * 3 - 4 = 5 → b 变成 5
第二步:再算 b * 5
此时 b 已经是 5 → 5 * 5 = 25
第三步:a = 25
输出:25 → 答案 A
⚠️ 严格来说这属于未定义行为(同一表达式里既读又写
b),标准并未规定求值顺序。但竞赛题按命题意图给答案 A。 学习重点不是背这个答案,而是记住:不要把「读」和「改」同一个变量写在同一个表达式里。
在 C++程序中,35%9的运算结果是?( )
答案:D
破题点:整数取余:35 ÷ 9 = 3 余 8。
% 是取余运算,只保留除法后的余数。35 ÷ 9 = 3 余 8,所以结果 8。注意 A 是实数除法的结果,C++ 里两个整数相除不产生小数。选 D。
在 C++程序中,9/2的运算结果是?( )
答案:C
破题点:两个整数相除,小数部分直接丢掉。
9 和 2 都是 int,/ 执行整数除法:9 ÷ 2 = 4.5,截断小数部分得 4。要得到 4.5 必须写成 9 / 2.0 或 9.0 / 2。选 C。
int x=1,y=6;
执行 x=y;y=x;后,x 和 y 的值分别为多少( )(两值用空格隔开)。答案:6 6
破题点:x=y 覆盖了 x 的原值,y 已不是原来的别人。
初值 x=3、y=6。执行 x=y 后 x 变成 6(x 原来的 3 被覆盖丢弃);再执行 y=x,此时 x 已经是 6,所以 y 也变成 6。结果 x=6、y=6。这道题是「交换两个变量必须借助第三个临时变量」的反面教材。答案:6 6。
以下运算符中,优先级最高的是:( )
答案:B
破题点:优先级:单目 > 算术 > 关系 > 逻辑 > 赋值。
四个运算符的优先级由高到低:++(单目自增)> >=(关系)> &&(逻辑与)> *=(复合赋值)。所以最高的是 ++。记忆口诀:「单目 > 算术 > 关系 > 逻辑 > 三目 > 赋值」。选 B。
设 ”int a=12; ”,则执行完语句 ”a+=a*a; ”后,a 的值是( )。
答案:C
破题点:a+=a*a 相当于 a = a + (a*a)。
复合赋值 a += X 等价于 a = a + X,其中 X 用运算前 a 的值计算。a=12,X = 12×12 = 144,所以 a = 12 + 144 = 156。注意 a 参与右侧计算时用的仍是旧值 12。选 C。
在 C++程序中,3%5 的运算结果是?( )
答案:A
破题点:被除数比除数小,商 0 余自己被除数。
3 % 5:3 除以 5 商 0 余 3,所以结果是 3。规律:当 a < b 且都为正数时,a % b = a。选 A。
设变量 int b,a = 5; 下列( )表达式计算后,使得变量 b 的值等于 2 ?
答案:A
破题点:逐个选项代入 a=5 算一遍。
a = 5。A:b = 5/2 = 2(整数除法)✓。B:b = 6 - (a--) = 6 - 5 = 1(a 自减为 4)。C:b = 5%2 = 1。D:a>3 为真,b = 3。只有 A 得到 2。选 A。
int a=126%6*2-10 执行后,a 的值为( )。
答案:-10
破题点:先算 %,再算 *,最后算 -。
126 % 6 = 0(126 = 21×6),0 × 2 = 0,0 - 10 = -10。乘除取余同级、从左到右,加减最后。答案:-10。
运行以下程序,输出结果是( )?
int a = 3;
int b = 4;
a = b * (b = 3 * a - b);
cout << a;答案:A
破题点:赋值运算符右侧先算完,b 的新值再参与乘法。
a=3、b=4。计算右侧 b * (b = 3*a - b):先算括号内的赋值,3×3-4 = 5,b 变成 5,括号表达式的值为 5;再算外面的乘法,注意此时左侧的 b 也已经是 5(同一个变量),所以是 5 × 5 = 25,赋给 a。选 A。
如果用两个int 类型的变量a 和b 分别表达长方形的长和宽,则下列哪个表达式不能用来计算长方形的周长?
答案:A
长方形周长 = (长 + 宽) × 2。a + b * 2 由于乘法优先,算的是 a + 2b,不能表示周长;正确应写 2*(a+b)。答案 A。
下列关于C++语言变量的叙述,正确的是( )。
答案:D
赋值语句执行后变量值「可能不变」——例如 a = a; 或 a = 5 时本来就等于 5。这句话正确。答案 D。
在C++语言中,注释不宜写得过多,否则会使得程序运行速度变慢。
答案:B
注释是给程序员看的,编译时会被完全剔除,不会进入可执行程序,因此不会影响运行速度。说法错误。答案 B(错误)。
下列关于C++语言的叙述,正确的是( )。
答案:B
两个 int 相乘结果仍是 int。若超出 int 范围会溢出,这正是「两数相乘前要留心数据类型」的原因。答案 B。
for(int i = 1; i < 10; i += 3;) ; 表示i从1开始到10结束间隔为3,相当于1、4、7、10。( )
答案:B
for(int i=1; i<10; i+=3) 中条件是 i<10,所以 i 取 1、4、7(下一个 10 不满足 i<10),不是 1、4、7、10。答案 B(错误)。
#include <iostream>
using namespace std;
int main(){
int a = 5, b = 2;
int c = a++ + b;
cout << a << " " << b << " " << c << endl;
return 0;
}程序输出为( )。
关于 ++a 与 a++,下列叙述正确的是( )。
表达式 5 % 3 * 2 的值是 ______。
- 第 1 题A a++ 是**后置**自增:先把 a 的旧值 5 参与加法,算完 c = 5 + 2 = 7…
- 第 2 题B 口诀:「前置先加后用,后置先用后加」。两种写法最终 a 都会加 1,区别只在**参与本次运算…
- 第 3 题4 取余 % 与乘法 * 同级,从左到右:5 % 3 = 2,再 2 * 2 = 4。若误以为先…
- 第 1 题B % 的操作数必须是整数,浮点数不能取余;结果的符号跟随被除数,所以 -7 % 3 得 -1,而不是正数。
- 第 2 题A 被除数小于除数时余数就是被除数本身,3 % 5 等于 3,不是 0;这是最容易想当然做错的地方。
- 第 3 题A 判断相等要用两个等号 ==;写成一个等号 a = 0 是赋值,表达式值为 0,条件恒为假,是经典陷阱。
- 第 4 题D 复合赋值先把右边整体算完:a = a + a * a = 12 + 144 = 156;算成 (a+a)*a = 288 是把优先级搞反了。
- 第 5 题C 直接用 x=y; y=x; 会让两个变量都变成原来的 y;必须先用临时变量把 x 保存起来再交换。
- 第 6 题B 前缀 ++i 先加再用,后缀 i++ 先用后加;单独写成一条语句时两者效果相同,一旦参与赋值或运算差别就出来了。
- 第 7 题B 单目运算符优先级最高,赋值运算符几乎垫底、只高于逗号;同级运算符除赋值和三目外都是从左往右算。
- 第 8 题D % 和 * 优先级相同,同级从左到右:先算 126 % 6 = 0,再算 0 * 2 = 0;改变顺序结果就不同了。
- 第 9 题B 强制类型转换成 int 是直接截断小数部分,得 3;要四舍五入必须用 round 函数,不能靠强制转换。
- 第 10 题C 两边都是整数的除法先按整数算完,7 / 2 = 3,再赋给 double 得到 3.0;想保留小数要写 sum * 1.0 / n。
- 第 11 题D 两个 int 相乘会先按 int 算完再提升,早就溢出了;必须把其中一个操作数先转成 long long,乘法才会按 64 位进行。
- 第 12 题D 同一个表达式里对 i 既读又改,标准没有规定求值顺序,结果不可预期;正确做法是拆成两条语句。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 手算并写出 35 % 9、3 % 5、9 / 2、9.0 / 2、-7 / 2、-7 % 3 的结果
- 用取余和整除各写一句表达式,分别取出整数 n 的个位、去掉个位
- 手推 int a = 12; a += a * a; 的值并写出计算顺序,写出 x += 3 的等价形式
- 写出 ++i 与 i++ 的区别,分别手算 int a = 5; b = ++a; 与 b = a++; 的结果
- 写出 (int)3.9 的值并说明与四舍五入的区别,写出整数除法得到小数的正确写法
- 把 + = ++ && 按优先级从高到低排序,并手算 126 % 6 2 - 10
- 手算 §3.4 的三道例题(
a+=a*a、b=a/2、126%6*2-10) - 默写「正确交换两个变量」的两种写法
- 完成客观题 14 题(
DAY09-01~DAY09-14) - 完成阅读程序小片段 1 组
本日关键记忆:整数除法截断 ·
a%b符号跟被除数 · 小数%大数=小数本身 ·a+=a*a右边整体先算 ·++i先加后用 /i++先用后加 · 单目优先级最高 · 赋值优先级最低 · 交换要用临时变量
运算符与表达式(下)· 关系逻辑位运算与三目
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 19 题 | 单项选择 | 2 分 |
| 2022 | 第 22 题 | 填空题 | 3 分 |
| 2022 | 第 31 题 | 阅读程序 | 3 分 |
| 2022 | 第 32 题 | 阅读程序 | 3 分 |
| 2022 | 第 33 题 | 阅读程序 | 3 分 |
| 2023 | 第 22 题 | 填空题 | 3 分 |
| 2024 | 第 15 题 | 单项选择 | 2 分 |
| 2024 | 第 18 题 | 单项选择 | 2 分 |
| 2025 | 第 15 题 | 单项选择 | 2 分 |
| 2025 | 第 21 题 | 单项选择 | 2 分 |
| 2025 | 第 22 题 | 单项选择 | 2 分 |
难易度:较难(★★★★☆) 近 4 年合计:11 题 / 27 分
2026 年备考建议
位运算在普及组复赛里不算好考,但放进初赛的阅读程序却能很方便地拉开区分度——会位运算和不会的,一眼就分得出来。它还能顺带考察学生对二进制的理解,又极易和编解码、状态压缩结合,命题人用起来实在太顺手,这几年明显在升温。
除了会写 &、|、^、~、<<、>>,还要把几个结论记熟:n & 1 判奇偶,n << 3 相当于乘 8,~0 等于 -1 而 !0 等于 1,德摩根律里与要变或;优先级从高到低是 !、算术、关系、& ^ |,最后才是 && 和 ||。三目从右往左结合,优先级只比赋值高一点;记住:位运算是按位来的,逻辑运算是看真假的。
②知识地图 · 本考点思维导图
- 关系运算符 == != > < >= <=
- 结果是 1(真)/ 0(假)
- ★ 区分 == 与 =
- 逻辑运算符 && || !
- 真值表
- ★ 短路求值
- ★ 德摩根律
- 位运算符 & | ^ ~ << >>
- 按位运算真值表
- 常见用途(判奇偶 / 乘除 2 的幂 / 交换 / lowbit)
- 三目运算符 ?:
- 基本形式:条件 ? 值1 : 值2
- ★ 嵌套 + 从右往左结合
- 优先级与结合性(总表)
③核心精讲
3.1 关系运算符
| 运算符 | 含义 | 例子 | 结果 |
|---|---|---|---|
== | 等于 | 3 == 3 | 1 |
!= | 不等于 | 3 != 3 | 0 |
> < | 大于 / 小于 | 5 > 3 | 1 |
>= <= | 大于等于 / 小于等于 | 5 <= 3 | 0 |
三条要点
① 关系运算的结果是 bool:真为 1,假为 0
cout << (3 > 2); // 输出 1
cout << (3 < 2); // 输出 0
② ★★ == 和 = 一定要分清
if (a == 3) 判断 a 是否等于 3
if (a = 3) 把 3 赋给 a,然后判断 a(非零→真)—— 这是超高频错误!
③ 关系运算符的优先级高于赋值,低于算术
3 + 4 > 5 等价于 (3 + 4) > 5 → 1
★ 2024·22 就考了
if(a = 0)已知a的值为 0,执行if(a = 0);时条件真假如何? →a = 0是赋值,把 0 赋给 a,整个表达式的值是 0 → 条件为假(false)。 这里注意区分:if (a = 0)永远是假;if (a = 1)永远是真(不管原来 a 是多少)——这就是经典的「赋值代替比较」bug。
浮点数不能用 == 比较(回看 DAY07)
if (fabs(a - b) < 1e-9) ... // ✅
3.2 逻辑运算符 ★★
| 运算符 | 名称 | 运算规则 | ||
|---|---|---|---|---|
! | 逻辑非 | 真变假、假变真(单目) | ||
&& | 逻辑与 | 两个都为真才是真 | ||
| `\ | \ | ` | 逻辑或 | 有一个为真就是真 |
真值表(必背)
| A | B | !A | A && B | `A \ | \ | B` |
|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 0 | ||
| 0 | 1 | 1 | 0 | 1 | ||
| 1 | 0 | 0 | 0 | 1 | ||
| 1 | 1 | 0 | 1 | 1 |
数学符号对照(真题用这种写法)
∧= 且 =&&∨= 或 =||¬= 非 =!
★ 短路求值(极重要)
A && B :如果 A 为假,B 根本不会被计算(直接返回假)
A || B :如果 A 为真,B 根本不会被计算(直接返回真)
短路的两个典型用法
// 用法 1:防止数组越界("护栏"技巧)
if (i < n && a[i] > 0) { ... }
// 如果 i >= n,&& 右边不会执行,不会越界访问 a[i]
// 用法 2:防止除零
if (b != 0 && a / b > 2) { ... }
考试提示:题目里若出现
f(x) && g(x)这种带函数调用的形式,要注意短路导致某个函数不被调用——这是阅卷时的常见失分点。
★ 德摩根律(化简逻辑式必备)
¬(A ∧ B) = ¬A ∨ ¬B
¬(A ∨ B) = ¬A ∧ ¬B
口诀:「非」可以拆进括号,但里面的 ∧ 要变 ∨、∨ 要变 ∧。
★ 2023·22 详解
bool P, Q;
bool st = (!P || !Q) && P && Q;
cout << st;
无论 P、Q 取什么值,结果都是 0。为什么?
- 若
P = 0:右边&& P已经是假 → 整体假 → 0 - 若
Q = 0:右边&& Q已经是假 → 整体假 → 0 - 若
P = 1且Q = 1:左边(!P || !Q) = (0 || 0) = 0→ 整体假 → 0
答案:0。
更快的看法:这个式子里既有
P&&Q,又要求P&&Q为真时左边也得为真,而左边恰恰要求「P 或 Q 至少有一个是假」——自相矛盾,永远为假。
3.3 位运算符 ★(2025 新热点)
先把数写成二进制,然后逐位运算。
| 运算符 | 名称 | 规则 | |
|---|---|---|---|
& | 按位与 | 两位都是 1 才得 1 | |
| `\ | ` | 按位或 | 两位有一个是 1 就得 1 |
^ | 按位异或 | 两位不同得 1,相同得 0(「相异为 1」) | |
~ | 按位取反 | 0 变 1、1 变 0(单目) | |
<< | 左移 | 整体左移,右边补 0 = 乘 2ⁿ | |
>> | 右移 | 整体右移,左边补符号位 = 除以 2ⁿ |
真值表
| a | b | a&b | `a\ | b` | a^b |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 0 | 1 | 0 | 1 | 1 | |
| 1 | 0 | 0 | 1 | 1 | |
| 1 | 1 | 1 | 1 | 0 |
常见用途
| 用途 | 写法 | |
|---|---|---|
| 判断奇偶 | n & 1(1 = 奇,0 = 偶) | |
| 取最低位的 1(lowbit) | n & (-n) | |
| 消掉最低位的 1 | n & (n - 1) | |
| 乘 2 的幂 | n << k(= n × 2ᵏ) | |
| 除 2 的幂 | n >> k(= n ÷ 2ᵏ) | |
| 交换两数 | a ^= b; b ^= a; a ^= b; | |
| 置位 / 清位 / 翻转 | `x \ | = (1<<k)、x &= ~(1<<k)、x ^= (1<<k)` |
★ 2025·22 详解:~((a & b) | ~(a ^ b)) 等价于 a 与 b 进行什么运算?
逐位枚举(a、b 各取 0/1 四种情况):
| a | b | a&b | a^b | ~(a^b) | `(a&b)\ | ~(a^b)` | ~(...) |
|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 | 1 | 0 | |
| 0 | 1 | 0 | 1 | 0 | 0 | 1 | |
| 1 | 0 | 0 | 1 | 0 | 0 | 1 | |
| 1 | 1 | 1 | 0 | 1 | 1 | 0 |
最后一列 0、1、1、0 —— 与 a ^ b 完全一致 → 答案 D(按位异或)。
代数化简法(更快):
~(X | Y) = ~X & ~Y(位运算也适用德摩根律)~((a&b) | ~(a^b)) = ~(a&b) & ~~(a^b) = ~(a&b) & (a^b)而~(a&b) = ~a | ~b,且(a^b) = (~a&b) | (a&~b),展开后恰好等于a^b。
3.4 三目运算符 ?: ★★
基本形式
条件 ? 值1 : 值2
条件为真 → 取值1;条件为假 → 取值2
int max = (a > b) ? a : b; // 求最大值
int abs = (x >= 0) ? x : -x; // 求绝对值
cout << (n % 2 == 0 ? "even" : "odd");
★ 嵌套与结合性:从右往左结合(先算后面的 ?)
w < x ? w : y < z ? y : z
等价于:
w < x ? w : ( y < z ? y : z )
★ 2022·19 详解:w=1, x=2, y=3, z=4,求 w<x ? w : y<z?y:z
- 外层条件
w < x→1 < 2= 真 → 取第一个分支w= 1 - (既然外层为真,冒号后面的嵌套部分根本不参与计算)
答案 D(1)
★ 2024·15 详解:x=1, y=2, z=4,求 (x % 2 == 1) ? x > z : y < z ? 1 : 0
- 条件
x % 2 == 1→1 % 2 = 1,1 == 1= 真 - 取第一个分支
x > z→1 > 4= 假 → 值为 0
答案 A(0)
⚠️ 注意:三目运算符的「值1」或「值2」本身又是一个关系表达式,所以结果会是 0 或 1,而不是 x 或 z 的值!
★ 2025·15 详解:a=7, b=3, c=5,求 (a%b == c/b) ? (a-c) : (b*c)
a % b = 7 % 3 = 1c / b = 5 / 3 = 1(整数除法!)1 == 1= 真 → 取a - c = 7 - 5 = 2
答案 A(2)
陷阱:如果误把
5/3当成 1.67,就会判断为「不等」,从而错选 15。
3.5 优先级与结合性总表 ★
| 优先级 | 运算符 | 结合方向 | ||
|---|---|---|---|---|
| 1(最高) | () [] . -> :: | 左→右 | ||
| 2 | ! ~ ++ -- +(正) -(负) *(解引用) &(取址) sizeof 单目 | 右→左 | ||
| 3 | * / % | 左→右 | ||
| 4 | + - | 左→右 | ||
| 5 | << >> | 左→右 | ||
| 6 | < <= > >= | 左→右 | ||
| 7 | == != | 左→右 | ||
| 8 | &(按位与) | 左→右 | ||
| 9 | ^(按位异或) | 左→右 | ||
| 10 | `\ | `(按位或) | 左→右 | |
| 11 | && | 左→右 | ||
| 12 | `\ | \ | ` | 左→右 |
| 13 | ?: | 右→左 | ||
| 14 | = += -= *= /= %= | 右→左 | ||
| 15(最低) | , 逗号 | 左→右 |
三句保命口诀
① 单目 > 算术(* / % 高于 + -) > 移位 > 关系 > 相等 > 位与 > 位异或 > 位或 > 逻辑与 > 逻辑或 > 三目 > 赋值
② 只有「单目、三目、赋值」是从右往左结合,其余都从左往右
③ 不确定就加括号 —— 括号不会扣分,算错才会
2023·4 详解:下列运算符中优先级最高的是
*=、++、&&、>=→++是单目运算符,优先级仅次于括号,答案 B。
2025·21 详解:
A=0, B=1, C=1,求(¬A ∧ B) ∨ (A ∨ C) ∧ (¬B ∧ C)第一步:¬A = 1→(1 ∧ 1) = 1第二步:¬B = 0→(0 ∧ C) = (0 ∧ 1) = 0第三步:(A ∨ C) = (0 ∨ 1) = 1→1 ∧ 0 = 0第四步:1 ∨ 0 = 1答案 B(1) ⚠️ 注意∧(与)的优先级高于∨(或),所以先算各处 ∧,再算 ∨。
若w=1,x=2,y=3,z=4,则条件表达式w<x ? w: y<z?y:z的值是( )。
答案:D
破题点:三目运算符右结合,先算右边那一层。
w=1, x=2, y=3, z=4。条件 w<x 即 1<2 为真,所以取冒号前的分支 w(值为 1);后面的 y<z?y:z 因为条件已命中而不必计算。结果 1。选 D。
C++判断一个整型变量 a,能被 3 整除的条件是 if( )。
答案:a%3==0
破题点:「能被 3 整除」= 除以 3 的余数为 0。
整除的判定必须用取余:a % 3 == 0。注意 == 是比较,= 是赋值;写成 a % 3 = 0 会编译错误,写成 a / 3 == 0 则逻辑错误(只有 a<3 时才成立)。答案:a % 3 == 0。
已知主函数中 bool P,Q,且 bool st=(!P||!Q)&&P&&Q,无论 P 和 Q 为何初值(保证 合法),在执行 cout<<st;语句后,屏幕上输出的结果是( )。
答案:0
破题点:把 st 化成 P∧Q∧¬(P∨Q)… 用真值表快速排除。
st = (!P || !Q) && P && Q。若 P、Q 均为真:(!P||!Q) 为假,整个表达式为假。若 P 假:则 P 为假,与运算为假。若 Q 假:同理为假。所以无论 P、Q 取何值 st 恒为 0(false),cout 输出 0。答案:0。
若 x=1,y=2,z=4,则条件表达式(x % 2 == 1) ? x > z: y < z ? 1 : 0 的值是( )。
答案:A
破题点:三目右结合;条件为真时直接取第一个分支。
x=1, y=2, z=4。(x % 2 == 1) 即 1%2==1 为真,于是取分支 x > z,即 1 > 4,结果 0(关系表达式为假时值为 0)。选 A。
A=1,B=0,下列式子恒为 1 的是( )。
答案:C
破题点:A=1、B=0 代入逐项化简。
A=1(真)、B=0(假)。C 项:A ∨ (¬A ∨ B) ∧ B = 1 ∨ (...∧0) = 1 ∨ 0 = 1,恒为 1。A 项:(¬1∨0)∧(1∨0)∨0 = (0∧1)∨0 = 0。B 项:(0∨0)∨(1∨1)∧0 = 0∨0 = 0。D 项:B∧...∧¬B 中 B 与 ¬B 同时出现,必为 0。选 C。
若 a=7,b=3,c=5,则表达式(a%b == c/b) ? (a-c):(b*c)的值是( )。
答案:A
破题点:先算两侧的关系表达式,再决定走哪个分支。
a=7, b=3, c=5。a%b = 7%3 = 1;c/b = 5/3 = 1(整数除法)。1 == 1 为真,取分支 a-c = 7-5 = 2。选 A。
已知 A=0,B=1,C=1,则表达式(¬A ∧ B) ∨ (A ∨ C) ∧ (¬B ∧ C)的结果是
( )。
答案:B
破题点:∧ 先于 ∨;¬ 优先级最高。
A=0, B=1, C=1。(¬A ∧ B) = (1 ∧ 1) = 1。(A ∨ C) ∧ (¬B ∧ C) = (0∨1) ∧ (0∧1) = 1 ∧ 0 = 0。1 ∨ 0 = 1。选 B。
~( (a & b) | ~(a ^ b) )的结果等价于 a 与 b 进行( )运算。
答案:D
破题点:德摩根律:~(X | Y) = ~X & ~Y;再把 ~(a^b) 展开。
用 ~(X|Y) = ~X & ~Y 拆开:~( (a&b) | ~(a^b) ) = ~(a&b) & (a^b)。又 ~(a&b) = ~a | ~b。所以原式 = ( ~a | ~b ) & (a^b)。逐位验证可得它恰好等于 a^b(异或):a≠b 时 a^b=1,此时 ~a|~b 中必有一个为 1,与 1 相与得 1;a=b 时 a^b=0,结果为 0。所以等价于按位异或。选 D。
如果a 为int 类型的变量,且a 的值为6,则执行a *= 3;之后,a 的值会是( )。
答案:D
a *= 3 等价于 a = a * 3 = 6 × 3 = 18。答案 D。
以下哪个不是C++语言中的运算符?( )
答案:D
** 不是 C++ 运算符(那是 Python 的幂运算符)。C++ 的乘方要用 pow() 函数。答案 D。
if 语句中的条件表达式的结果必须为bool 类型。
答案:B
if 的条件可以是任意数值表达式:非 0 为真、0 为假,不必是 bool 类型。说法错误。答案 B(错误)。
如果a 为int 类型的变量,b 为char 类型的变量,则下列哪个语句不符合 C++语法?( )
答案:D
(int)b = a; 中 (int)b 是强制转换后的临时值(右值),不能再被赋值;正确写法是 b = (char)a; 或 b = a;。答案 D。
定义变量char c,下面对c 赋值的语句,不符合语法的是()。
答案:D
char 的强制转换要写成 (char)66,char 66 这种写法非法。答案 D。
在C++代码中,运算符只能处理相同的数据类型,不同类型之间必须转换为相同的数据类型。( )
答案:B
不同类型的运算数会自动进行隐式类型转换(如 int + double 按 double 算),不需要程序员手动转换。说法错误。答案 B(错误)。
#include<iostream>
using namespace std;
int main()
{
int a,x,y,ok1,ok2;
a=100;
cin>>x>>y>>ok1>>ok2;
if((x>y) || ((y!=20) && (ok1==0)) && (ok2!=0))
a=1;
else if((ok1!=0) && (ok2==0))
a= -1;
else a=0;
cout<<a<<endl;
return 0;
}输入数据:20 20 5 0
输出数据:( )
输入数据:30 20 5 0
输出数据:( )
输入数据:10 20 0 0
输出数据:( )
- 第 1 空-1 逐步代入,注意 || 与 && 的「短路」:左边已能定结果时右边不再计算。
- 第 2 空1 逐步代入,注意 || 与 && 的「短路」:左边已能定结果时右边不再计算。
- 第 3 空0 逐步代入,注意 || 与 && 的「短路」:左边已能定结果时右边不再计算。
- 第 1 题A a = 0 是赋值表达式,值为 0 即假,所以条件永远不成立;想判断相等必须写 if (a == 0)。
- 第 2 题C && 左边为假就直接判定整体为假,右边不再执行;反过来 || 是左边为真时右边不算,两者都要利用来防止越界。
- 第 3 题B ∧ 相当于 &&,∨ 相当于 ||,&& 优先级高于 ||,所以先算所有与、再算或;记混会整句求值全错。
- 第 4 题D 德摩根律是取反后要把 与 变 或、或 变 与:!(A && B) = !A || !B;只改符号不改运算符是最常见的错。
- 第 5 题B 三目运算符和赋值一样是从右往左结合,嵌套时先算右边那一组;顺序搞反,嵌套三目的结果就会错。
- 第 6 题C 条件成立后取的是分支表达式 x > z 的值,即 1 > 4 的结果 0,而不是 x 或 z 本身;这是三目最容易踩的坑。
- 第 7 题C & 逐位做与运算,&& 只判断真假并有短路;例如 5 & 3 得 1,而 5 && 3 只得到真值 1,含义完全不同。
- 第 8 题A 位运算符里 & 高于 ^ 高于 |,且这三个都高于逻辑的 &&;把 & 和 && 的先后记反是失分主因。
- 第 9 题D n & 1 取的是最低位,正好就是奇偶标志,对正数而言与 n % 2 结果一致,但位运算更快。
- 第 10 题C 三目优先级很低,只比赋值高一点;在复杂表达式里最好加括号,否则很容易被别的运算符抢先结合。
- 第 11 题A 三目必须三个操作数齐全:条件 ? 真值 : 假值,缺 ? 或 : 都会编译错误。
- 第 12 题D ~ 是单目按位取反,把 0 变成全 1 即 -1;! 是逻辑非,把 0 变成 1。一个是位运算、一个是逻辑运算,绝不能混。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 写出 !、&&、|| 的真值表,并各举一个短路求值的例子
- 用德摩根律化简 !(A && B),写出 ∧、∨、¬ 分别对应的 C++ 运算符
- 手推 5 & 3、5 | 3、5 ^ 3 的二进制过程,并写出 ~0 和 !0 的值
- 说明 n & 1 判断奇偶、n << 3 相当于乘几,写出三目运算符的结合方向
- 手算 w=1,x=2,y=3,z=4 时 w<x ? w : y<z?y:z 的值,以及 (x%2==1)?x>z:0 这类分支取值的陷阱
- 把 && = ! + || 按优先级从高到低排序,并说明三目运算符优先级的位置
- 默画
!&&||真值表,默写德摩根律 - 手算 §3.4 的三道三目题 + §3.3 的位运算等价题
- 背熟优先级总表的「三句口诀」
- 完成客观题 14 题(
DAY10-01~DAY10-14) - 完成阅读程序小片段 1 组
本日关键记忆:
==≠=· 短路求值 · 德摩根律(∧变∨)· ∧优先于∨ · 三目从右往左 · 三目分支里的关系式得 0/1 ·&≠&&·~≠!· 单目 > 算术 > 关系 > 逻辑 > 三目 > 赋值
顺序结构、算法基础与流程图
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 13 题 | 单项选择 | 2 分 |
难易度:较易(★★☆☆☆) 近 4 年合计:1 题 / 2 分
2026 年备考建议
顺序结构、算法基础和流程图看起来像送分的概念题,其实是阅读程序题的元知识。命题人喜欢拿它考算法五大特征、流程图符号和三种基本结构,因为这些概念一清楚,学生读程序的能力就上一个台阶;概念一含糊,后面读程序、完善程序都会吃亏。
要记牢:五大特征是有穷性、确定性、可行性、输入、输出,输入可以是 0 个、输出至少 1 个;流程图里菱形是判断框、矩形是处理框、平行四边形是输入输出框、圆角矩形是起止框;while 先判断后执行、do-while 先执行后判断;一重循环 O(n)、双重循环 O(n²)、二分查找 O(log n)。
②知识地图 · 本考点思维导图
- 算法基础
- 定义:解决问题的有限步骤序列
- ★ 五大特征:有穷性 · 确定性 · 可行性 · 输入 · 输出
- 描述方式:自然语言 · 流程图 · 伪代码 · 程序语言
- 流程图
- 符号:起止框(圆角矩形)· 处理框(矩形)· 判断框(菱形)
- 输入输出框(平行四边形)· 连接点(圆)· 流程线(箭头)
- 三种基本结构:顺序 · 选择(分支)· 循环
- 三种基本结构
- 顺序结构:一条一条往下执行
- 分支结构:if / switch(DAY12)
- 循环结构:for / while / do-while(DAY13)
- 时间复杂度初步
- O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)
- 常量与表达式的求值顺序
- 顺序点、副作用、未定义行为
③核心精讲
3.1 算法的定义与五大特征 ★
定义:算法是为解决某个问题而设计的一组有穷的、确定的、可执行的操作步骤。
★ 五大特征(必背)
| 特征 | 含义 | 反例 |
|---|---|---|
| 有穷性 | 必须在有限步之后结束 | 死循环不是算法 |
| 确定性 | 每一步都有确定的定义,不能有歧义 | 「取一个合适的数」不是算法 |
| 可行性 | 每一步都可以被分解为基本可执行操作 | 「判断这个数是不是完全数」若不可判定则不行 |
| 输入 | 有 0 个或多个输入 | 可以没有输入 |
| 输出 | 必须有至少一个输出 | 没有输出就不叫算法 |
★ 2022·13 答案 C:题目问「不正确的描述」,C 项说「算法一定要有输入,但是可以没有输出」——恰好把输入输出说反了。正确说法是:可以有 0 个输入,但必须有输出。
另外两项的表述也都是标准定义:A「必须保证在有限步之后结束」= 有穷性;B「每一步必须有确定的定义」= 确定性;D「每一步都可以被分解为基本的可执行操作」= 可行性。
记忆口诀:「有穷、确定、可行、可无输入、必有输出」。
3.2 算法的三种描述方式
| 方式 | 优点 | 缺点 |
|---|---|---|
| 自然语言 | 好懂 | 容易有歧义、啰嗦 |
| 流程图 | 直观,逻辑清晰 | 复杂算法画不下 |
| 伪代码 | 接近程序,便于转成代码 | 不是严格语言,不能直接运行 |
| 程序语言(C++) | 可直接运行 | 需要掌握语法 |
3.3 流程图符号 ★
| 符号 | 形状 | 含义 |
|---|---|---|
| 起止框 | 圆角矩形 / 椭圆 | 开始 / 结束 |
| 处理框 | 矩形 | 执行一个操作(赋值、计算) |
| 判断框 | 菱形 | 条件判断,有「是/否」两条出口 |
| 输入输出框 | 平行四边形 | 输入(cin)/ 输出(cout) |
| 连接点 | 小圆圈 | 连接断开的两段流程线 |
| 流程线 | 带箭头的线 | 表示执行方向 |
| 注释框 | 虚线框 | 说明性文字 |
流程图的三种基本结构
① 顺序结构——从上到下依次执行
┌─────────────┐
│ 开始 │
└──────┬──────┘
↓
┌─────────────┐
│ 读入 a, b │
└──────┬──────┘
↓
┌─────────────┐
│ c = a + b │
└──────┬──────┘
↓
┌─────────────┐
│ 输出 c │
└──────┬──────┘
↓
┌─────────────┐
│ 结束 │
└─────────────┘
② 选择(分支)结构——菱形判断框分流
┌─────────┐
│ 条件? │
└──┬───┬──┘
是 ↓ ↓ 否
┌──────┐ ┌──────┐
│ 操作A │ │ 操作B │
└───┬──┘ └───┬──┘
└───┬────┘
↓
③ 循环结构——「当型」与「直到型」
当型(while) 直到型(do-while)
┌──────────┐ ┌──────────┐
│ 条件? │←─────┐ │ 循环体 │←─────┐
└──┬────┬──┘ │ └────┬─────┘ │
真 ↓ ↓ 假 │ ↓ │
┌──────┐ ↓ │ ┌──────────┐ │
│ 循环体│──┘ │ │ 条件? │──真──┘
└──────┘ │ └────┬─────┘
│ 假 ↓
↓ ↓
区别:当型(while)先判断后执行,可能一次都不执行;直到型(do-while)先执行后判断,至少执行一次。
3.4 三种基本结构
| 结构 | C++ 语法 | 特点 |
|---|---|---|
| 顺序 | 一条语句接一条语句 | 从前往后依次执行 |
| 选择(分支) | if / if-else / switch | 根据条件选一条路走 |
| 循环 | for / while / do-while | 重复执行某段代码 |
定理(结构化程序设计):任何算法都可以只用这三种基本结构组合出来。这就是为什么「顺序、分支、循环」写在同一条大纲里。
2024·16 就考最基础的一条:
include、if、while、double中哪个是循环关键字 →while(答案 C)。 顺便记住:for、while、do都是循环关键字;if、else、switch、case是分支关键字。
3.5 时间复杂度初步(了解 · 阅读程序会涉及)
时间复杂度:算法运行时间随问题规模 n 增长的量级。
| 量级 | 名称 | 例子 |
|---|---|---|
O(1) | 常数阶 | 一次赋值、一次访问 |
O(log n) | 对数阶 | 二分查找、每次砍一半 |
O(n) | 线性阶 | 一重循环遍历 |
O(n log n) | 线性对数阶 | 快速排序、归并排序 |
O(n²) | 平方阶 | 双重循环(冒泡、选择排序) |
O(n³) | 立方阶 | 三重循环 |
O(2ⁿ) | 指数阶 | 枚举所有子集 |
O(n!) | 阶乘阶 | 全排列枚举 |
规模判断(竞赛经验值)
| n 的量级 | 可以接受的复杂度 |
|---|---|
| 10⁸ 左右 | O(n) |
| 10⁴ 左右 | O(n²) |
| 100 左右 | O(n³) |
| 20 左右 | O(2ⁿ) |
计算技巧:只看循环嵌套的层数和各层循环的次数。
for (i=0; i<n; i++)→ O(n)for (i=0; i<n; i++) for (j=0; j<n; j++)→ O(n²)- 二分:
while (l <= r) { mid = (l+r)/2; ... }→ 每次区间减半 → O(log n)
3.6 表达式的求值顺序与「副作用」
顺序点(sequence point):分号 ;、&&、||、逗号 , 等位置,前面的求值必须完成后才继续。
副作用(side effect):表达式除了「算出值」之外还改了东西(如 i++、a = 5)。
★ 重要规则:不要在同一个表达式里对同一个变量既读又改。
int i = 5; int x = i++ + i++; // ❌ 未定义行为,不同编译器结果不同 a = b * (b = 3*a - b); // ❌ 同上(2025·26 这类题按命题意图作答)正确做法:拆成多条语句。
常见可安全使用的写法
int i = 5;
int a = i++; // a = 5, i = 6 ✅ 只有一处读、一处改
int b = ++i; // i 先变 6 → b = 6 ✅
下列关于算法的描述,不正确的是( )。
答案:C
破题点:算法的五大特征:有穷性、确定性、可行性、有输入、有输出。
算法的五大特征是有穷性、确定性、可行性、有输入、有输出。「可以没有输出」是错的——算法必须至少产生一个输出,否则这个算法就没有意义。所以不正确的描述是 C。选 C。
以下关于递推算法基本思想的描述,正确的是( )。
答案:B
递推的核心是「已知初值 + 递推关系 → 逐步推出更大规模的解」,这正是 B 的描述。答案 B。
一个算法可以用不同的形式来描述,但要求描述比较规范,因此不能用自然语言描述。
答案:B
算法可以用自然语言、流程图、伪代码、程序等多种形式描述,规范与否取决于写法而非载体。说法错误。答案 B(错误)。
某算法的递推关系式为 T(n) = T(n − 1) + n(n为正整数)及 T(0) = 1,则该算法的时间复杂度为O(n²)。
答案:A
T(n) = T(n-1) + n 展开得 T(n) = 1 + (1+2+…+n) = O(n²)。递推式里每一项做 O(1) 的工作、共 n 层且每层代价递增,是 O(n²)。答案 A(正确)。
下列关于C++语言的叙述,不正确的是( )。
答案:C
缩进只是为了好看,C++ 用花括号 {} 界定语句块,编译器完全不看缩进,所以缩进不能「消除二义性」。答案 C。
如果要找出整数a、b 中较大一个,通常要用下面哪种程序结构?( )。
答案:C
比较大小需要先判断再选择执行,属于分支(选择)结构。答案 C(分支结构)。
以下选项中,不能用于表示分支结构的C++保留字是?( )
答案:B
分支结构的保留字是 if、else、switch、case、default;return 用于从函数返回,不表示分支。答案 B。
for 语句的循环体至少会执行一次。
答案:B
for 循环先判断条件再执行循环体,若首次判断就不成立,循环体一次也不执行。说法错误。答案 B(错误)。
#include <iostream>
using namespace std;
int main(){
int a = 3, b = 7;
int t = a;
a = b;
b = t;
cout << a << " " << b << endl;
return 0;
}程序输出为( )。
这段程序实现的功能是( )。
若把第 5 行的 `int t = a;` 改成 `int t = b;`,程序输出为 ______。(两数以空格隔开)
- 第 1 题A 逐条跟踪:t = 3(存下 a 的原值);a = 7(a 被 b 覆盖);b = 3(用 t…
- 第 2 题B 借助第三个变量 t 交换两个变量的值,是顺序结构的经典三行式。若删掉 int t = a; …
- 第 3 题7 7 t = 7;a = b = 7;b = t = 7。原值 3 被彻底覆盖,两个变量都是 7。…
- 第 1 题D 五大特征是有穷性、确定性、可行性、输入、输出;输入允许 0 个,输出必须至少有一个,二者要求不同。
- 第 2 题C 有穷性指算法在有限步后必然结束,这是它区别于一般计算过程的关键;把有穷性理解成输入有限是偷换概念。
- 第 3 题C 菱形用来表示判断(分支条件),矩形用来表示处理(计算、赋值);这两个符号最常被互换着记错。
- 第 4 题C 平行四边形表示输入输出,圆角矩形(或椭圆)表示起止;两者外形相近,容易被故意调换。
- 第 5 题B 当型循环对应 while,先判断条件再进循环体;直到型循环对应 do-while,先执行一次再判断,所以至少跑一次。
- 第 6 题A 三种基本结构是顺序、选择、循环,其中顺序结构最基础,赋值和输入输出本质上都是顺序执行。
- 第 7 题C 两层都是 n 次的循环总次数是 n²,复杂度 O(n²);快速排序、归并排序是 O(n log n),二分查找是 O(log n)。
- 第 8 题B 外层每跑一次,内层都要完整跑 n 次,总次数是乘法 n × n = n²,不是把两层相加。
- 第 9 题D 同一表达式里对 i 既读又改,求值顺序没有规定,属未定义行为;要拆成多条语句写才安全。
- 第 10 题A 可行性指算法的每一步都能由基本操作切实完成,与效率高低无关;把可行性理解成高效是典型误解。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写算法五大特征,说明输入和输出各有几个是必需的
- 写出描述算法的四种方式,并说出菱形、矩形、平行四边形、圆角矩形各代表什么
- 默写程序的三种基本结构,说明当型循环与直到型循环的区别及对应的 C++ 语句
- 从 for、if、while、do、switch、return 中挑出所有循环关键字
- 写出一重循环、双重循环、二分查找的时间复杂度,说明双重循环总次数为什么是乘不是加
- 说明 i++ + i++ 这类写法为什么不可靠
- 默写算法五大特征,并解释「输入可以没有、输出必须有」
- 手画三种基本结构的流程图(顺序 / 分支 / 循环)
- 阶段二总结:语言基础 7 天(框架/变量/类型/IO/运算符×2/算法基础)覆盖单选约 26 题 / 44 分 + 填空 21 分
- 完成客观题 8 题(
DAY11-01~DAY11-08) - 完成阅读程序小片段 1 组
本日关键记忆:有穷·确定·可行·输入(可无)·输出(必有) · 菱形=判断/平行四边形=输入输出/圆角=起止 · 顺序·分支·循环 · while 先判断、do-while 先执行 · O(1)<O(log n)<O(n)<O(n log n)<O(n²)
分支结构
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 20 题 | 单项选择 | 2 分 |
| 2024 | 第 16 题 | 单项选择 | 2 分 |
| 2024 | 第 22 题 | 填空题 | 3 分 |
难易度:中等(★★★☆☆) 近 4 年合计:3 题 / 7 分
2026 年备考建议
分支结构语法很浅,却是阅读程序、完善程序的主干,命题人最爱在逻辑陷阱上下功夫:悬空 else 配哪个 if、switch 少了 break 会穿透成什么样、0 < x < 10 为什么恒真,这些都是年年出现的老朋友,一旦掉进坑里就会连着丢分。
要掌握到什么程度?if 的三种形态要能随手写,else 永远配最近的、尚未配对的 if(与缩进无关),if (a = 0) 是赋值恒为假、要写 a == 0;switch 的 case 必须是常量表达式且不支持范围,break 负责跳出;else if 阶梯从最严格的条件开始判,浮点数不能用 == 比较。
②知识地图 · 本考点思维导图
- 三种 if 形态
- 单分支:if (条件) 语句;
- 双分支:if (条件) 语句A; else 语句B;
- 多分支:if … else if … else if … else
- 条件表达式的真假
- 非零即真(0 为假,其余全为真)
- 嵌套 if 与「悬空 else」
- ★ else 与最近的、未配对的 if 配对
- 复合语句
- 多条语句要用 { } 包起来
- switch 多分支
- case / default / break
- ★ 没有 break 会「穿透」
- 高频陷阱
- if (a = 0) 赋值代替比较
- if (条件); 多余的分号
- 0 < x < 10 数学写法在 C++ 中无效
- 浮点数直接用 == 比较
③核心精讲
3.1 if 的三种形态
① 单分支
if (条件) {
语句;
}
② 双分支
if (条件) {
语句A;
} else {
语句B;
}
③ 多分支(else if 阶梯)
if (score >= 90) {
cout << "优秀";
} else if (score >= 80) {
cout << "良好";
} else if (score >= 60) {
cout << "及格";
} else {
cout << "不及格";
}
⚠️ 多分支的执行顺序是「从上往下,命中即停」。所以判断顺序很重要——如果把
score >= 60写在最前面,那 95 分也会被判成「及格」。
④ 三目运算符(if-else 的简写)
int max = (a > b) ? a : b; // 等价于 if (a>b) max=a; else max=b;
3.2 条件表达式的真假:非零即真 ★
if (5) cout << "真"; // ✅ 执行(5 非 0)
if (0) cout << "假"; // ❌ 不执行
if (-1) cout << "真"; // ✅ 执行(-1 非 0)
if (0.0) cout << "假"; // ❌ 不执行
if ('a') cout << "真"; // ✅ 执行('a' = 97 非 0)
if ("") // 字符串字面量是地址,非 0 → 真(这是个坑,别这么写)
规则一句话:只有 0 和 false 是假,其他全是真。
bool flag = 5; // flag 变成 true(1)
int n = true; // n = 1
3.3 ★ 悬空 else(dangling else)—— 真题最爱考
规则:else 与最近的、还没有配对的 if 配对,与缩进无关。
if (a > 0)
if (b > 0)
cout << "A";
else
cout << "B"; // ★ 这个 else 属于内层 if (b > 0),不是外层!
加花括号就能改变配对关系
if (a > 0) {
if (b > 0) cout << "A";
} else {
cout << "B"; // ★ 现在这个 else 属于外层 if (a > 0)
}
★ 2022·20 详解(原卷缩进很乱,考查的正是这个规则)
1 if (a < b)
2 if (c < d)
3 x = 1;
4 else if (a < c)
5 if (b < d)
6 x = 2;
7 else
8 x = 3;
9 else
10 x = 6;
11 else
12 x = 7;
给定 a=1, b=5, c=4, d=3:
| 步骤 | 判断 | 结果 |
|---|---|---|
| 外层 | a < b → 1 < 5 | 真,进入内层 |
| 第 1 层 | c < d → 4 < 3 | 假 → 跳到第 4 行的 else if |
| 第 2 层 | a < c → 1 < 4 | 真 → 进入第 5 行的 if |
| 第 3 层 | b < d → 5 < 3 | 假 → 执行第 8 行的 else |
| 结果 | x = 3 |
答案 C(3)
破题方法:不要靠缩进猜配对,从最内层往外层逐层画括号,把每个
else配到最近的未配对if上。
3.4 switch 多分支与「穿透」★
switch (表达式) {
case 常量1:
语句组1;
break; // ★ 没有 break 就会往下"穿透"
case 常量2:
语句组2;
break;
default: // 都不匹配时执行(default 位置可放在任意处)
语句组3;
break;
}
五条必须记住的规则
| 规则 | 说明 |
|---|---|
| ① 表达式必须是整型或字符型 | 不能用 double、string |
② case 后必须是常量 | 不能写变量,也不能写范围(case 1..5 ❌) |
③ 没有 break 会穿透 | 匹配后继续往下执行所有 case 的语句,直到遇到 break 或结束 |
④ default 可选 | 可以放在任意位置,通常放最后 |
⑤ 各 case 值不能重复 | 重复会编译错误 |
★ 穿透的正确利用(多个 case 共用同一段代码)
switch (grade) { case 'A': case 'B': cout << "合格"; break; // A 和 B 走同一分支 case 'C': cout << "待定"; break; default: cout << "不合格"; }
穿透导致的经典错题(2024·24 附带代码)
int a = 2;
switch (a) {
case 1: printf("1");
case 2: printf("2");
case 3: printf("3");
}
a = 2 → 匹配 case 2,但后面没有 break:
- 先执行
printf("2") - 穿透执行
printf("3") - 到达 switch 结尾,结束
输出 23(不是 2!)
3.5 高频陷阱
陷阱 ①:== 写成 =(2024·22 考过)
int a = 0;
if (a = 0); // ★ 这是赋值!a 被赋为 0,表达式值为 0 → 条件为「假」(false)
if (a = 1); // ★ a 被赋为 1,条件恒为「真」,不管原来 a 是多少
防错技巧:把常量写在左边 ——
if (0 == a)。这样误写成if (0 = a)会编译报错。
陷阱 ②:if 后面多写了一个分号
if (a > 0); // ★ 分号使 if 语句体变成"空语句"
cout << "正数"; // 这一行总是无条件执行!
陷阱 ③:数学式 0 < x < 10 在 C++ 中不成立
if (0 < x < 10) // ❌ 等价于 (0 < x) < 10 → 结果永远是 1 < 10 = 真
if (x > 0 && x < 10) // ✅ 正确写法
原因:
(0 < x)先算,得到 0 或 1,再拿 0 或 1 与 10 比 —— 恒为真。这是必考陷阱。
陷阱 ④:多条语句忘记加花括号
if (a > 0)
cout << "正数";
cout << "很大"; // ❌ 这一行不在 if 管辖范围内,总会执行
陷阱 ⑤:浮点数用 == 比较
if (a == 0.3) // ❌
if (fabs(a - 0.3) < 1e-9) // ✅
陷阱 ⑥:else if 写成 else if(中间不能换行拆开写)
else if (...) // ✅
else
if (...) // ⚠️ 语法上能过,但逻辑上变成嵌套,等价但易混
小明写程序时很不注意格式的规范,当他写完下面一段程序后自己也看不清程序逻辑了,请大家帮他分析一下:当 a=1, b=5, c=4, d=3 时,执行完这段程序后 x 的值是( )。
1 if(a<b)
2 if(c<d)
3 x=1;
4 else if(a<c)
5 if(b<d)
6 x=2;
7 else
8 x=3;
9 else
10 x=6;
11 else
12 x=7;
答案:C
破题点:先把缩进还原成 if-else 配对,再逐层判断。
还原缩进后:外层 if(a<b)=1<5 为真;内层 if(c<d)=4<3 为假,转 else if(a<c)=1<4 为真;再进 if(b<d)=5<3 为假,走 else 得 x=3。选 C。
下列关键字中, ( )是循环关键字。
答案:C
破题点:循环关键字:for / while / do-while。
while 是循环关键字(与 for、do 同属循环语句)。include 是预处理指令,if 是分支关键字,double 是数据类型关键字。选 C。
C++程序中有已知整型变量 a 的值为 0,那么执行 if(a = 0);语句时 if 语句内条件 真假情况为( )。 (填写 true 或 false)
答案:false
破题点:if(a = 0) 是赋值不是比较,赋值表达式的值就是被赋的值。
if 括号里写的是 a = 0(赋值),不是 a == 0(比较)。赋值表达式的值等于赋给变量的值,即 0;C++ 中 0 表示假,所以条件为 false。这是一类高频陷阱题:多写一个等号就完全变了意思。答案:false。
以下哪个不是C++语言的关键字?( )
答案:D
endl 是标准库中的流操纵符(函数),不是 C++ 关键字;int、for、double 才是关键字。答案 D。
以下不是C++关键字的是( )。
答案:B
cout 是 std 命名空间里的对象(变量),不是关键字。答案 B。
下列说法错误的是?( )
答案:C
标准 C++ 没有 foreach 关键字(C++11 提供的是范围 for:for(auto x : v),写法不同)。答案 C。
6.执行下面的C++代码时输入1,则输出是( )。
int month;
cin >> month;
switch(month){
case 1:
cout << "Jan ";
case 3:
cout << "Mar ";
break;
default:
;
}答案:C
输入 1 时匹配 case 1,输出 "Jan ";由于 case 1 后没有 break,会继续「穿透」执行 case 3,输出 "Mar " 后遇 break 跳出。结果是 Jan Mar。答案 C。
if 语句可以没有else 子句。
答案:A
if 可以单独使用,不需要 else;else 也可以省略。说法正确。答案 A(正确)。
如果a 为int 类型的变量,下列哪个表达式可以正确求出满足“大于等于 a 且是4 的倍数”的整数中最小的?
答案:C
(a+3)/4*4 先加 3 再整除 4(向下取整)再乘 4,得到 ≥a 的最小 4 的倍数。例如 a=5:8/4*4 = 8 ✓。答案 C。
以下哪个不是C++语言的运算符?( )
答案:D
<> 不是 C++ 运算符(不等号是 !=)。答案 D。
以下C++不可以作为变量的名称的是( )。
答案:D
变量名不能含空格,red star 会被当成两个标识符。答案 D。
如果a 为int 类型的变量,则赋值语句a = a + 3;是错误的,因为这条语句会导致a 无意义。
答案:B
a = a + 3; 是最常见的自增写法,完全合法(把 a 的值加 3 再存回 a)。说法错误。答案 B(错误)。
#include <iostream>
using namespace std;
int main(){
int score = 85;
if(score >= 90) cout << "A";
else if(score >= 80) cout << "B";
else if(score >= 60) cout << "C";
else cout << "D";
return 0;
}程序输出为( )。
若把两个 `else if` 都改写成独立的 `if`,score = 85 时程序输出为( )。
在原程序中,若 score 的值改为 60,程序输出为 ______。
- 第 1 题B score=85:第一个条件 85>=90 不成立 → 判断第二个 85>=80 成立 → …
- 第 2 题B 改成独立 if 后三条判断都会执行:85>=90 假;85>=80 真 → 输出 B;85>…
- 第 3 题C 60>=90 假;60>=80 假;60>=60 真 → 输出 C,跳出。注意边界值取「>=…
- 第 1 题D else 配的是最近的、还没有被配对的 if,和缩进完全无关;靠缩进判断是最经典的悬空 else 陷阱。
- 第 2 题C a = 0 是赋值,表达式值为 0,条件恒为假;判断相等必须写成两个等号 a == 0。
- 第 3 题A if 后面多写的分号让它的语句体变成了空语句,后面的语句不再受 if 管辖,于是无条件执行。
- 第 4 题A 它先算 0 < x 得到 0 或 1,再和 10 比较,恒为真;正确写法是 x > 0 && x < 10。
- 第 5 题D if 只管紧随其后的那一条语句,"B" 不在管辖范围内,无论条件真假都会输出;要多条语句受控必须加花括号。
- 第 6 题B switch 匹配到某个 case 后会一直往下执行,直到遇到 break;少了 break 就会穿透到下一个 case。
- 第 7 题C case 必须是编译期就能确定的常量表达式,不能是变量;写成变量会直接编译错误。
- 第 8 题B switch 只做等值匹配,不支持区间;区间条件要用 if-else if 来写,而 case 也不能用变量或浮点表达式。
- 第 9 题C else if 从上往下依次判断、命中即停,所以要把最严格的条件放前面,否则宽条件会提前把窄条件挡住。
- 第 10 题C 浮点运算有累积误差,直接用 == 往往判不出相等;应该看两者之差的绝对值是否小于一个很小的 EPS。
- 第 11 题B 字符串字面量的值是一个地址,地址非 0 即视为真,所以条件永远成立;这显然不是本意,属于典型误用。
- 第 12 题B else 必须依附于一个 if,不能单独存在;它也不是 switch 的搭配,switch 用的是 default。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 写出 if 的单分支、双分支、多分支三种形态各一条示例
- 说明 else 与哪个 if 配对,写一段靠缩进误导的悬空 else 代码并指出实际配对结果
- 写出 if (a = 0) 与 if (a == 0) 的区别,说明 0 < x < 10 为什么恒为真、正确写法是什么
- 默写 switch 的完整语法,说明 break 的作用以及 default 是否必须放最后
- 手推 int a=1; switch(a){case 1: cout<<"x"; case 2: cout<<"y"; break; case 3: cout<<"z";} 的输出
- 说明 else if 阶梯为什么从最严格的条件开始判断,写出浮点数相等比较的正确写法
- 手算 2022·20 那道嵌套 if 题,画出「括号配对图」
- 把 §3.5 的六个陷阱各写一小段代码,亲自编译运行看结果
- 完成客观题 12 题(
DAY12-01~DAY12-12) - 完成阅读程序小片段 1 组
本日关键记忆:非零即真 ·
else配最近的未配对if·if(a=0)是个坑 ·if(...);分号是坑 ·0<x<10恒真 · switch 无 break 会穿透 · case 必须是常量 · 多分支从上往下命中即停
循环结构
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 16 题 | 单项选择 | 2 分 |
| 2022 | 第 17 题 | 单项选择 | 2 分 |
| 2023 | 第 19 题 | 单项选择 | 2 分 |
| 2023 | 第 20 题 | 单项选择 | 2 分 |
| 2023 | 第 26 题 | 填空题 | 3 分 |
| 2024 | 第 25 题 | 填空题 | 3 分 |
| 2024 | 第 26 题 | 填空题 | 3 分 |
| 2024 | 第 41 题 | 完善程序 | 2 分 |
| 2024 | 第 42 题 | 完善程序 | 2 分 |
| 2024 | 第 43 题 | 完善程序 | 2 分 |
| 2024 | 第 44 题 | 完善程序 | 2 分 |
| 2024 | 第 45 题 | 完善程序 | 2 分 |
| 2025 | 第 27 题 | 单项选择 | 2 分 |
难易度:较难(★★★★☆) 近 4 年合计:13 题 / 29 分
2026 年备考建议
循环是阅读程序的绝对核心——近四年的阅读程序几乎每一组都离不开循环,完善程序里更是成片地考。命题人喜欢它,是因为循环能同时考边界、终值、break 和 continue 的行为,一道题里能塞进好几个坑,区分度天然就高。
必须吃透:循环三要素是初值、条件、更新,缺了更新就会死循环;for (int i = 0; i < 10; i++) 结束后 i 是 10 而不是 9,for (i = 1; i <= n; i++) 结束后 i 是 n+1;break 只跳出当前那一层,continue 只跳过本次;嵌套循环的总次数是各层次数相乘。
②知识地图 · 本考点思维导图
- 三种循环语句
- for —— 适合"次数已知"
- while —— 适合"条件已知"(先判断后执行)
- do-while —— 先执行后判断(至少执行 1 次)
- 循环三要素
- ① 初值 ② 条件 ③ 更新(缺一不可,否则死循环)
- 循环控制
- break —— 立即跳出整个循环
- continue —— 跳过本次剩余语句,进入下一次
- 嵌套循环
- 外层执行 1 次,内层执行完整一轮
- 总次数 = 各层次数之积
- 终值与边界
- ★ 循环结束后,循环变量 = 第一个使条件不成立的值
- < 与 <= 差一次、先加后用与先用后加差一次
- 常见陷阱
- while 里 continue 前忘了更新变量 → 死循环
- do-while 至少执行一次
- for 循环变量作用域
- 浮点条件累积误差
③核心精讲
3.1 三种循环语句
① for 循环(次数已知时首选)
for (初始化; 条件; 更新) {
循环体;
}
for (int i = 1; i <= 5; i++) {
cout << i << " "; // 输出 1 2 3 4 5
}
执行顺序:① 初始化(只做一次)→ ② 判断条件 → ③ 执行循环体 → ④ 更新 → 回到 ②
② while 循环(先判断后执行)
while (条件) {
循环体;
}
int i = 1;
while (i <= 5) {
cout << i << " ";
i++; // ★ 别忘了更新,否则死循环
}
③ do-while 循环(先执行后判断,至少执行一次)
do {
循环体;
} while (条件); // ★ 末尾有分号!
int i = 1;
do {
cout << i << " ";
i++;
} while (i <= 5); // 输出 1 2 3 4 5
★ 三者对比表
for | while | do-while | |
|---|---|---|---|
| 判断时机 | 先判断 | 先判断 | 后判断 |
| 最少执行次数 | 0 次 | 0 次 | 1 次 |
| 适用场景 | 次数已知 | 条件已知 | 至少要做一次 |
| 末尾分号 | 无 | 无 | 有 |
关键区别演示
int i = 100; while (i < 5) cout << "执行"; // 一次都不输出 do { cout << "执行"; } while (i < 5); // 输出一次!
3.2 循环三要素 ★
任何循环都要想清楚三件事,缺一个就会出错:
① 初值:从哪儿开始? i = 1
② 条件:什么时候继续? i <= n
③ 更新:每次怎么变? i++
漏掉「更新」= 死循环
int i = 1;
while (i <= 5) {
cout << i; // ❌ 忘了 i++,无限输出 1111111...
}
「更新」写错方向 = 死循环
for (int i = 1; i <= 10; i--) { ... } // ❌ i 越来越小,永远满足 i<=10
3.3 break 与 continue ★
| 语句 | 作用 | 记忆 |
|---|---|---|
break | 立即终止整个循环,跳到循环外面 | 「掀桌子走人」 |
continue | 跳过本次循环剩下的语句,直接进入下一次循环 | 「这局不算,下一局」 |
// break 例子:找到第一个能被 7 整除的数就停
for (int i = 1; i <= 100; i++) {
if (i % 7 == 0) { cout << i; break; } // 输出 7
}
// continue 例子:跳过所有偶数
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) continue; // 偶数跳过
cout << i << " "; // 输出 1 3 5 7 9
}
在嵌套循环中:break 和 continue 只作用于当前所在的那一层循环。
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (j == 2) break; // ★ 只跳出内层 for j,外层 i 照常继续
cout << i << j << " ";
}
}
// 输出:11 21 31
★ 2022·17 详解:continue 引发的死循环
int k = 0;
while (k < 10) {
if (k < 1) continue; // ★ k=0 时永远满足 k<1 → 永远 continue
if (k == 4) break;
k++;
}
第 1 轮:k = 0 → k < 10 真 → k < 1 真 → continue,跳过了下面的 k++! 第 2 轮:回到条件 k < 10 → 真 → k < 1 仍为真(k 还是 0)→ 又 continue…… → 无限循环,k 永远等于 0,程序卡死
答案 D(死循环,不能确定循环次数)
教训:
while里的continue千万要小心——如果continue出现在「更新语句」之前,就会跳过更新,造成死循环。 修法:把k++提到continue前面,或改用for循环(for的「更新」在continue之后仍会执行)。
对比:
for (…; …; i++) { if (…) continue; … }中,continue之后仍会执行i++,所以for循环里用continue更安全。
3.4 循环终值与边界 ★★ 最高频
★ 核心规律:循环结束后,循环变量 = 第一个使条件不成立的值
for (int i = 0; i < 10; i++) { }
// i 结束时的值是 10(不是 9!因为 i=10 时条件 i<10 不成立,循环才结束)
2022·16 答案 B(10)、2023·19 答案 D(6):
int i=0; while(i<=5){ cout<<i; i++; }→ 循环结束后 i = 6(因为 i=6 时6<=5不成立)。
「差一」陷阱对照表
| 写法 | 循环次数 | 结束后变量的值 |
|---|---|---|
for (i=0; i<10; i++) | 10 次 | 10 |
for (i=0; i<=10; i++) | 11 次 | 11 |
for (i=1; i<=10; i++) | 10 次 | 11 |
for (i=1; i<10; i++) | 9 次 | 10 |
理解方式:循环次数 = 满足条件的 i 的个数;结束值 = 第一个不满足条件的 i。
★ 「先加后用」造成的差一(2024·26 的答案来源)
int i = 0, sum = 0;
while (i <= 100) {
i++; // 先加
sum += i; // 后累加 —— 第一次累加的是 1,最后一次累加的是 101
}
// sum = 1 + 2 + 3 + … + 101 = 5151
对比另一种写法:
int i = 0, sum = 0;
while (i <= 100) {
sum += i; // 先累加
i++; // 后加 —— 累加的是 0 到 100
}
// sum = 0 + 1 + 2 + … + 100 = 5050
区别就在于「先加后用」还是「先用后加」——差一次,答案完全不同。 2024 年第 26 题的答案是 5151,正好等于 1+2+…+101,说明原程序采用的是「先 i++ 再累加」的写法(循环共执行 101 次)。
★ 2025·27 详解:三种写法的 s 值对比
// ①
int i = 0, s = 0;
while (i <= 5) { i++; s += i; } // i=1..6 → s = 1+2+3+4+5+6 = 21
// ②
int i = 0, s = 0;
while (i <= 5) { s += i; i++; } // i=0..5 → s = 0+1+2+3+4+5 = 15
// ③
int i = 0, s = 0;
do { s += i; i++; } while (i < 5); // i=0..4 → s = 0+1+2+3+4 = 15
结果:① = 21、② = 15、③ = 15 → ① 与 ② 不同;① 与 ③ 不同 → 答案 D(①跟②不同,跟③不同)
⚠️ 很多同学会误以为 ② 和 ③ 一样就选 C——注意题目问的是 ① 和 ②、① 和 ③ 的关系,不是 ② 和 ③。
3.5 嵌套循环
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 4; j++) {
cout << "*";
}
cout << endl;
}
// 输出 3 行,每行 4 个 *
执行规律:
外层第 1 轮 → 内层完整跑 4 次 → 换行
外层第 2 轮 → 内层完整跑 4 次 → 换行
外层第 3 轮 → 内层完整跑 4 次 → 换行
总执行次数 = 3 × 4 = 12
常见嵌套图案
// 直角三角形
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) cout << "*";
cout << endl;
}
// *
// **
// ***
// ****
// *****
// 九九乘法表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++)
cout << j << "×" << i << "=" << i * j << " ";
cout << endl;
}
复杂度提示:双重循环通常是
O(n²)。如果 n = 10⁵,双重循环会超时(10¹⁰ 次操作)——这是复赛的重要考点。
3.6 for 循环变量的作用域
for (int i = 0; i < 5; i++) { }
cout << i; // ❌ 编译错误:i 只在 for 循环内有效(C++ 标准)
int i;
for (i = 0; i < 5; i++) { }
cout << i; // ✅ 输出 5(i 定义在外面)
这正好呼应 2022·16:那道题的
for(i=0;i<10;i++)没有写int,说明i是在循环外定义的,所以循环结束后可以访问,值为 10。
3.7 常见死循环的四种写法(要能识别,但别自己写)
while (true) { ... } // ① 条件恒真
for (;;) { ... } // ② 三个表达式都省略
while (i <= 10) { ... } // ③ 忘了更新 i
while (k < 10) { if (k<1) continue; k++; } // ④ continue 跳过了更新(2022·17)
for(i=0;i<10;i++) 这个循环结束后,i的值是( )。
答案:B
破题点:循环结束后 i 的值是「第一个不满足条件的值」。
for(i=0; i<10; i++):i 依次取 0~9 执行循环体,当 i 变成 10 时条件 i<10 不成立,循环结束。此时 i 的值是 10(不是 9)。选 B。
下列程序的循环次数是( )次。 1int k=0; 2 while(k<10){ 3if(k<1) continue; 4 if(k==4)break; 5k++; 6}
答案:D
破题点:continue 之前没有 i++,k 永远是 0。
k=0 进入循环:if(k<1) 为真 → 执行 continue,跳过后面的语句回到循环条件判断。注意 k++ 在 continue 之后,永远执行不到,所以 k 始终是 0,while(k<10) 永远成立 → 死循环。选 D。
在 C++语言中,运行以下代码后,变量 i 的最终值是( ) int i=0; while(i<=5) { cout<<i; i++; }
答案:D
破题点:i++ 在循环体最后,i 会一直加到超过上界。
i 从 0 开始,每次输出 i 后 i++。当 i=5 时条件 i<=5 成立,输出 5、i 变 6;再判断 6<=5 不成立,退出。最终 i=6。选 D。
20. 执行如下程序
int x;
for(int i=1;i<=100;i++) {
cin>>x;
if(x<0) continue;
cout<<i;
}
则下面正确的说法是( )答案:D
破题点:continue 只跳过本轮,不影响循环次数。
循环固定执行 100 次(i=1..100),与 x 无关。当 x<0 时 continue 跳过 cout,当 x>=0 时执行 cout<<i 输出一个非负整数。所以最多(全部输入非负时)输出 100 个非负整数。A 错在 continue 不会结束循环(那是 break);C 错在输入非负时 cout 会执行。选 D。
有以下程序:
int i,s=0;
for(i=1;i<20;i+=3) s+=i;
cout<<s;
程序执行后的输出结果 s 的值是( )。答案:70
破题点:i = 1,4,7,10,13,16,19 共 7 项。
for(i=1; i<20; i+=3):i 取值 1、4、7、10、13、16、19(下一个 22 已越界)。s = 1+4+7+10+13+16+19 = 70。答案:70。
有以下程序
1 int a = 2;
2 switch (a) {
3 case 1:
4 printf("1");
5 case 2:
6 printf("2");
7 case 3:
8 printf("3");
9 }
程序执行后的输出结果为( )。答案:23
破题点:switch 没有 break 会「穿透」到下一个 case。
a=2,switch 跳到 case 2,执行 printf("2");由于 case 2 后面没有 break,会继续向下「穿透」执行 case 3 的 printf("3");case 3 后仍是 switch 结尾,结束。输出 23。这题考的就是「漏写 break 导致 fall-through」。答案:23。
有以下程序:
1 int i = 0,sum = 0;
2 do{
3 i++;
4 sum+=i;
5 }while(i<=100);
程序执行后 sum 的最终值为( )。答案:5151
破题点:do-while 先执行后判断,会多做一次。
do{ i++; sum+=i; }while(i<=100):第 1 轮 i=1、sum=1;…;当 i=100 时 sum=1+2+…+100=5050,判断 100<=100 成立,再执行一轮 i=101、sum=5050+101=5151,判断 101<=100 不成立,退出。所以 sum=5151。答案:5151。
27. 以下三个程序运行后,输出 s 的值( )
【①】
int i = 0, s = 0;
while (i <= 5){
i++;
s += i;
}
【②】
int i = 0, s = 0;
while (i <= 5){
s += i;
i++;
}
【③】
int i = 0, s = 0;
do{
i++;
s += i;
}while (i < 5);答案:D
破题点:三个程序区别只在「i++ 的位置」与「判断时机」。
① while(i<=5){ i++; s+=i; }:先自增再累加,s = 1+2+3+4+5+6 = 21。② while(i<=5){ s+=i; i++; }:先累加再自增,s = 0+1+2+3+4+5 = 15。③ do{ i++; s+=i; }while(i<5):i=1,s=1;i=2,s=3;i=3,s=6;i=4,s=10;此时判断 4<5 成立,再执行一轮 i=5,s=15,判断 5<5 不成立退出,s=15。所以 ①=21、②=15、③=15,①与②不同、①与③也不同。选 D。
以下哪个循环语句会无限次执行?( )
答案:B
bool 变量参与 b++ 时会先转成 int 再加 1,再转回 bool ⇒ 非 0 即 true,所以 b 永远是 true,b <= true 恒成立 → 无限循环。答案 B。
下面C++代码用于判断N是否为质数(只能被1和它本身整除的正整数)。程序执行后,下面有关描述正确的是( )。
int N;
cout << "请输入整数:";
cin >> N;
bool Flag = false;
if (N >= 2){
Flag = true;
for (int i=2; i < N; i++)
if (N % i == 0){
Flag = false;
break;
}
}
if(Flag)
cout << "是质数";
else
cout << "不是质数";答案:C
输入 2 时 N>=2 成立,Flag 先置为 true;内层 for(i=2; i<2) 条件一开始就不成立、循环体一次不执行,Flag 保持 true,所以输出「是质数」,判断正确。答案 C。
do ... while 语句的循环体至少会执行一次。
答案:A
do-while 是「先执行后判断」,循环体至少执行一次(这是它与 while 的本质区别)。说法正确。答案 A(正确)。
如果a、b 和c 都是int 类型的变量,下列哪个语句不符合C++语法?( )
答案:D
赋值号左边必须是变量(左值),a + c 是表达式的值,不能作为赋值目标。答案 D。
C++表达式2 - 1 && 2 % 10 的值是( )。
答案:B
2 - 1 = 1(非 0、视为真),2 % 10 = 2(非 0、视为真),真 && 真 = 1。答案 B(1)。
如果a 为int 类型的变量,则表达式(a / 4 == 2)和表达式(a >= 8 && a <= 11)的结果总是相同的。
答案:A
整数除法 a/4 == 2 意味着 8 ≤ a ≤ 11(因为 a/4 向下取整),与 a>=8 && a<=11 完全等价。说法正确。答案 A(正确)。
【问题描述】 Oier 设计了一种有趣的数字游戏: 一位同学随机给出一个数 n,其余同学需要构造一个数列 a1,a2,a3,...,ax,满足以 下条件: ✦数列中所有数的和等于 n; ✦数列中的每个数 ai 的表示中,每一位数字只能是 0 或 1(例如 1,101,11011 符合 规则,而 5,12,8910 不符合规则); ✦在满足上述条件的情况下,尽可能减少数列的长度 x, 你需要输出满足条件的最小的数列长度 x 以及这个数列。 样例输入: 42 输出: 4 356 输出: 6 111 111 111 11 11 1
#include <bits/stdc++.h>
using namespace std;
int ans[100001];
int main()
{
int n, t = 0, num_loc = 0;
cin >> n;
while (n != 0)
{
ans[++t] = 【41】;
if (ans[t] > num_loc)
num_loc = 【42】;
n /= 10;
}
cout <<【43】<< endl;
for (int i = 1; i <= num_loc; i++)
{
int k = 0;
for (int j = 【44】; j >= 1; j--)
{
if (ans[j] != 0)
{
k = 【45】;
cout << 1;
ans[j]--;
}
else if (k)
cout <<0;
}
cout <<" ";
}
return 0;
}第( )空应填写?(对应代码中 ans[++t] = 【41】)
第( )空应填写?(对应代码中 num_loc = 【42】)
第( )空应填写?(对应代码中 cout << 【43】 << endl)
第( )空应填写?(对应代码中 for (int j = 【44】; j >= 1; j--))
第( )空应填写?(对应代码中 k = 【45】)
- 第 1 空A ans[t] 存的是 n 的当前最低位数字。
- 第 2 空C 记录最大位数。
- 第 3 空B 先输出数列长度。
- 第 4 空A 每轮要遍历所有有效位。
- 第 5 空D 把 k 置为非零,用于控制补 0。
- 第 1 题D 循环体在 i = 9 执行完后 i 再加 1 变成 10,此时条件不成立退出,所以结束值是 10,不是 9。
- 第 2 题C k = 0 时 k < 1 恒真,continue 每次都跳过 k++,k 永远停在 0,形成死循环。
- 第 3 题B do-while 的结尾 while (条件) 后面那个分号不能省,漏掉会导致编译错误;条件写在循环体之后。
- 第 4 题A do-while 先执行一次循环体再判断条件,即使条件一开始就是假,也会至少输出一次。
- 第 5 题C break 只结束它所在的那一层循环,外层照常继续;想跳出多层得用标志变量或 goto。
- 第 6 题B break 直接终结整个循环,continue 只是跳过本次剩下的语句去做下一次;两者用途和效果完全不同。
- 第 7 题D 写在 for 初始化里的 int i 作用域仅限循环内部,循环外要用这个值,必须在外面先定义 i。
- 第 8 题A 循环三要素是初值、条件、更新;缺了更新往往造成死循环,缺初值会用到不确定的值,缺条件则无法结束。
- 第 9 题C i++ 与 ++i 放在累加语句里,会导致累加的范围差一项,答案常见相差一次(如 5050 与 5151);读数前先明确先加还是先用。
- 第 10 题A 先 i++ 再累加,i 从 1 一直加到 101,所以 sum = 1+2+…+101 = 5151,比 5050 多了一项 101。
- 第 11 题B 外层每跑一次,内层跑满 4 次,共 3 × 4 = 12 次;嵌套循环的总次数是各层次数相乘,不是相加。
- 第 12 题D 循环体在 i = n 执行完后 i 再加 1 变成 n+1,条件不成立才退出,所以 i 最终是 n+1。
- 第 13 题B 浮点运算有累积误差,用 != 或 == 判断往往永远不成立或提前停止;循环次数最好用整数变量来控制。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 写出 for、while、do-while 三种循环的区别,指出哪一种至少执行一次
- 默写循环三要素,说明缺了更新会有什么后果
- 分别写出 for (int i = 0; i < 10; i++) 和 for (int i = 1; i <= 10; i++) 结束后 i 的值与循环次数
- 手推 1+2+…+100 两种累加写法的结果(5050 与 5151),说明差在哪一步
- 说明 break 与 continue 的区别,指出嵌套循环里 break 只跳出几层,并写出一种 continue 导致死循环的代码
- 手算双重循环 for(i=1;i<=3;i++) for(j=1;j<=4;j++) 的总执行次数,说明为什么是乘不是加
- 把 §3.4 的「差一陷阱对照表」自己算一遍
- 手算 §3.4 的两道真题(2022·17 死循环、2025·27 三种循环)
- 用三种循环各写一遍「求 1+2+…+100」,比较结果是否相同
- 完成客观题 14 题(
DAY13-01~DAY13-14) - 完成阅读程序小片段 1 组
本日关键记忆:结束值 = 第一个不满足条件的值 ·
do-while至少执行一次 · 三要素(初值/条件/更新)·break结束整个循环 /continue只跳本次 ·while里continue前必须更新 · 先加后用差一次 · 嵌套次数相乘 ·for(int i…)的 i 只在循环内可见
一维数组与二维数组
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 25 题 | 填空题 | 3 分 |
| 2022 | 第 26 题 | 填空题 | 3 分 |
| 2023 | 第 13 题 | 单项选择 | 2 分 |
| 2023 | 第 24 题 | 填空题 | 3 分 |
| 2023 | 第 27 题 | 填空题 | 3 分 |
| 2023 | 第 31 题 | 阅读程序 | 3 分 |
| 2023 | 第 32 题 | 阅读程序 | 3 分 |
| 2023 | 第 33 题 | 阅读程序 | 3 分 |
| 2024 | 第 11 题 | 单项选择 | 2 分 |
| 2024 | 第 34 题 | 阅读程序 | 3 分 |
| 2024 | 第 35 题 | 阅读程序 | 3 分 |
| 2024 | 第 36 题 | 阅读程序 | 3 分 |
| 2024 | 第 37 题 | 阅读程序 | 3 分 |
| 2025 | 第 11 题 | 单项选择 | 2 分 |
| 2025 | 第 24 题 | 单项选择 | 2 分 |
难易度:中等(★★★☆☆) 近 4 年合计:15 题 / 41 分
2026 年备考建议
数组是阅读程序的头号素材来源,近四年光是数组就考了 15 题、30 分,单选、填空、阅读程序三类题型全覆盖。命题人偏爱它,是因为数组能天然地考下标、边界和内存计算,还能顺手把 a[b[i]] 这类嵌套下标做成陷阱,区分度非常理想。
所以要掌握得很牢:下标从 0 开始,合法范围是 0 到 n-1;局部数组是随机值、全局数组自动为 0;数组长度必须是常量,数组不能整体赋值也不能用 == 比内容;内存计算别忘了乘 sizeof,一维是长度乘 4、二维是行乘列乘 4,1 MB 等于 1024 乘 1024 字节。
②知识地图 · 本考点思维导图
- 一维数组
- 定义:类型 数组名[长度];
- 初始化:{} 列表、部分初始化、全部初始化
- 下标从 0 开始 → 最后一个元素是 a[n-1]
- 越界问题
- 数组的遍历与常见操作
- 求和 / 求平均值 / 求最值
- 计数 / 查找 / 反转
- 求最长上升子序列长度
- 置换(p2[i] = p1[p1[i]])
- 二维数组
- 定义:类型 数组名[行数][列数];
- 访问 a[i][j],i 是行、j 是列
- 行优先存储
- 遍历:双重循环
- 内存占用计算
- 一维:长度 × sizeof(元素类型)
- 二维:行 × 列 × sizeof(元素类型)
- 常见陷阱
- 下标越界(最容易犯)
- 数组长度必须是常量
- 数组名不能整体赋值 / 比较
③核心精讲
3.1 一维数组的定义与初始化 ★
定义
int a[10]; // 10 个 int,下标 0 ~ 9
int a[5] = {1,2,3,4,5};
int a[5] = {1,2}; // 只初始化前 2 个,其余自动为 0 → {1,2,0,0,0}
int a[5] = {0}; // 全部为 0(最常用的清零写法)
int a[] = {1,2,3}; // 长度自动推断为 3
int a[3] = {1,2,3,4}; // ❌ 编译错误:初始值过多
int a[]; // ❌ 编译错误:必须指定长度或给出初始值
★ 2023·13 答案 D:
int a[];既没有长度也没有初始值,编译错误。 而int a[]={1,2,3};、int a[10]={0};、int a[5];都是合法的。
★ 四条硬规则
| 规则 | 说明 |
|---|---|
| ① 长度必须是常量 | int n; int a[n]; 在标准 C++ 中不合法(部分编译器当扩展支持) |
| ② 下标从 0 开始 | a[0] 是第一个元素,a[n-1] 是最后一个 |
| ③ 不能整体赋值 | int a[5], b[5]; a = b; ❌ |
| ④ 不能整体比较 | if (a == b) ❌(比较的是地址) |
全局数组自动清零
int a[1000005]; // 定义在所有函数外面 → 全部元素自动为 0
int main() {
int b[10]; // 局部数组 → 元素是随机值(垃圾值)!
...
}
竞赛常用技巧:把大数组定义在全局,既自动清零,又能开得更大(局部数组放在栈上,容易爆栈)。
3.2 下标与遍历
const int N = 5;
int a[N] = {10, 20, 30, 40, 50};
// 下标 0 1 2 3 4
// 正序遍历
for (int i = 0; i < N; i++) cout << a[i] << " "; // 10 20 30 40 50
// 倒序遍历
for (int i = N - 1; i >= 0; i--) cout << a[i] << " "; // 50 40 30 20 10
★ 下标越界:最危险的错误
int a[5];
a[5] = 1; // ❌ 越界!合法下标只有 0~4
a[-1] = 1; // ❌ 越界!
特点:越界不会报编译错误,可能不报运行错误,但会悄悄改掉别的变量的值,或者直接让程序崩溃。这是竞赛中最难查的 bug 之一。
记忆:「长度为 n 的数组,下标范围是 0 ~ n−1」。
数组长度的两种求法
int a[10];
// ① 用 sizeof(编译期常量)
int len = sizeof(a) / sizeof(a[0]); // 10
// ② 直接记常量(推荐)
const int N = 10;
int a[N];
for (int i = 0; i < N; i++) ...
3.3 数组常见操作(阅读程序的高频套路)
① 求和 / 求平均
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
double avg = sum * 1.0 / n; // ★ 注意整数除法
② 求最大值 / 最小值
int mx = a[0], mn = a[0];
for (int i = 1; i < n; i++) {
if (a[i] > mx) mx = a[i];
if (a[i] < mn) mn = a[i];
}
③ 计数
int cnt = 0;
for (int i = 0; i < n; i++) if (a[i] > 60) cnt++;
④ 反转
for (int i = 0, j = n - 1; i < j; i++, j--) swap(a[i], a[j]);
★ ⑤ 最长上升子序列(LIS)长度(2024·28)
问题:在一个序列中找出最长的、严格递增的子序列(元素顺序不能改变),求它的长度。
int a[9] = {3,1,5,7,9,8,6,2,4};
手算方法(考试就靠手算):以每个位置为结尾,往前找能接上的最长链
| 位置 | 值 | 能接在谁后面 | 长度 |
|---|---|---|---|
| 1 | 3 | — | 1 |
| 2 | 1 | — | 1 |
| 3 | 5 | 3 或 1 | 2 |
| 4 | 7 | 3→5 或 1→5 | 3 |
| 5 | 9 | 3→5→7 | 4 |
| 6 | 8 | 3→5→7 | 4 |
| 7 | 6 | 3→5 | 3 |
| 8 | 2 | 1 | 2 |
| 9 | 4 | 1→2 或 3 | 3 |
答案:4(例如子序列 3, 5, 7, 9)
易错:子序列不是子串!子序列可以跳过元素,只要相对顺序不变。上例中的 3,5,7,9 在原序列里中间隔着 1,但它是合法的子序列。
★ ⑥ 置换 p2[i] = p1[p1[i]](2024·34–37)
这是一个「用数组的值当数组的下标」的双层索引题,关键是逐步展开、不要跳步。
输入
5 3 1 2 5 4(n=5,之后 5 个数是p1[1..5])第一步:填表
i 1 2 3 4 5 p1[i] 3 1 2 5 4 第二步:逐个算
p2[i] = p1[p1[i]]
i p1[i] p1[p1[i]] = p2[i] 1 3 p1[3] = 22 1 p1[1] = 33 2 p1[2] = 14 5 p1[5] = 45 4 p1[4] = 5答案:
2 3 1 4 5
通用套路:遇到
a[b[i]]、a[a[i]]这类「嵌套下标」,先画出数组的值表,再一层一层往里代。
3.4 二维数组
定义
int a[3][4]; // 3 行 4 列
int b[2][3] = {{1,2,3}, {4,5,6}};
int c[2][3] = {1,2,3,4,5,6}; // 按行依次填充,与上面等价
int d[3][3] = {{1}, {2,3}, {0}}; // 部分初始化,其余为 0
★ 访问元素 a[i][j]
第一维 i 表示"行",第二维 j 表示"列"
i 的范围:0 ~ 行数 − 1
j 的范围:0 ~ 列数 − 1
j=0 j=1 j=2
i=0 [ 1 ][ 2 ][ 3 ]
i=1 [ 4 ][ 5 ][ 6 ]
遍历:双重循环
int a[2][3] = {1,2,3,4,5,6};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
// 1 2 3
// 4 5 6
★ 行优先存储(重要)
C++ 中二维数组在内存里是按行连续存放的:
a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]
连续的一段内存 →
对角线元素
a[i][i] // 主对角线(行列下标相同)
a[i][n-1-i] // 副对角线
2023·26 就考这个:
int a[3][3]={9,8,7,6,5,4,3,2,1};执行for(k=1;k<3;k++) cout<<a[k][k]<<' ';主对角线元素a[1][1] = 5、a[2][2] = 1→ 输出5 1(这也是 2023·27 的答案)。
3.5 ★ 数组内存占用计算(高频)
公式
一维数组:字节数 = 长度 × sizeof(元素类型)
二维数组:字节数 = 行数 × 列数 × sizeof(元素类型)
★ 反向求解:能开多大?
元素个数上限 = 可用内存字节数 ÷ sizeof(元素类型)
★ 2024·11 详解:
int占 4 字节,数组限制 128 MB,最多能定义多长的int数组?128 MB = 128 × 1024 × 1024 = 134 217 728 字节 134 217 728 ÷ 4 = 33 554 432 ≈ 3.1 × 10⁷答案 A(3.1×10⁷)
★ 2025·11 详解:
int arr[m][n]总空间不超过 2 MB,m×n最大值可能是?2 MB = 2 × 1024 × 1024 = 2 097 152 字节 2 097 152 ÷ 4 = 524 288 ≈ 5.24 × 10⁵选项中不超过这个值的最大项是 5×10⁵ → 答案 B
⚠️ 易错:C 项的 5×10⁶ 已经超出(需要 20 MB);B 的 5×10⁵ 需要 2 MB,正好合规。
常用容量速查表(竞赛必备)
| 数组类型 | 内存限制 | 最大长度 |
|---|---|---|
int(4 B) | 128 MB | ≈ 3.1×10⁷ |
int(4 B) | 256 MB | ≈ 6.7×10⁷ |
long long(8 B) | 256 MB | ≈ 3.3×10⁷ |
char(1 B) | 128 MB | ≈ 1.3×10⁸ |
3.6 常见陷阱
| 陷阱 | 说明 |
|---|---|
| 下标从 1 开始写 | C++ 数组下标从 0 开始;用 int a[n+1] 才能从 1 开始存 |
| 越界 | a[n] 是越界的;合法范围 0 ~ n-1 |
| 局部数组未初始化 | 局部数组是随机值,用之前要清零 |
| 长度为变量 | 标准 C++ 要求长度是常量 |
| 数组整体赋值/比较 | a = b、a == b 都不行;要逐个元素操作 |
sizeof(a) 在函数内失效 | 数组传进函数后退化为指针,sizeof 得到的是指针大小(见 DAY16) |
| 二维数组传参必须写第二维 | void f(int a[][5]) 是合法的;void f(int a[][]) 不合法 |
| 二维数组行列搞反 | a[i][j] 中 i 是行、j 是列,别写反 |
假设下列两小题变量在每小题运行前已经重新赋为下列的值(问题1、问题2)
int x=3,y=6;int a[ ]={2,4,3,7,8,9,1,10};
int b[ ]={9,3,2,6,3,1,8,10,2,3} ;
执行
for(int i=0;i<=x;i++)
{a[x+i]*=b[y+i];}后,a 数组元素按顺序为( )(用 空格分隔每个值)。答案:2 4 3 56 80 18 3 10
破题点:数组下标从 0 起,注意 x=3 使起点后移。
i 从 0 到 3(i<=x,即 i<=3),执行 a[x+i] *= b[y+i],即 a[3+i] ×= b[6+i]:a[3]=7×8=56,a[4]=8×10=80,a[5]=9×2=18,a[6]=1×3=3。其余元素不变,最终 a = 2 4 3 56 80 18 3 10。答案:2 4 3 56 80 18 3 10。
假设下列两小题变量在每小题运行前已经重新赋为下列的值(问题1、问题2)
int x=3,y=6;int a[ ]={2,4,3,7,8,9,1,10};
int b[ ]={9,3,2,6,3,1,8,10,2,3} ;
执行
for (int i=0;i<=y;i++)
{if(a[i]%x) a[i]=a[i+1];}后,a 数组元素按顺序 为( )(用空格分隔每个值)。答案:4 3 3 8 9 9 10 10
破题点:边算边改,后面的元素用的是已改过的值。
a 初值 [2,4,3,7,8,9,1,10],x=3,循环 i=0..6:i=0 时 2%3≠0 → a[0]=a[1]=4;i=1 时 4%3≠0 → a[1]=a[2]=3;i=2 时 3%3=0 跳过;i=3 时 7%3≠0 → a[3]=a[4]=8;i=4 时 8%3≠0 → a[4]=a[5]=9;i=5 时 9%3=0 跳过;i=6 时 1%3≠0 → a[6]=a[7]=10。最终 4 3 3 8 9 9 10 10。答案:4 3 3 8 9 9 10 10。
在下面的一维数组定义中,哪一个有语法错误。( )
答案:D
破题点:数组定义必须能确定长度。
int a[]={1,2,3} 由初始化列表自动确定长度,合法;int a[10]={0} 合法(首元素 0 其余 0);int a[5] 合法(只分配空间);int a[]; 既没给长度又没给初值,编译器无法确定数组大小,语法错误。选 D。
若有 int a[10]={1,2,3,4,5,6,7,8,9,10};,则 a[a[1]+2*a[2]]的值是( )。
答案:9
破题点:先把下标算出来:a[1]=2、a[2]=3。
a = {1,2,3,4,5,6,7,8,9,10},a[1]=2,a[2]=3,所以下标 = 2 + 2×3 = 8,a[8] = 9。答案:9。
定义如下变量和数组:
int k;
int a[3][3]={9,8,7,6,5,4,3,2,1};
则语句
for(k=1;k<3;k++) cout<<a[k][k]<<' ';
的输出结果是( )(用空格分隔每个值)。答案:5 1
破题点:只输出主对角线 a[1][1] 与 a[2][2]。
a[3][3] 按行填充为 [[9,8,7],[6,5,4],[3,2,1]]。k=1 输出 a[1][1]=5,k=2 输出 a[2][2]=1。答案:5 1。
在 C++中,int 类型变量占用 4 字节。若数组大小限制为 128 MB,下列选项中可以 安全定义的 int 数组最大长度是多少? ( )
答案:A
破题点:先换算 128MB 的字节数,再除以 4。
128MB = 128 × 1024 × 1024 = 134,217,728 字节;每个 int 占 4 字节,可存 134217728 ÷ 4 = 33,554,432 ≈ 3.36 × 10⁷ 个。选项中不超过该值且最接近的是 3.1×10⁷。选 A。
在 C++ 中,int 类型变量占用 4 字节,若定义一个二维数组 int arr[m][n],且数
组占用的存储空间不超过 2 MB,则 m×n 的最大值可能是( )。
答案:B
破题点:2MB ÷ 4字节,结果是元素个数上限。
2MB = 2 × 1024 × 1024 = 2,097,152 字节;÷4 = 524,288 ≈ 5.24 × 10⁵。选项中最大且不超过该值的是 5×10⁵。选 B。
对于数组 int a[10]={3,1,4,1,5,9,2,6,5,3},a[ a[ (a[5]+a[8])/2 ] ]的结果是
( )?
答案:B
破题点:由内向外剥下标。
a = {3,1,4,1,5,9,2,6,5,3}。a[5]=9,a[8]=5,(9+5)/2 = 7(整数除法);a[7] = 6;再取 a[6] = 2。选 B。
下列关于C++语言中数组的叙述,不正确的是( )。
答案:D
C++ 的数组(含多维数组)在内存中一定是**连续存放**的,这正是指针可以用 a[i] 等价 *(a+i) 访问的原因。答案 D。
下列关于C++语言中数组的叙述,不正确的是( )。
答案:D
数组维数只受内存与语法限制,四维数组完全有意义(如 f[年][月][日][时])。答案 D。
下面C++数组的定义中,会丢失数据的是( )。
答案:C
char dict_name[]={'chen','wang','zhou'} 中 'chen' 是多字符常量(不是字符串),赋给 char 会发生截断丢失,编译还会警告。答案 C。
对二维数组int arr[3][16];,则arr[1] 占用内存的大小为( )字节。
答案:D
arr[1] 是二维数组的第 2 行,含 16 个 int,每个 4 字节,共 16 × 4 = 64 字节。答案 D。
在C++语言中,长度为n 的数组,合理的下标范围是从0 到n,包括0 和n。
答案:B
长度为 n 的数组下标范围是 0 ~ n-1,不含 n。访问 a[n] 是越界错误。说法错误。答案 B(错误)。
对N个元素的数组执行插入排序算法,通常的时间复杂度是O(N²)。
答案:A
插入排序平均需要约 n²/4 次比较与移动,时间复杂度 O(N²)。说法正确。答案 A(正确)。
#include<iostream>
using namespace std;
int main()
{
int x, y, z, f[3];
for(int i=0;i<3;i++) cin>> f[i];
x=f[0]+f[1]+f[2];
x=x/f[0];
y=f[0]+f[2];
y=y/x;
z=(y*f[1]+x)/f[2];
if(f[(x+y+z)%3]>f[2])
cout<<x<<endl;
else
cout<<y+z<<endl;
return 0;
}输入数据:1 1 1
输出数据:( )
输入数据:2 0 4
输出数据:( )
输入数据:10 15 3
输出数据:( )
- 第 1 空3 整数除法会截断,且要先算完 x、y、z 才能确定走哪个分支。
- 第 2 空2 整数除法会截断,且要先算完 x、y、z 才能确定走哪个分支。
- 第 3 空36 整数除法会截断,且要先算完 x、y、z 才能确定走哪个分支。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100 + 7;
int p1[maxn],p2[maxn];
int main()
{
int n; scanf("%d",&n);
for(int i = 1; i <= n; ++i){
scanf("%d",&p1[i]);
}
for(int i = 1; i <= n; ++i){
p2[i] = p1[p1[i]];
}
for(int i = 1; i <= n; ++i){
cout<<p2[i]<<" ";
}
cout<<"\n";
return 0;
}输入数据:3 1 2 3
输出数据:( )
输入数据:3 3 2 1
输出数据:( )
输入数据:5 3 1 2 5 4
输出数据:( )
输入数据:5 2 3 5 1 4
输出数据:( )
- 第 1 空1 2 3 先确定 p1 每个位置的值,再把它当作下标去查 p1,得到 p2。
- 第 2 空1 2 3 先确定 p1 每个位置的值,再把它当作下标去查 p1,得到 p2。
- 第 3 空2 3 1 4 5 先确定 p1 每个位置的值,再把它当作下标去查 p1,得到 p2。
- 第 4 空3 5 4 2 1 先确定 p1 每个位置的值,再把它当作下标去查 p1,得到 p2。
- 第 1 题B C++ 数组下标从 0 开始,长度为 10 的数组合法下标是 0 到 9,最后一个元素是 a[9],不是 a[10]。
- 第 2 题D 长度为 10 的数组只有 a[0] 到 a[9] 共 10 个元素,访问 a[10] 已经越界,会破坏其他数据且不一定报错。
- 第 3 题C 全局(和静态)数组自动清 0,局部数组存放的是不确定的随机值;局部数组使用前务必先赋初值或清零。
- 第 4 题A 标准要求数组长度是编译期就能确定的常量表达式;需要变长时,应开一个足够大的固定数组来用。
- 第 5 题C 定义数组要么给出长度,要么用初值列表让编译器推算长度;两者都没有就直接编译错误。
- 第 6 题A 初值个数不能超过数组长度,int a[3] 最多写 3 个初值;写 4 个是编译错误。反过来初值少于长度则允许,缺的补 0。
- 第 7 题D 数组名是地址常量,不能整体赋值,b = a 只是非法地改地址;要复制内容必须逐个元素来或调用专门函数。
- 第 8 题B 数组名会退化为指针,a == b 比的是两个首元素地址是否相同,不是内容;判断内容相等要逐个元素比较。
- 第 9 题D sizeof(a) 直接给出整个数组的字节数,等于 10 × 4 = 40;只写 10 或 sizeof(int) 都只是部分信息。
- 第 10 题C 1 MB = 1024 KB = 1024 × 1024 字节 = 1 048 576 字节;算内存时要乘两次 1024。
- 第 11 题C 子序列允许跳过元素、只要求相对顺序不变;子串必须连续。两者条件不同,长度计算自然也不一样。
- 第 12 题D 先算内层:a[1] = 2、a[2] = 3,得 2 + 6 = 8,再取 a[8] = 9;嵌套下标要先画值表逐层代入。
- 第 13 题A a[i][j] 中 i 表示第 i 行、j 表示第 j 列;行列写反会导致访问到完全不同的元素,是高频失分点。
- 第 14 题B 数组传参时会退化成指针,sizeof 得到的是指针大小而不是数组大小;正确做法是把长度单独作为参数传进去。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 写出 int a[10]; 的合法下标范围、最后一个元素,以及 int a[5] = {1,2}; 初始化后各元素的值
- 说明全局数组和局部数组未初始化时的区别,写出用 sizeof 求数组长度的表达式
- 手算 int a[10]={1,2,3,4,5,6,7,8,9,10}; 中 a[a[1]+2*a[2]] 的值,并写出代入步骤
- 分别计算 128 MB 限制下 int 数组最多能开多长、2 MB 下 int arr[m][n] 的 m×n 上限
- 手推序列 3,1,5,7,9,8,6,2,4 的最长上升子序列长度并举一个,写出 3×3 二维数组 a[1][1]、a[2][2] 及主对角线的循环写法
- 说明数组不能整体赋值 a = b 的原因,以及数组传进函数后 sizeof 求不出长度的原因
- 手算 §3.3 的置换题(
p2[i]=p1[p1[i]])和 LIS 题 - 背熟内存换算:1 MB = 1 048 576 字节;
int数组上限公式 - 用一重循环、二重循环各写一遍「求数组最大值」
- 完成客观题 14 题(
DAY14-01~DAY14-14) - 完成阅读程序小片段 1 组
本日关键记忆:下标 0 ~ n−1 ·
int a[];是错的 · 局部数组是随机值 · 长度 × 4 = 字节数 · MB 用 1024×1024 · 嵌套下标先画值表 · 子序列 ≠ 子串 · 二维行优先 · 越界不报错最危险
字符、字符数组与字符串
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 34 题 | 阅读程序 | 3 分 |
| 2022 | 第 35 题 | 阅读程序 | 3 分 |
| 2022 | 第 36 题 | 阅读程序 | 3 分 |
| 2022 | 第 37 题 | 阅读程序 | 3 分 |
| 2024 | 第 12 题 | 单项选择 | 2 分 |
| 2025 | 第 12 题 | 单项选择 | 2 分 |
| 2025 | 第 34 题 | 阅读程序 | 3 分 |
| 2025 | 第 35 题 | 阅读程序 | 3 分 |
| 2025 | 第 36 题 | 阅读程序 | 3 分 |
难易度:中等(★★★☆☆) 近 4 年合计:9 题 / 25 分
2026 年备考建议
站在出题人的视角,字符串是阅读程序板块里最好用的素材:不需要灵感,一个循环逐字符处理,就能把学生的耐心和细致称得清清楚楚。四年来它在阅读程序里出现 11 次,2022 年连出 4 题、2025 年又连出 3 题,是全卷出现最多的题材——会就是会,不会就是不会,区分度干净利落。
所以这一块要练到条件反射:cin >> 遇空格就停、'7' 的 ASCII 是 55、大小写差 32、字母后移越界要 -26、数字后移越界要 -10。char[] 与 string 的三组写法也要背死:strcpy 对 =、strcmp 对 ==、strlen 对 .length()。
两个最毒的坑是:strlen 数的是有效字符、sizeof 数的是数组总容量,两者差一个 '\0';以及子串计数里“任意个”含 0 个,长度为 n 的字符串非空子串共 n(n+1)/2 个,含空串要再 +1。
②知识地图 · 本考点思维导图
- char 与 ASCII
- 'a'=97 'A'=65 '0'=48 ' '=32
- 大小写差 32
- 字符可以做加减运算
- 字符判断三件套
- 是否小写:c >= 'a' && c <= 'z'
- 是否大写:c >= 'A' && c <= 'Z'
- 是否数字:c >= '0' && c <= '9'
- char[] 字符数组
- 以 '\0' 结尾
- 常用函数:strlen / strcpy / strcat / strcmp
- 不能用 = 赋值、不能用 == 比较
- string 类
- 长度:length() / size()
- 取子串:substr(起点, 长度)
- 查找:find()
- 支持 + = == < 等运算符
- 串的常见处理
- 大小写互换
- 位移与回绕(凯撒密码)
- 统计各类字符个数
- 子串计数
- 高频陷阱
- cin>> 遇空格停止
- 数字字符 '0'~'9' 与数字 0~9 的区别
- 位移越界要"回绕"
③核心精讲
3.1 char 与 ASCII 复习(回看 DAY03)
| 字符 | ASCII |
|---|---|
' ' 空格 | 32 |
'0' ~ '9' | 48 ~ 57 |
'A' ~ 'Z' | 65 ~ 90 |
'a' ~ 'z' | 97 ~ 122 |
★ 三条常用关系
'a' - 'A' == 32 // 大小写相差 32
'0' → 数字值 = c - '0' // '7' - '0' = 7
数字值 → 字符 = d + '0' // 7 + '0' = '7'
★ 字符判断三件套(必背,几乎每道字符串题都要用)
if (c >= 'a' && c <= 'z') ... // 小写字母
if (c >= 'A' && c <= 'Z') ... // 大写字母
if (c >= '0' && c <= '9') ... // 数字字符
➡️ 也可用库函数:islower(c) / isupper(c) / isdigit(c) / isalpha(c)(需 <cctype>)、tolower(c) / toupper(c)。
⚠️ 别把字符和数字搞混:
'7'的值是 55(ASCII),不是 7。char c = '7'; int v = c - '0'; // v = 7 ✅ 正确的"字符转数字" int wrong = c; // wrong = 55 ❌
3.2 大小写转换
方法一:直接加/减 32
if (c >= 'a' && c <= 'z') c = c - 32; // 小写 → 大写
if (c >= 'A' && c <= 'Z') c = c + 32; // 大写 → 小写
方法二:用字母序号(更通用,也更好记)
c = c - 'a' + 'A'; // 小写 → 大写:先算出序号,再加到大写起点
c = c - 'A' + 'a'; // 大写 → 小写
方法三:互换(真题 2022·34 用的就是这个)
if (c >= 'a' && c <= 'z') c = c - 'a' + 'A'; // 小写变大写
else if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a'; // 大写变小写
方法四:库函数
c = toupper(c); // 转大写(非字母不变)
c = tolower(c); // 转小写
3.3 位移与回绕(凯撒密码式)★
核心难点:位移越界后要「绕回」
// 小写字母整体后移 3 位(c → f,x → a)
if (c >= 'a' && c <= 'z') {
if (c + 3 > 'z') c = c + 3 - 26; // ★ 越界:减 26 个字母绕回来
else c = c + 3;
}
// 数字整体后移 3 位(0 → 3,8 → 1)
if (c >= '0' && c <= '9') {
if (c + 3 > '9') c = c + 3 - 10; // ★ 数字越界:减 10 绕回来
else c = c + 3;
}
★ 2025·34–36 详解(三段程序完全一样,只是输入不同)
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (s[i] + 3 > 'z') s[i] = s[i] + 'A' - 'a' + 3 - 26; // 越界:转大写 + 3 - 26
else s[i] = s[i] + 'A' - 'a' + 3; // 正常:转大写 + 3
}
else if (s[i] >= '0' && s[i] <= '9') {
if (s[i] + 3 > '9') s[i] = s[i] + 3 - 10; // 数字越界回绕
else s[i] = s[i] + 3;
}
cout << s[i];
}
三条规律(观察代码就能总结出来):
- 小写字母 → 变大写,且字母序号 +3;
- 数字字符 → 数值 +3,超过 9 就回绕(
7→0、8→1、9→2); - 大写字母和其他字符 → 原样不变。
| 输入 | 逐字符推演 | 输出 | 答案 |
|---|---|---|---|
2025c++ | 2→5、0→3、2→5、5→8、c→F、+不变、+不变 | 5358F++ | A |
Hello! | H不变、e→H、l→O、l→O、o→R、!不变 | HHOOR! | D |
China_76 | C不变、h→K、i→L、n→Q、a→D、_不变、7→0、6→9 | CKLQD_09 | C |
注意
c → F的推导:'c'是第 3 个小写字母(从 0 数:a=0、b=1、c=2)。s[i] + 'A' - 'a' + 3='c' - 32 + 3='C' + 3='F'。 也就是「先把小写转成对应大写,再加 3」。
3.4 char[] 与 string 的区别 ★
| 对比项 | char s[100] | string s |
|---|---|---|
| 头文件 | 不需要 | #include <string> |
| 结束标志 | 必须有 '\0' | 不需要 |
| 赋值 | strcpy(s, "abc") | s = "abc" |
| 拼接 | strcat(s, "abc") | s += "abc" |
| 比较 | strcmp(a, b) == 0 | a == b |
| 求长度 | strlen(s) | s.length() / s.size() |
| 下标访问 | s[i] | s[i](都从 0 开始) |
| 读整行 | gets / cin.getline(s, 100) | getline(cin, s) |
| 是否可直接运算 | ❌ 不能 | ✅ == + < 都支持 |
char[] 的四个常用函数
| 函数 | 作用 | 例子 |
|---|---|---|
strlen(s) | 求有效字符长度(不含 '\0') | strlen("hello") = 5 |
strcpy(dst, src) | 复制 | strcpy(a, "abc") |
strcat(dst, src) | 拼接 | strcat(a, "def") |
strcmp(a, b) | 比较 | 相等返回 0,a>b 返回正数 |
★ '\0' 的作用
char s[10] = "abc";
// 内存里是: 'a' 'b' 'c' '\0' ? ? ? ? ?
// ↑ 字符串结束标志(ASCII 值为 0)
cout << strlen(s); // 3(不把 '\0' 算进去)
sizeof(s); // 10(整个数组的大小)
strlen与sizeof的区别(易考):
strlen(s)= 实际字符个数(运行时计算,不含'\0')sizeof(s)= 数组总容量(编译时确定,包含'\0'和未用空间)
string 的常用操作
string s = "hello";
s.length() // 5
s.size() // 5(等价)
s[0] // 'h'
s.substr(1, 3) // "ell" 从下标 1 开始取 3 个字符
s.find("ll") // 2 找不到返回 string::npos
s.insert(0, "say ") // 插入
s.erase(0, 4) // 删除
s += " world" // 拼接
reverse(s.begin(), s.end()); // 反转(需 <algorithm>)
遍历字符串的两种写法
// 下标法(最常用)
for (int i = 0; i < s.length(); i++) cout << s[i];
// 范围 for(C++11)
for (char c : s) cout << c;
3.5 子串计数 ★
定义:字符串中连续的若干个字符组成的序列叫「子串」。
★ 公式:长度为 n 的字符串
非空子串个数 = n × (n + 1) / 2
含空串的子串个数 = n × (n + 1) / 2 + 1
| n | 非空子串 | 含空串 |
|---|---|---|
| 3 | 6 | 7 |
| 4 | 10 | 11 |
| 5 | 15 | 16 |
| 6 | 21 | 22 |
★ 2024·12 答案 C(16):题目说「任意个连续的字符组成的子序列称为该串的子串」——「任意个」包含 0 个,所以要把空串算进去:
5 × 6 / 2 + 1 = 15 + 1 = 16。手工核对(以
abcde为例):
- 长度 1:a, b, c, d, e → 5 个
- 长度 2:ab, bc, cd, de → 4 个
- 长度 3:abc, bcd, cde → 3 个
- 长度 4:abcd, bcde → 2 个
- 长度 5:abcde → 1 个
- 长度 0:空串 → 1 个
合计 5+4+3+2+1+1 = 16
★ 2025·12 详解:"banana" 中,所有长度为 3 且包含字符 n 的连续子串有几个?
所有长度为 3 的子串(共 6−3+1 = 4 个):
ban (下标 0-2) → 含 n ✅
ana (下标 1-3) → 含 n ✅
nan (下标 2-4) → 含 n ✅
ana (下标 3-5) → 含 n ✅
4 个全部含 n → 答案 D(4)
⚠️ 注意去重问题:题目问的是「连续子串」的个数(按位置计),
ana出现两次要算 2 个,不是去重后的 1 个。
3.6 ★ 最高频的坑:cin >> 遇空格停止
★ 2022·37 详解(这道题考的就是这个坑)
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) { ... } // 大小写互换 + 数字加 3
cout << str << endl;
输入 This is a pen. —— 但 cin >> str 只读到第一个空格为止,所以 str = "This"(只有 4 个字符,is a pen. 根本没读进来)。
处理 "This":T→t、h→H、i→I、s→S → 输出 tHIS(而不是处理整句后的 tHIS IS A PEN.)。
三种正确处理办法
getline(cin, s); // ✅ 读整行(含空格)
cin.getline(buf, 100); // ✅ char[] 版
while (cin >> s) { ... } // ✅ 循环读数个"单词"
同理:scanf("%s", s) 遇空格也停;要读整行用 fgets 或 getline。
字符串中任意个连续的字符组成的子序列称为该串的子串。当字符串长度为 5 时, 共有( )个子串。
答案:C
破题点:注意原卷对「子串」的定义含空串。
按卷面定义「任意个连续的字符组成的子序列」,「任意个」包含 0 个。长度 5 的字符串:非空子串数 = 5+4+3+2+1 = 15,再加上空串共 16 个。选 C。
字符串 "banana" 中,所有长度为 3 且包含字符 "n" 的连续子串有( )个。
答案:D
破题点:先把 4 个长度为 3 的子串都列出来。
"banana" 长度为 3 的连续子串有 4 个(起始位置 0~3):ban、ana、nan、ana。逐一检查是否含字母 n:ban 含 n ✓、ana(a-n-a)含 n ✓、nan 含 n ✓、ana 含 n ✓。4 个全部满足。选 D。
如果执行下面C++代码后,输出的结果是“gesp ccf org cn”,则横线上应填入哪个代码?( )
#include <iostream>
using namespace std;
int main() {
string str = "gesp.ccf.org.cn";
string delimiter = ".";
string result="";
string token;
size_t found = str.find(delimiter);
while (found != string::npos) {
token = str.substr(0, found);
result += token;
result += " ";
__________________________ // 在此处填入代码
found = str.find(delimiter);
}
//最后一部分
result += str;
result += " ";
cout << result << endl;
return 0;
}答案:A
每轮要把 str 缩短为「去掉第一个分隔符及其前面部分」:新 str = str.substr(found + 1, 剩余长度),即 substr(found + delimiter.length(), ...),否则死循环。答案 A。
以下关于C++中 string 类和字符数组( char[] )的说法,错误的是( )。
答案:D
string 对象可以用 == 直接比较内容,但字符数组的数组名是地址,用 == 比较的是地址而不是内容,必须用 strcmp。所以 D 的说法错误。答案 D。
执行以下 C++ 代码后,sub 的值是( )。第 2 页 / 共 9 页
string str = "GESP2026";
string sub = str.substr(4, 2);答案:A
str = "GESP2026",substr(4, 2) 从下标 4 开始取 2 个字符:下标 4 是 '2'、5 是 '0',得 "20"。答案 A。
关于 string 的成员函数,下面说法错误的是( )
答案:D
s.erase(2) 的**单参数**形式会删除从下标 2 起到末尾的全部字符;只删一个字符要写成 s.erase(2, 1)。说法错误。答案 D。
string 的substr(1, 3) 返回从下标1开始的3个字符的子串。
答案:A
substr(pos, len) 从下标 pos 开始取 len 个字符,substr(1,3) 即从下标 1 起取 3 个字符。说法正确。答案 A(正确)。
strcmp(str1, str2) 返回 0 表示 str1 大于 str2,返回正数表示两者相等。
答案:B
strcmp 返回值:0 表示两串相等,正数表示 str1 > str2,负数表示 str1 < str2。题干的说法正好说反了。答案 B(错误)。
string("hello") == "hello" 的比较结果为true。
答案:A
string 重载了 == 运算符,比较的是字符串内容而不是地址,"hello" 与 "hello" 内容相同,结果为 true。答案 A(正确)。
string 的substr(2, 10) 在字符串长度不足时会抛出异常。
答案:B
substr 在长度不足时不会抛异常,而是返回从 pos 到末尾的剩余部分(若 pos 本身越界才抛 out_of_range)。答案 B(错误)。
如果字符串定义为char str[] = "Hello";,则字符数组str 的长度为( )。
答案:C
char str[]="Hello" 用字符串常量初始化时,编译器会自动在末尾补 '\0',所以数组长度是 5 + 1 = 6。答案 C。
在C++语言中,可以使用字符(如'0')作为数组下标。
答案:A
字符在参与下标运算时会自动转换成 ASCII 码(整数),如 a['0'] 等价 a[48],语法完全合法。说法正确。答案 A(正确)。
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str;
cin>>str;
for(int i=0;i<str.length();i++)
{
if(str[i]>='a' && str[i]<='z')
str[i]=(str[i]-'a')+'A';
else if(str[i]>='A' && str[i]<='Z')
str[i]=(str[i]-'A')+'a';
else if(str[i]>='0' && str[i]<='9')
str[i]=(str[i]-'0'+3)%10+'0';
}
cout<<str<<endl;
return 0;
}输入数据:These
输出数据:( )
输入数据:N92
输出数据:( )
输入数据:12+96
输出数据:( )
输入数据:This is a pen.
输出数据:( )
- 第 1 空tHESE 逐字符查表:小写 a~z 转大写减 32,数字 0~9 加 3 后 (x-'0'+3)%10 再还原成字符。
- 第 2 空n25 逐字符查表:小写 a~z 转大写减 32,数字 0~9 加 3 后 (x-'0'+3)%10 再还原成字符。
- 第 3 空45+29 逐字符查表:小写 a~z 转大写减 32,数字 0~9 加 3 后 (x-'0'+3)%10 再还原成字符。
- 第 4 空tHIS 逐字符查表:小写 a~z 转大写减 32,数字 0~9 加 3 后 (x-'0'+3)%10 再还原成字符。
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
for(int i=0;i<s.length();i++){
if(s[i]>='a' && s[i]<='z'){
if(s[i]+3>'z'){
s[i]=s[i]+'A'-'a'+3-26;
}
else{
s[i]=s[i]+'A'-'a'+3;
}
}
else if(s[i]>='0' && s[i]<='9'){
if(s[i]+3>'9'){
s[i]=s[i]+3-10;
}
else{
s[i]=s[i]+3;
}
}
cout<<s[i];
}
return 0;
}输入“2025c++",请选出正确的输出( )
输入"Hello!",请选出正确的输出( )
输入“China_76”,请选出正确的输出( )
- 第 1 空A 分「小写字母」「数字」「其他」三类,注意越界时的绕回处理。
- 第 2 空D 分「小写字母」「数字」「其他」三类,注意越界时的绕回处理。
- 第 3 空C 分「小写字母」「数字」「其他」三类,注意越界时的绕回处理。
- 第 1 题A `cin >>` 一遇空白字符就停止,只会读到 `Hello`;想读整行要用 `getline(cin, s)`。
- 第 2 题B `'7'` 在内存中是 ASCII 码 55,直接赋给 int 得 55;减去 `'0'`(48)才得到数字 7。
- 第 3 题C `'x' + 3` 会越过 `'z'`,必须回绕:23 + 3 = 26,26 − 26 = 0,对应 `'a'`。
- 第 4 题D 大小写字母的 ASCII 码相差 32(`'A'` 是 65、`'a'` 是 97);26 是字母个数,48 是 `'0'` 的码值。
- 第 5 题A 条件限定在 `'a'`~`'z'`,`'A'` 的 ASCII 是 65,不在这段区间内;做题先看清题目只处理小写还是也含大写。
- 第 6 题B 非空子串是 n(n+1)/2 = 15 个;“任意个”包含取 0 个这一种,所以还要再 +1 得 16。
- 第 7 题C 子串按位置计数,两个 `ab` 各算一个,共 `ab`、`ba`、`ab` 三个。
- 第 8 题D `strlen` 数有效字符数 5;`sizeof` 数整个数组的容量 20 字节,含义完全不同。
- 第 9 题A `char[]` 的数组名不能整体赋值,必须用 `strcpy`;`s = "abc"` 那种写法只对 `string` 成立。
- 第 10 题B 数组名做 `==` 比的是地址不是内容;`strcmp` 返回 0 才表示相等,长度相同也不代表内容相同。
- 第 11 题C `'\0'` 是 ASCII 值为 0 的空字符,`strlen` 靠它判断结尾;缺了它程序会一直往后读,越界出错。
- 第 12 题D 合法下标是 0 到 `length()-1`,用 `<=` 会多读一位,属于越界访问。
- 第 13 题B `char c : s` 是值拷贝,改 c 动不了原串;加 `&` 变成引用才能真正修改 s 中的字符。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写
'a'、'A'、'0'、'7'的 ASCII 值,写出大小写相差的数值,并各举一个字符验证。 - 写出把小写字母先转大写、再后移 3 位的完整表达式,并单独处理越界时的
-26回绕。 - 手写把字符
'7'转成数字 7,以及把数字字符后移 3 位并回绕的两种实现(if 判断版和取模版)。 - 列表对比
char[]与string在赋值、比较、求长度上的三组写法,各写出一行代码。 - 用公式算出长度为 6 的字符串的非空子串个数和含空串的个数,再手数
banana中所有长度为 3 的子串。 - 写一段能读入含空格整行的代码,并用输入
Hello World对比cin >>与getline的结果差异。 - 手写一遍「大小写互换 + 数字加 3」的完整代码,并用 4 个样例走一遍
- 手算 2025·34–36 三道题的逐字符变化表
- 背熟子串计数公式 n(n+1)/2(+1)
- 完成客观题 12 题(
DAY15-01~DAY15-12) - 完成阅读程序小片段 1 组
本日关键记忆:
'a'-'A'=32 ·c-'0'转数字 · 位移越界要回绕(字母 −26、数字 −10)·cin>>遇空格停 →getline·strlen≠sizeof· 子串 = n(n+1)/2 (+1 空串) · 重复内容按位置各算一个
函数与递归
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 38 题 | 阅读程序 | 3 分 |
| 2022 | 第 39 题 | 阅读程序 | 3 分 |
| 2022 | 第 40 题 | 阅读程序 | 3 分 |
| 2023 | 第 11 题 | 单项选择 | 2 分 |
| 2023 | 第 23 题 | 填空题 | 3 分 |
| 2023 | 第 25 题 | 填空题 | 3 分 |
| 2023 | 第 38 题 | 阅读程序 | 3 分 |
| 2023 | 第 39 题 | 阅读程序 | 3 分 |
| 2023 | 第 40 题 | 阅读程序 | 3 分 |
| 2024 | 第 28 题 | 填空题 | 3 分 |
| 2025 | 第 17 题 | 单项选择 | 2 分 |
难易度:较难(★★★★☆) 近 4 年合计:11 题 / 31 分
2026 年备考建议
站在出题人的视角,函数与递归是全卷分值最高的单个考点——四年 16 题 48 分,光阅读程序就占 13 题。它天然分层:肯列表逐项求和的人拿分,靠心算猜的人丢分,区分度极高;而且斐波那契、约瑟夫环、汉诺塔、各种递推都能被套进递归外壳,命题人取材几乎不用费力。
所以递归要按“工程”来练,不能靠感觉:先圈出基线条件(如 x==0 || x==1),再从最小规模老老实实列表,fun(1)、fun(2)、fun(3) 一项一项填。碰到双递归,必须先把内层函数整张表算完,再算外层,逐步查表代入。
三个高频送分点也记牢:值传递只改副本、要动实参必须用 &;返回类型由定义时写的类型决定,不看 return;数组传参会退化成指针,sizeof 失效,长度必须额外传。
②知识地图 · 本考点思维导图
- 函数基础
- 定义:返回类型 函数名(参数表) { 函数体 }
- 声明(原型)与调用
- 形参 vs 实参
- 返回类型与 void;return 的两种作用
- 参数传递
- 值传递(拷贝,改不了实参)
- 引用传递(& ,能改实参)
- 数组作为参数
- 传的是首地址;sizeof 失效,要另外传长度
- 递归
- 递归三要素:基线条件 / 递归调用 / 向基线推进
- 递归求值四步法
- 常见递归模型
- 阶乘、斐波那契
- 隔项递归(x + fun(x-2))
- 双递归(fun 调用 fun2)
- 约瑟夫环
- 常见陷阱
- 忘记写返回类型
- 递归没有基线 → 栈溢出
- 返回值类型不匹配被截断
③核心精讲
3.1 函数的定义、声明与调用
// ① 函数定义
int add(int a, int b) { // 返回类型 int,函数名 add,参数 a、b
return a + b; // return 把结果交回调用处
}
// ② 函数声明(原型)——只写"长什么样",不写函数体
int add(int, int);
// ③ 函数调用
int main() {
int s = add(3, 5); // 实参 3、5
cout << s; // 输出 8
return 0;
}
★ 关键规则
| 规则 | 说明 |
|---|---|
| 返回类型由「定义函数时指定的类型」决定 | 不是由 return 表达式或实参类型决定(2023·11 答案 A) |
无返回值时写 void | 2023·23 答案 void |
int main() 必须有 return 0; | 表示正常结束 |
| 函数名后的括号不能省 | 即使没有参数也要写 () |
| 一个函数只能有一个返回值 | 需要返回多个值时用引用参数或结构体 |
return 的两个作用
① 把值交回调用处
② 立即结束当前函数(后面的语句不再执行)
int f(int x) {
if (x < 0) return 0; // ★ 提前返回,后面的语句被跳过
return x * 2;
}
函数声明的作用:如果函数定义写在 main 后面,就必须先在前面写声明,否则编译器不认识这个函数名。
int add(int, int); // ★ 声明:告诉编译器"有这么个函数"
int main() {
cout << add(1, 2);
return 0;
}
int add(int a, int b) { // 定义在下面
return a + b;
}
3.2 形参与实参
| 概念 | 说明 |
|---|---|
| 形参(形式参数) | 定义函数时括号里声明的变量,只在函数内有效 |
| 实参(实际参数) | 调用函数时传入的具体值 |
★ 匹配规则:个数、顺序、类型都要对应(类型不合会自动转换)。
int f(int a, double b) { ... }
f(3, 4.5); // ✅ 正确
f(3); // ❌ 参数个数不对
f(4.5, 3); // ⚠️ 顺序错了,类型可转但语义错误
形参是局部变量:有自己的作用域和生命周期,函数返回后就消失了。
3.3 ★ 值传递 vs 引用传递(2025·17 考点)
值传递(默认):把实参的值复制一份给形参,函数里改的是那份副本。
void change(int x) { x = 100; } // 改的是副本
int main() {
int a = 5;
change(a);
cout << a; // 输出 5(没变!)
}
引用传递(在类型后加 &):形参是实参的别名,改形参就是改实参。
void change(int &x) { x = 100; } // ★ & 表示引用
int main() {
int a = 5;
change(a);
cout << a; // 输出 100(变了!)
}
对比表
| 值传递 | 引用传递 | |
|---|---|---|
| 写法 | void f(int x) | void f(int &x) |
| 是否复制 | 复制一份副本 | 不复制,是别名 |
| 函数内修改 | 不影响实参 | 直接影响实参 |
| 内存占用 | 各占一份 | 共用同一份 |
| 适用 | 只需读取数据 | 需要修改实参、或传大对象 |
void swap1(int a, int b) { int t = a; a = b; b = t; } // ❌ 交换失败
void swap2(int &a, int &b) { int t = a; a = b; b = t; } // ✅ 交换成功
★ 2025·17 详解:下列关于 C++ 函数参数传递的说法中,正确的是( ) A. 按值传递时,函数内部修改参数值会影响实参 → ❌(值传递不影响) B. 按引用传递时,函数参数是实参的别名,修改参数会直接影响实参 → ✅ C. 函数参数只能通过"按值传递"或"按引用传递"两种方式传递 → ❌(还有指针传递) D. 按值传递时,实参和形参占用相同的内存空间 → ❌(各占一份) 答案 B
3.4 数组作为函数参数
// 一维数组
void print(int a[], int n) { // ★ 长度要另外传!
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
// 二维数组:第二维必须写明长度
void show(int a[][5], int rows) { ... }
★ 重要特性:数组名作为参数时「退化为指针」
void f(int a[]) {
cout << sizeof(a); // ⚠️ 输出的是指针大小(8 或 4),不是数组大小!
}
结论:数组传进函数后,
sizeof就失效了,必须在参数里额外传长度n。
3.5 递归 ★★ 核心
递归三要素(缺一不可)
| 要素 | 说明 | 例子(阶乘) |
|---|---|---|
| ① 基线条件(终止条件) | 什么时候不再递归、直接返回 | if (n <= 1) return 1; |
| ② 递归调用 | 自己调用自己 | return n * f(n - 1); |
| ③ 向基线推进 | 每次调用规模都变小,最终能碰到基线 | n - 1 比 n 更接近 1 |
经典例子
// 阶乘 n!
int fact(int n) {
if (n <= 1) return 1; // ① 基线
return n * fact(n - 1); // ② 递归,③ 规模减 1
}
// fact(5) = 5*4*3*2*1 = 120
// 斐波那契
int fib(int n) {
if (n <= 2) return 1; // ① 基线
return fib(n - 1) + fib(n - 2); // ② 两次递归调用
}
// fib: 1 1 2 3 5 8 13 21 …
★ 递归求值四步法(考试专用)
第 1 步:找到"基线条件",写出最底层的确定值
第 2 步:从基线开始,逐步往回代,列成表格(不要跳步!)
第 3 步:遇到"双递归"(一个式子调用两次),把两个函数分开列两行
第 4 步:最后核对——每一项都要能由前几项算出
3.6 真题递归模型精讲
★ 模型一:隔项递归(2022·38–40)
int fun(int x) {
if (x == 0 || x == 1) return 3; // ★ 基线:x 为 0 或 1 时返回 3
else return x + fun(x - 2); // ★ 每次减 2
}
| 输入 | 展开 | 结果 |
|---|---|---|
| 1 | 直接命中基线 | 3 |
| 3 | 3 + fun(1) = 3 + 3 | 6 |
| 9 | 9 + fun(7) = 9 + 7 + fun(5) = 9+7+5+3+fun(1) = 9+7+5+3+3 | 27 |
通用展开式:
fun(9) = 9 + 7 + 5 + 3 + fun(1)。 注意:基线是x == 0 || x == 1,从 9 往下减 2 得到 7、5、3、1(命中基线),不是 0。
★ 模型二:带循环的递归(2023·38–40)
const int NUM = 5;
int fun(int n) {
if (n <= NUM) return n; // 基线:n ≤ 5 时返回 n 本身
for (int i = 1; i <= NUM; i++)
if (fun(n - i) < 0) return i; // ★ 找到第一个"负值"就返回 i
return -1; // 都不负 → 返回 −1
}
注意这个递归里带了一个 for 循环,要先把小的 fun 值全算出来:
| n | 计算 | fun(n) |
|---|---|---|
| 1–5 | 命中基线 | 1, 2, 3, 4, 5 |
| 6 | i=1→fun(5)=5;i=2→fun(4)=4;…;i=5→fun(1)=1,都不小于 0 | −1 |
| 7 | i=1→fun(6)=−1 < 0 → 返回 1 | 1 |
| 8 | i=1→fun(7)=1;i=2→fun(6)=−1 < 0 → 返回 2 | 2 |
| 9 | i=1→fun(8)=2;i=2→fun(7)=1;i=3→fun(6)=−1 < 0 → 返回 3 | 3 |
答案:输入 5 → 5;输入 6 → −1;输入 9 → 3。 方法:这类递归必须自底向上列表(1,2,3,…,n),一层层往上推,绝不能凭直觉跳步。
★ 模型三:约瑟夫环(2024·38–40)
int f(int n, int k) {
if (n == 1) return 0; // 基线
return (f(n - 1, k) + k) % n; // 递推式
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
int s = f(n, k);
printf("%d\n", s + 1); // ★ 输出时要 +1
return 0;
}
含义:n 个人围成一圈、每报到第 k 个人出列,问最后剩下的人是第几号(从 1 开始编号)。 递推公式的含义:从「n−1 个人」的答案,推出「n 个人」的答案 —— 多了一个人,相当于起点整体往后退 k 位,所以 +k 后对 n 取模。
逐项展开(务必列表)
| 输入 | f 的逐项值 | f(n,k)+1 | 答案 |
|---|---|---|---|
5 1 | f(1)=0 → f(2)=1 → f(3)=2 → f(4)=3 → f(5)=4 | 5 | 5 |
3 3 | f(1)=0 → f(2)=(0+3)%2=1 → f(3)=(1+3)%3=1 | 2 | 2 |
10 2 | 0 → 0 → 2 → 0 → 2 → 4 → 6 → 0 → 2 → 4 | 5 | 5 |
以
10 2为例,逐项为: f(1)=0 f(2)=(0+2)%2=0 f(3)=(0+2)%3=2 f(4)=(2+2)%4=0 f(5)=(0+2)%5=2 f(6)=(2+2)%6=4 f(7)=(4+2)%7=6 f(8)=(6+2)%8=0 f(9)=(0+2)%9=2 f(10)=(2+2)%10=4 → 输出 4+1 = 5
⚠️ 最大的坑:
main里输出的是s + 1。如果只算到f(n,k)=4就答 4,就错了。
★ 模型四:双递归(2025·37–40)
int fun2(int num) {
if (num <= 1) return num;
return fun2(num - 1) + num; // fun2(n) = 1 + 2 + … + n
}
int fun(int num) {
if (num <= 1) return num;
int ans = num - fun(num - 1) + fun2(num - 2);
return ans;
}
第一步:先搞清 fun2 到底算什么
fun2(0) = 0、fun2(1) = 1、fun2(2) = 1 + 2 = 3、fun2(3) = 1+2+3 = 6、fun2(4) = 10、fun2(5) = 15……
➡️ fun2(n) 就是 1 + 2 + … + n = n(n+1)/2
第二步:把 fun 逐项列表(用上面算好的 fun2 值)
| n | num - fun(n-1) + fun2(n-2) | fun(n) |
|---|---|---|
| 1 | 基线 | 1 |
| 2 | 2 − fun(1) + fun2(0) = 2 − 1 + 0 | 1 |
| 3 | 3 − fun(2) + fun2(1) = 3 − 1 + 1 | 3 |
| 4 | 4 − fun(3) + fun2(2) = 4 − 3 + 3 | 4 |
| 5 | 5 − fun(4) + fun2(3) = 5 − 4 + 6 | 7 |
| 6 | 6 − fun(5) + fun2(4) = 6 − 7 + 10 | 9 |
| 7 | 7 − fun(6) + fun2(5) = 7 − 9 + 15 | 13 |
| 8 | 8 − fun(7) + fun2(6) = 8 − 13 + 21 | 16 |
| 9 | 9 − fun(8) + fun2(7) = 9 − 16 + 28 | 21 |
答案:输入 1 → 1;输入 3 → 3;输入 5 → 7;输入 9 → 21。
★ 双递归的解题要点: ① 先把内层函数(fun2)单独算一遍,列成表; ② 再算外层,每一步都从表里查值,不要重新展开递归; ③ 遇到
fun(n-1)这种「依赖前一项」的,一定要从小到大算。
3.7 递归的两个常见问题
① 忘记基线条件 → 无限递归 → 栈溢出(Stack Overflow)
int f(int n) { return f(n - 1); } // ❌ 没有基线,程序崩溃
② 重复计算导致超时(了解)
fib(40) 会算 2⁴⁰ 次左右 —— 用「记忆化」或改成递推可解决
递归 vs 递推(迭代)
| 递归 | 递推(循环) | |
|---|---|---|
| 写法 | 自己调用自己 | 用循环从前往后算 |
| 可读性 | 简洁,贴近数学定义 | 略啰嗦 |
| 效率 | 有函数调用开销,可能重复计算 | 更高 |
| 风险 | 层数太深会栈溢出 | 无 |
C++语言中函数返回值的类型是由( )决定的。
答案:A
破题点:函数返回类型由定义时声明决定,不由 return 的表达式决定。
函数返回值类型在「定义函数」时由函数名前面的类型声明指定;return 后面的表达式会被自动转换成该类型。主调函数类型、实参类型都与返回值类型无关。选 A。
C++中当一个函数无返回值时,则该函数应声明为( )类型。
答案:void
破题点:无返回值 → void。
C++ 中用 void 表示函数不返回任何值,例如 void print(int x){ cout<<x; }。int 表示返回整数,float 返回实数,return 表示返回动作本身而不是类型。答案:void。
下列关于 C++ 函数参数传递的说法中,正确的是( )
答案:B
破题点:按值传递「复制一份」,按引用传递「起别名」。
按值传递时形参是实参的副本,占用不同内存,函数内修改不影响实参(A、D 错);按引用传递时形参是实参的别名,占用同一内存,修改立即反映到实参(B 对)。C 说「只能两种方式」也错——数组退化为指针、指针传递同样常见。选 B。
对于递推公式:F(n)=F(n-1)+3,已知 F(1)=2,求 F(5)的值是( )。
答案:14
破题点:等差数列:F(n) = F(1) + (n-1)×3。
F(1)=2;F(2)=5;F(3)=8;F(4)=11;F(5)=14。也可直接用通项:F(n) = 2 + (n-1)×3,F(5) = 2 + 12 = 14。答案:14。
已知子序列是从给定序列中通过删除一些元素(可以不删)后所得到的序列。这些元素的顺序要和原序列中元素的相对顺序保持一致。
最长上升子序列是在一个序列中,找出一个子序列,这个子序列中的元素是严格递增的, 并且在所有满足递增条件的子序列中它的长度是最长的。
对于序列 3,1,5,7,9,8,6,2,4 来说,最长上升子序列的长度为( )。
答案:4
破题点:在序列里依次挑出更大的数,尽量多挑。
序列 3,1,5,7,9,8,6,2,4。从 1 开始挑:1,5,7,9(长度 4);也可 1,5,7,8 → 也是 4;1,2,4 只有 3。最长是 4。答案:4。
下列关于C++语言中函数的叙述,正确的是( )。
答案:A
C++ 中函数必须通过函数名被调用,匿名函数除外但也需借助变量/直接调用语法,常规函数「必须有名字」。答案 A。
下列关于C++语言中函数的叙述,正确的是( )。
答案:B
函数调用时实参的个数必须与形参匹配(可以提供默认参数,但不能少传没有默认值的参数)。答案 B。
下面有关函数参数的说法,正确的是( )。
答案:A
值传递时形参是实参的**副本**,子函数修改形参不会影响主函数里的实参,这是值传递的基本特征。答案 A。
若函数声明为int f(int &x){ x+=3; return x; },则对声明的变量int a=3,下面哪个调用能够改变a 的值( )。
答案:C
形参写成 int &x 就是引用传递,形参是实参的别名,函数内 x += 3 会直接改变实参 a 的值。答案 C(f(a);)。
在C++语言中,一个函数没有被调用时,它的参数不占用内存。
答案:A
局部变量(含形参)在函数被调用时才分配内存、调用结束就释放,不被调用时不占内存。说法正确。答案 A(正确)。
下面关于递推的说法不正确的是( )。
答案:A
「自己调用自己」是**递归**的特征;递推是「由前一项推出后一项」的迭代过程,两者不同。答案 A。
关于递推算法的描述,正确的是( )。
答案:B
递推三要素:已知初值、递推关系、逐步推进。B 的描述完整准确。答案 B。
数列1, 1, 2, 3, 5, 8 ... 是以意大利数学家列昂纳多·斐波那契命名的数列,从第三个数开始,每个数是前面两项之和。如果计算该数列的第n 项(其中n>3)fib(n),我们采用如下方法:①令fib(1)=fib(2)=1 ②用循环for i=3 to n 分别计算f(i) ③输出fib(n)。这体现了递推的编程思想。
答案:A
用循环递推求斐波那契第 n 项只需从前两项顺推 n 步,时间复杂度 O(n)、空间 O(1);若用朴素递归则是 O(2ⁿ)。说法正确。答案 A(正确)。
递推是一种通过已知的初始值和递推公式,逐步求解目标值的算法。
答案:A
这是递推的标准定义:初始值 + 递推公式 → 目标值。说法正确。答案 A(正确)。
#include<cstdio>
#include<iostream>
using namespace std;
int fun(int x)
{
if(x==0 || x==1) return 3;
else return x+fun(x-2);
}
int main()
{
int k;
cin>>k;
printf("%d", fun(k));
return 0;
}输入数据:1
输出数据:( )
输入数据:3
输出数据:( )
输入数据:9
输出数据:( )
- 第 1 空3 展开递归:fun(x) = x + (x-2) + (x-4) + … 直到 0 或 1 处补 3。
- 第 2 空6 展开递归:fun(x) = x + (x-2) + (x-4) + … 直到 0 或 1 处补 3。
- 第 3 空27 展开递归:fun(x) = x + (x-2) + (x-4) + … 直到 0 或 1 处补 3。
#include<iostream>
using namespace std;
const int NUM=5;
int fun(int n)
{
if(n<=NUM) return n;
for(int i=1;i<=NUM;i++)
if(fun(n-i)<0) return i;
return -1;
}
int main(){
int n;
cin>>n;
cout<<fun(n)<<endl;
return 0;
}输入数据:5
输出数据:( )
输入数据:6
输出数据:( )
输入数据:9
输出数据:( )
- 第 1 空5 自顶向下展开递归,注意 NUM 是常量 5;对 n ≤ 5 一律返回 n。
- 第 2 空-1 自顶向下展开递归,注意 NUM 是常量 5;对 n ≤ 5 一律返回 n。
- 第 3 空3 自顶向下展开递归,注意 NUM 是常量 5;对 n ≤ 5 一律返回 n。
- 第 1 题A 返回类型在函数定义时就定死了,`return` 的表达式会被转换成该类型;写 `int f()` 就返回 int。
- 第 2 题B 不返回值用 `void`;写成 `int` 却没 `return`,返回值是未定义的随机值,属于常见错误。
- 第 3 题C 普通形参是副本,交换副本不影响实参;加 `&` 让形参成为实参的别名,才能真正交换。
- 第 4 题D 递归题最忌讳跳步,规范做法是从 `fun(1)`、`fun(2)` 起把表列满,每层都代入上一层的结果。
- 第 5 题A 基线条件是递归的出口,先确定它返回什么,往上推才不会推错方向。
- 第 6 题B 减 2 依次得到 7、5、3、1,1 命中基线 `x==1` 返回 3,所以是 9+7+5+3+3 = 27,而不是一直加到 0。
- 第 7 题C 外层函数会反复查内层的值,先把内层整张表独立算好,再算外层就不容易乱。
- 第 8 题D 递推得到的是 0-based 编号,题目若按 1 开始编号,输出必须 `+1`,漏掉就差 1。
- 第 9 题A 循环里每次都调同一个递归,把从小到大的值全部列表,后面只需查表,既快又不易错。
- 第 10 题B 数组名作参数会退化为指针,`sizeof` 只能得到指针大小,所以长度必须作为额外参数传进来。
- 第 11 题C 没有出口的递归会不断压栈,耗尽栈空间后崩溃;基线条件是递归三要素的第一条。
- 第 12 题D 编译器从上往下读,`main` 里用到还没见过的函数就会报错,所以要先写函数原型。
- 第 13 题A 二维数组传参必须给出第二维的长度,且必须是常量,写成 `int a[][5]` 才合法。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写递归三要素(基线条件、递归调用、规模递减),各用一句话说清含义。
- 手算
int fun(int x){ if(x==0||x==1) return 3; return x+fun(x-2); }的fun(3)与fun(9),并列出从 fun(1) 到 fun(9) 的完整取值表。 - 默写值传递与引用传递两种函数写法,并说明为什么
swap(int a,int b)交换不了两个数。 - 用列表法算出
fun(1)=1、fun(n)=n−fun(n−1)+fun2(n−2)、fun2(n)=1+2+…+n时的fun(5),写出每一步代入过程。 - 推导约瑟夫环
f(1)=0、f(n)=(f(n-1)+k)%n下的f(5,1),并说明输出为什么要+1。 - 写出一条把数组长度作为参数传入的函数头,并解释函数内为什么不能用
sizeof求数组长度。 - 把四类递归模型(隔项 / 带循环 / 约瑟夫环 / 双递归)各手算一遍,并写成表格
- 背诵「递归求值四步法」
- 完成客观题 14 题(
DAY16-01~DAY16-14) - 完成阅读程序小片段 1 组
本日关键记忆:返回类型由定义决定 · 无返回写
void· 值传递改不了实参 / 引用传递&能改 · 递归三要素 · 递归必须列表、不许跳步 · 双递归先算内层 · 约瑟夫环别忘+1
结构体与自定义类型
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
(本年暂无该考点真题,属新增/补强内容)
难易度:中等(★★★☆☆) 近 4 年合计:0 题 / 0 分
2026 年备考建议
站在出题人的视角,结构体四年真题一分未考,但大纲明确列着,复赛里几乎每道稍复杂的题都要用它。命题人要的不是背语法,而是检验“会不会用自定义类型把数据打包”——一旦它和排序、函数传参一起出现在阅读程序里,看不懂定义就整题读不下去,区分度照样很高。
所以目标是“零死角会用”:定义末尾的分号、. 与 -> 的区别、成员数组长度必须是常量、结构体数组下标从 0 开始,这些是送分点。更要把结构体和 sort 练熟:cmp 返回 true 表示第一个参数排在前面,按总分降序写 a.total > b.total,cmp 里千万别用 >=。
再记一条效率常识:结构体作函数参数建议写 const Student &s,既不整份复制,也不会误改。
②知识地图 · 本考点思维导图
- 结构体的定义
- struct 名字 { 成员列表 }; ← ★ 末尾有分号
- 成员可以是不同类型
- 结构体变量的定义与初始化
- 定义时直接初始化
- 逐个成员赋值(用 . )
- 列表初始化 { }
- 成员访问
- 变量名.成员名
- 结构体数组
- 定义、遍历、赋值
- 结构体与函数
- 作为参数(建议用引用 &)、作为返回值
- 结构体与排序 ★
- sort + 自定义比较函数 cmp
- 多关键字排序
- typedef 与别名
- typedef struct {...} Name; / using Name = ...;
③核心精讲
3.1 为什么要用结构体
问题:描述一个学生的「姓名 + 语文 + 数学 + 英语 + 总分」,用数组要开四个数组,容易对不上号。
// 用数组(麻烦)
string name[100];
int chinese[100], math[100], english[100], total[100];
// 用结构体(清晰)
struct Student {
string name; // 姓名
int chinese; // 语文
int math; // 数学
int english; // 英语
int total; // 总分
};
Student s[100]; // 100 个学生,每人自带 5 个属性
结构体的本质:把若干个不同类型的数据打包成一个整体,作为一个新的「自定义类型」使用。
3.2 结构体的定义 ★
struct 类型名 {
成员类型 成员名;
成员类型 成员名;
...
}; // ★ 末尾的分号千万不能少!
struct Point {
int x;
int y;
}; // ★ 定义了一种新类型 Point
⚠️ 最常见的错误:忘记最后的分号。
struct { ... }后面必须跟;。
3.3 结构体变量的定义与初始化
① 定义时直接声明变量
struct Point { int x, y; } p1, p2;
② 先定义类型,再声明变量(推荐)
struct Point { int x, y; };
Point p1, p2;
③ 初始化
Point p1 = {3, 4}; // 按成员顺序依次赋值
Point p2 = {0}; // x = 0,y 自动为 0
Point p3; // 局部变量未初始化 → 成员是随机值
// 逐个赋值
Point p4;
p4.x = 10;
p4.y = 20;
注意:
Point p3;如果是局部变量,x、y都是随机值;如果是全局变量,成员自动为 0。
3.4 成员访问:用点号 .
struct Student {
string name;
int score;
};
Student s;
s.name = "小明"; // ★ 用 . 访问成员
s.score = 95;
cout << s.name << " " << s.score;
结构体指针访问用 ->
Student *p = &s;
cout << p->name; // 等价于 (*p).name
三种符号区分(回看 DAY05):
::作用域解析(命名空间/类) ·.对象成员访问 ·->指针成员访问
3.5 结构体数组
struct Student {
string name;
int score;
} s[3];
// 输入
for (int i = 0; i < 3; i++) cin >> s[i].name >> s[i].score;
// 输出
for (int i = 0; i < 3; i++) cout << s[i].name << " " << s[i].score << endl;
初始化结构体数组
Student s[3] = {
{"小明", 95},
{"小红", 88},
{"小刚", 76}
};
结构体数组可以整体赋值(同类型之间)
Student a = {"小明", 95};
Student b;
b = a; // ✅ 结构体可以直接整体赋值
3.6 结构体作为函数参数与返回值
// 作为参数(数据大时建议用引用,避免复制)
int getTotal(Student &s) {
return s.chinese + s.math + s.english;
}
// 作为返回值
Point makePoint(int a, int b) {
Point p;
p.x = a; p.y = b;
return p;
}
为什么要用
&:结构体往往包含多个成员,按值传递会整份复制,效率低;加&传引用既不复制,又只读时不加const也能避免改动(严谨写法是const Student &s)。
3.7 ★ 结构体与排序(复赛必备)
问题:给学生按总分从高到低排序,总分相同按语文从高到低排。
#include <bits/stdc++.h>
using namespace std;
struct Student {
string name;
int chinese, math, english, total;
};
// ★ 自定义比较函数:返回 true 表示 a 应排在 b 前面
bool cmp(Student a, Student b) {
if (a.total != b.total) return a.total > b.total; // 总分高的在前
return a.chinese > b.chinese; // 总分相同,语文高的在前
}
int main() {
int n; cin >> n;
Student s[105];
for (int i = 0; i < n; i++) {
cin >> s[i].name >> s[i].chinese >> s[i].math >> s[i].english;
s[i].total = s[i].chinese + s[i].math + s[i].english;
}
sort(s, s + n, cmp); // ★ 第三个参数传比较函数
for (int i = 0; i < n; i++)
cout << s[i].name << " " << s[i].total << endl;
return 0;
}
cmp 函数的三条规则
| 规则 | 说明 |
|---|---|
① 返回值是 bool | true 表示第一个参数应排在前面 |
② a > b 表示降序 | a < b 表示升序 |
| ③ 多关键字排序 | 先比第一关键字,相等再比第二关键字,依次往下 |
★ 常见排序写法对照
| 需求 | cmp 写法 |
|---|---|
| 升序 | return a < b; |
| 降序 | return a > b; |
| 按总分降序 | return a.total > b.total; |
| 双关键字(主降副升) | if (a.x != b.x) return a.x > b.x; return a.y < b.y; |
易错点:
cmp里不能写a.total >= b.total(要用>)。用>=在相等时会返回true,导致排序算法行为异常(严格弱序被破坏),可能引发运行时错误。
3.8 typedef 与类型别名
// 写法一:先定义 struct,再起别名
struct Point { int x, y; };
typedef Point P;
// 写法二:定义与起别名合并(C 语言风格)
typedef struct {
int x, y;
} Point;
// 写法三:C++ 推荐(using)
using Point = struct { int x, y; };
常见用途:把 unsigned long long 缩写成 ull,或给结构体起短名。
typedef long long ll;
ll a = 100000000000LL; // 简洁清晰
下面的描述中,( )正确定义一个名为Person 的结构体并正确初始化了一个Person 结构体的变量p。
答案:C
结构体定义要用 struct 关键字 + 类型名 + 花括号;初始化时成员值要按声明顺序用花括号给出。答案 C。
关于结构体初始化,以下哪个选项中正确的是( )。
struct Point {int x,y;};答案:B
聚合初始化:Point p = {1,2}; 即 x=1、y=2。答案 B。
下列关于结构体初始化的写法,正确的是( )。第 2 页 / 共 11 页
答案:B
struct Point { int x, y; }; 后用 Point p = {1, 2}; 初始化,成员按顺序对应。答案 B。
结构体的成员默认是public 访问权限。
答案:A
struct 的成员默认访问权限是 public,class 的默认才是 private。说法正确。答案 A(正确)。
下面c++代码在一个结构体中又定义了别的结构体。这种结构嵌套定义的方式语法不正确。
#include <string>
#include <vector>
using namespace std;
struct Library {
struct Book {
struct Author {
string name;
int birthYear;
};
string title;
int year;
Author author;
};
string name;
vector<Book> books;
};答案:B
结构体中可以嵌套定义其他结构体(包括自己定义的结构体类型),语法完全合法,常用于描述复杂对象。说法错误。答案 B(错误)。
下列关于C++语言中指针的叙述,不正确的是( )。
答案:C
指针可以指向任意类型,包括指向另一个指针(如 int **p 二级指针),这不违反语法。答案 C。
下列关于C++语言中指针的叙述,不正确的是( )。
答案:D
void* 是通用指针类型,可以定义、可以接收任意类型的地址(只是不能直接解引用)。答案 D。
运行下面代码片段后,x 和*p 的结果分别是( )。
int x = 20;
int* p = &x;
*p = *p + 2;答案:D
int* p = &x; 让 p 指向 x,则 *p 与 x 是同一块内存的两个名字。*p = *p + 2 即 x = x + 2 = 22,所以 x 和 *p 都是 22。答案 D。
以下哪种参数传递方式可以避免拷贝大型对象?
答案:D
值传递要复制整个对象;引用传递和指针传递都只传地址,不会拷贝大对象。答案 D。
在 C++ 中,下面代码可以正确定义指针和初始化指针。
int* ptr;
*ptr = 10;答案:B
int* ptr; 只是定义了指针,它指向的地址是随机的(野指针);此时 *ptr = 10 会把 10 写到未知内存,是严重的未定义行为。正确做法是先 ptr = &x; 再解引用。答案 B(错误)。
#include <iostream>
using namespace std;
struct stu {
string name;
int score;
};
int main(){
stu a = {"Tom", 90}, b = {"Amy", 95};
if(a.score < b.score) swap(a, b);
cout << a.name << " " << a.score << endl;
return 0;
}程序输出为( )。
访问结构体变量 a 的成员 score,正确的写法是( )。
结构体的作用是让程序员自己定义一种新的数据类型。
- 第 1 题B 逐句跟踪:a = {"Tom", 90}、b = {"Amy", 95};判断 a.scor…
- 第 2 题B 普通结构体变量用「.」访问成员:a.score、a.name。只有指向结构体的**指针**才…
- 第 3 题A 结构体正是「用户自定义数据类型」。它把若干不同类型的数据(如 string 名字 + int…
- 第 1 题A 结构体定义的右花括号后必须跟分号,这是语句结束标志,漏写会报编译错误。
- 第 2 题B 普通结构体变量用点号 `.` 访问成员,箭头 `->` 只用于结构体指针。
- 第 3 题C 局部结构体变量的成员不会自动清零,用之前必须逐个赋值,否则结果不确定。
- 第 4 题D C++ 数组下标从 0 开始,长度 5 的数组合法下标是 0~4,用 5 就越界了。
- 第 5 题A `sort` 要求严格弱序,相等元素必须返回 `false`;用 `>=` 时相等也返回真,会导致排序行为异常。
- 第 6 题B `sort` 默认用 `<` 比较,结构体没有定义 `<`,所以必须自己传 `cmp`,否则编译不通过。
- 第 7 题C 传值会整份复制,效率低;用 `const` 引用既避免复制,又保证函数内不会改动原对象。
- 第 8 题D C++ 不会自动为结构体生成 `==`,默认比较不合法;要判断相等必须逐个成员比或重载运算符。
- 第 9 题A `typedef ... 别名;` 的别名写在最末尾,写完就能直接用 `Point p;` 声明变量。
- 第 10 题B 结构体成员数组长度必须是编译期常量,用变量会报错;需要变长应改用 `vector` 或指针。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写一个含 x、y 两个整数成员的结构体定义,注意结尾的分号不能漏。
- 分别写出用
.和->访问结构体成员的代码,并说明各自用在什么场合。 - 声明一个长度为 5 的结构体数组,写出它的合法下标范围并说明为什么不是 1 到 5。
- 写出按总分降序排列结构体数组的
cmp函数,并说明为什么不能用>=。 - 写出
typedef struct { ... } Point;的完整形式,并解释别名写在什么位置。 - 写出结构体作函数参数的推荐写法
const Student &s,说明它比传值好在哪里。 - 独立写出「结构体 +
sort多关键字排序」的完整可运行程序 - 记住三种成员访问符号:
::、.、-> - 完成客观题 10 题(
DAY17-01~DAY17-10,题源以 GESP 与综合练习为主) - 完成阅读程序小片段 1 组
本日关键记忆:
struct { ... };末尾有分号 ·.访问成员 /->访问指针成员 · 结构体数组下标从 0 起 ·cmp用>降序、<升序、别用>=· 多关键字:先判不等再比次关键字
初等数论与数学逻辑题
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 28 题 | 填空题 | 3 分 |
| 2023 | 第 18 题 | 单项选择 | 2 分 |
| 2023 | 第 28 题 | 填空题 | 3 分 |
| 2024 | 第 4 题 | 单项选择 | 1 分 |
| 2024 | 第 5 题 | 单项选择 | 1 分 |
| 2024 | 第 13 题 | 单项选择 | 2 分 |
| 2025 | 第 4 题 | 单项选择 | 2 分 |
| 2025 | 第 13 题 | 单项选择 | 2 分 |
| 2025 | 第 28 题 | 单项选择 | 2 分 |
难易度:较难(★★★★☆) 近 4 年合计:9 题 / 18 分
2026 年备考建议
站在出题人的视角,数论和逻辑推理是初赛里性价比最奇特的一块:不占阅读程序那样的大分,但每年单选、填空都稳稳出现,四年 9 题 21 分,还在填空里额外塞了最大公约数、整除性 2 空。命题人偏爱它,因为题目短、答案唯一、区分度却高——思路通了半分钟出结果,想不通硬枚举能耗光时间。
所以要练“识别题型、调用工具”:见 gcd 就用辗转相除法一步步算,牢记 a×b = gcd×lcm;见“商之和”要知道两数除以 gcd 后的商一定互质;见余数问题先分清“余数相同”还是“差相同”,再用口诀一步合并。
最容易丢分的几处盯死:1 既不是质数也不是合数、2 是唯一的偶质数、整百年份要被 400 整除才是闰年、一笔画看的是奇度顶点个数(0 或 2)、整除 3 和 9 看各位数字之和。
②知识地图 · 本考点思维导图
- 整数基本概念
- 质数(素数)/ 合数 / 1 既不是质数也不是合数
- 质因数分解
- 因数(约数)与倍数
- 最大公约数 gcd 与最小公倍数 lcm
- 辗转相除法(欧几里得算法)
- 公式:a × b = gcd(a,b) × lcm(a,b)
- 短除法 / 质因数分解法
- 互质与欧拉函数
- 互质:gcd(a,b) = 1
- φ(n):1~n 中与 n 互质的个数
- 整除性与同余
- 常见整除特征(2/3/4/5/8/9/11)
- 余数问题与「差同减差」
- 中国剩余定理思想
- 数位与进位
- 数位拆分(n % 10、n / 10)
- 数字和与整除
- 逻辑推理模型
- 闰年与日期计算
- 一笔画(欧拉路/欧拉回路)
- 过河问题
- 抽屉原理
③核心精讲
3.1 质数与合数
| 概念 | 定义 | 举例 |
|---|---|---|
| 质数(素数) | 只有 1 和它本身两个正因数的大于 1 的自然数 | 2, 3, 5, 7, 11, 13, 17, 19, 23, 29… |
| 合数 | 除了 1 和本身还有其他因数的自然数 | 4, 6, 8, 9, 10, 12, 14, 15… |
| 1 | 既不是质数,也不是合数 | — |
★ 必背小结论
- 2 是唯一的偶质数;
- 最小的质数是 2,最小的合数是 4;
- 100 以内的质数共 25 个:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
质因数分解
36 = 2² × 3²
100 = 2² × 5²
1925 = 5² × 7 × 11
因数个数公式:若 n = p₁^a₁ × p₂^a₂ × … × pₖ^aₖ,则
因数个数 = (a₁ + 1) × (a₂ + 1) × … × (aₖ + 1)
例:
36 = 2² × 3²→(2+1)×(2+1) = 9个因数(1,2,3,4,6,9,12,18,36 ✔)
3.2 最大公约数与最小公倍数 ★★
定义
| 名称 | 含义 | 记法 |
|---|---|---|
| 最大公约数 | 能同时整除两数的最大正整数 | gcd(a, b) |
| 最小公倍数 | 能同时被两数整除的最小正整数 | lcm(a, b) |
★ 方法一:辗转相除法(欧几里得算法)
gcd(a, b) = gcd(b, a mod b),直到 b = 0,此时 gcd = a
★ 2023·18 详解:
gcd(253, 299)gcd(253, 299) = gcd(253, 299 mod 253) = gcd(253, 46) = gcd(46, 253 mod 46) = gcd(46, 23) ← 253 = 46×5 + 23 = gcd(23, 46 mod 23) = gcd(23, 0) ← 46 = 23×2 + 0 = 23答案 C(23)
★ 2022·28 详解:
gcd(1001, 1989)先做质因数分解更快:1001 = 7 × 11 × 131989 ÷ 1001 = 1余 988;也可以用「两数差」的技巧:1989 − 1001 = 988,而1001 ÷ 13 = 77、1989 ÷ 13 = 153。 分解验证:1989 = 3² × 13 × 17,与1001 = 7 × 11 × 13的公共质因数是 13,且只有 13。 答案:13
★ 方法二:短除法 / 质因数分解法(考试常用)
★ 2023·28 详解 题目:两数的最小公倍数是 1925,两数分别除以它们的最大公约数,得到的 2 个商之和是 16,求这两个数(小的写在前)。
设:两数为
g·a和g·b,其中g = gcd,且a、b互质(这是关键!)。lcm = g·a·b = 1925 a + b = 16把 1925 分解:
1925 = 5² × 7 × 11逐个试
g,使a·b = 1925 / g且a + b = 16,且 a、b 互质:
g a·b = 1925/g 能拆成和为 16 且互质的两数? 5 385 = 5×7×11 需和为 16:5+11=16 ✔ 但 5 与 11 互质 ✔(385 = 55) 7 275 = 5²×11 需和为 16:? 不行 11 175 = 5²×7 需和为 16:? 不行 25 77 = 7×11 7+11=18 ✘ 35 55 = 5×11 5 + 11 = 16 ✔ 且互质 ✔ 取
g = 35,a = 5、b = 11(或反过来):两数 = 35 × 5 = 175,35 × 11 = 385答案:
175 385验算:
gcd(175, 385) = 35;lcm = 175 × 385 ÷ 35 = 1925✔;5 + 11 = 16✔破题关键:「两数除以最大公约数后的商一定互质」——这是这类题的通用突破口。
★ 核心公式(必背)
a × b = gcd(a, b) × lcm(a, b)
3.3 互质与欧拉函数
互质:两个数的最大公约数为 1,记作 gcd(a,b) = 1。
注意:互质不要求两个数都是质数!例如
8和9互质(8 = 2³、9 = 3²,没有公共质因数)。
★ 欧拉函数 φ(n):1 ~ n 中与 n 互质的整数个数。
公式:若 n = p₁^a₁ × p₂^a₂ × … × pₖ^aₖ,则
φ(n) = n × (1 − 1/p₁) × (1 − 1/p₂) × … × (1 − 1/pₖ)
★ 2024·13 详解:100 以内和 100 互质的正整数个数?
100 = 2² × 5²→ 质因数是 2 和 5φ(100) = 100 × (1 − 1/2) × (1 − 1/5) = 100 × 1/2 × 4/5 = 40答案 B(40)
验算(另一条路):100 以内与 100 不互质的数 = 2 的倍数或 5 的倍数
⌊100/2⌋ = 50、⌊100/5⌋ = 20、⌊100/10⌋ = 10由容斥原理:50 + 20 − 10 = 60个不互质 →100 − 60 = 40个互质 ✔
★ 2025·28 详解:「最小互质子集」= 元素最少的、整体互质(gcd 为 1)的子集;元素个数叫「最小互质阶」。哪个数列的最小互质阶最大? A. 1,2,3,4,5,6 →
{1,2}就互质(gcd = 1)→ 阶 2 B. 2,4,6,8,10,12 → 全是偶数,任取几个 gcd 都 ≥ 2 → 不存在互质子集 → 阶 0 C. 6,10,12,15,20,30 →{6,10,15}的 gcd = 1;而任取两个都有公因数(6&10=2、6&15=3、10&15=5…)→ 阶 3 D. 10,14,20,21,28,35 →{10,21}互质 → 阶 2 最大的是 C 的 3 → 答案 C破题关键:要判断「整体互质」必须算出这几个数的公共 gcd;两个数互质的判据是「没有公共质因数」。
3.4 整除性与同余
★ 常见整除特征(速查)
| 除数 | 判断方法 |
|---|---|
| 2 | 末位是偶数 |
| 3 | 各位数字之和能被 3 整除 |
| 4 | 末两位能被 4 整除 |
| 5 | 末位是 0 或 5 |
| 8 | 末三位能被 8 整除 |
| 9 | 各位数字之和能被 9 整除 |
| 11 | 奇数位数字和与偶数位数字和之差能被 11 整除 |
★ 同余记号与「差同减差」
a ≡ b (mod m) 表示 a 除以 m 和 b 除以 m 的余数相同
★ 2025·13 详解:一个三位数,除以 7 余 3、除以 8 余 4、除以 9 余 5,最小是多少?
观察:
3 = 7 − 4、4 = 8 − 4、5 = 9 − 4也就是这个数「差 4 就能被 7、8、9 同时整除」:n ≡ −4 (mod 7) n ≡ −4 (mod 8) n ≡ −4 (mod 9)三数同余 → 合并:
n ≡ −4 (mod lcm(7,8,9)) = −4 (mod 504) n = 504k − 4取最小的三位数:
k = 1 → n = 500 ✔(三位数)答案 C(500) 验算:
500 ÷ 7 = 71 余 3 ✔;500 ÷ 8 = 62 余 4 ✔;500 ÷ 9 = 55 余 5 ✔★ 破题口诀:余数问题的三种合并方式
情形 处理办法 余数相同 取「余数 + 各模数的最小公倍数」的倍数 除数与余数的差相同(本题) 差同减差:取「−差 + lcm 的倍数」 余数与除数互质、都没规律 逐个试(从最小的模数开始枚举)
3.5 闰年与日期计算
★ 闰年判断规则(三年一考)
闰年 ⟺ (年份能被 4 整除 且 不能被 100 整除) 或 (年份能被 400 整除)
| 年份 | 是否闰年 | 判断 |
|---|---|---|
| 2024 | 闰年 | 被 4 整除,不被 100 整除 |
| 1900 | 不是闰年 | 被 100 整除但不被 400 整除 |
| 2000 | 闰年 | 被 400 整除 |
| 2100 | 不是闰年 | 被 100 整除但不被 400 整除 |
平闰年的天数
| 平年 | 闰年 | |
|---|---|---|
| 2 月 | 28 天 | 29 天 |
| 全年 | 365 天 | 366 天 |
★ 2024·4 详解:小唐于公历 1888 年 2 月 29 日出生,1910 年之前过了几次生日?
只在闰年的 2 月 29 日才有「生日」。从 1889 到 1909 的闰年是:
1892 ✔(被 4 整除,不被 100 整除) 1896 ✔ 1900 ✘(被 100 整除,但不被 400 整除 —— 这是本题的"陷阱年") 1904 ✔ 1908 ✔共 4 次(1892、1896、1904、1908)→ 答案 D(4)
⚠️ 陷阱:如果不记得「整百年份必须被 400 整除」这条,就会把 1900 也算进去,错答 5 次。
3.6 一笔画(欧拉路与欧拉回路)★
定义
| 名称 | 含义 |
|---|---|
| 欧拉路 | 从某点出发,每条边恰好经过一次,走遍所有边 |
| 欧拉回路 | 欧拉路的起点与终点相同(能回到起点) |
★ 判别定理(必背)
① 统计每个顶点的"度"(连出去的边数)
② 如果所有顶点的度都是偶数 → 存在欧拉回路(可以一笔画并且回到起点)
③ 如果恰好有 2 个顶点的度是奇数 → 存在欧拉路(可以一笔画,但起点终点不同)
④ 如果奇度顶点个数是 0 或 2 以外的值(如 4 个、6 个)→ ★ 不能一笔画
一句话口诀:「奇点 0 个或 2 个,才能一笔画」。
★ 2024·5 详解:下面哪个选项的图形可以实现一笔画出? 解题步骤:
- 数出图形中每个交点(顶点)连接了几条线;
- 统计奇度顶点的个数;
- 奇度顶点个数为 0 或 2 的图形才能一笔画。
本题答案为 C(该图形恰有 2 个奇度顶点)。
⚠️ 常见干扰项:看起来「很简单」的图形如果奇度顶点有 4 个,也不能一笔画。
经典推论
| 图形 | 奇度顶点数 | 能否一笔画 |
|---|---|---|
| 一条线段 | 2 | ✔ |
| 三角形 | 0 | ✔ |
| 正方形 | 0 | ✔ |
| 正方形 + 两条对角线 | 4(每个顶点度都是 3) | ✘ |
| 「日」字型(两个相邻方块) | 2 | ✔ |
3.7 过河问题(逻辑推理)
★ 2025·4 详解:猎人带一只羊、一头狼、一筐白菜过河,船每次只能载猎人和一样东西。猎人不在时狼吃羊、羊吃白菜。最少渡河几次(过河和返回各算一次)?
推演过程:
次数 动作 左岸(出发岸) 右岸(对岸) 1 猎人带羊过河 狼、白菜 猎人、羊 2 猎人空手返回 猎人、狼、白菜 羊 3 猎人带狼过河 白菜 猎人、狼、羊 4 猎人带羊返回 猎人、羊、白菜 狼 5 猎人带白菜过河 羊 猎人、狼、白菜 6 猎人空手返回 猎人、羊 狼、白菜 7 猎人带羊过河 — 全部过河 ✔ 共 7 次 → 答案 D
★ 破题要点: ① 羊是"中间人"——它既会被狼吃,又会吃白菜,所以必须先把羊运走; ② 关键一步是第 4 步「把羊带回来」——很多同学想不到这一步,就会得到 5 次的错误答案; ③ 过河与返回都算一次(题目已说明)。
3.8 抽屉原理与数位拆分(补充)
抽屉原理:把 n+1 个物体放进 n 个抽屉,至少有一个抽屉有 2 个或更多物体。
例:13 个人中至少有 2 个人同月出生(12 个月 = 12 个抽屉)。
数位拆分
while (n > 0) {
int d = n % 10; // 取出最低位数字
// 处理 d ...
n /= 10; // 去掉最低位
}
常用结论:一个数能被 9 整除 ⟺ 它的各位数字之和能被 9 整除。
最大公因数,也称最大公约数、最大公因子,指两个或多个整数共有约数中最大的 一个,请问:1001 和 1989 两个整数的最大公约数为( )。
答案:13
破题点:辗转相除法:gcd(1001,1989)。
1989 - 1001 = 988;gcd(1001,988):1001 - 988 = 13;988 ÷ 13 = 76 整除,所以 gcd = 13。也可用欧几里得算法 1989 mod 1001 = 988,1001 mod 988 = 13,988 mod 13 = 0 → 13。答案:13。
253 和 299 的最大公约数是( )
答案:C
破题点:辗转相除两步出结果。
299 mod 253 = 46;253 mod 46 = 253 - 46×5 = 23;46 mod 23 = 0 → gcd = 23。选 C。
两个整数的最小公倍数是 1925,这两个整数分别除以它们的最大公约数,得到 2 个 商的和是 16,这两个整数分别是( )(注:较小的数写在前)。
答案:175 385
破题点:设两数为 gx、gy(gcd(x,y)=1),则 lcm = gxy。
1925 = 5² × 7 × 11。设两数为 g·x、g·y,x 与 y 互质,x + y = 16,且 g·x·y = 1925。试 x=5、y=11:乘积 55,g = 1925÷55 = 35,得两数 175 与 385,验算 gcd(175,385)=35、lcm=1925 ✓。答案:175 385。
100 以内和 100 互质的正整数个数有( )个
答案:B
破题点:欧拉函数 φ(100) = 100×(1-1/2)×(1-1/5)。
100 = 2² × 5²,与 100 互质即不能被 2 或 5 整除。φ(100) = 100 × (1 - 1/2) × (1 - 1/5) = 100 × 1/2 × 4/5 = 40。选 B。
一个三位数,除以 7 余 3,除以 8 余 4,除以 9 余 5,这个数最小是( )。
答案:C
破题点:观察余数:都比除数小 4 → n+4 同时被 7、8、9 整除。
n ÷ 7 余 3 → n + 4 能被 7 整除;n ÷ 8 余 4 → n + 4 能被 8 整除;n ÷ 9 余 5 → n + 4 能被 9 整除。lcm(7,8,9) = 504,所以 n + 4 = 504(取最小),n = 500。选 C。
一个正整数数列中的若干(至少为 2)整体互质元素组成的集合,我们称之为“互质
子集”,而其中元素数量最小的子集被称为“最小互质子集”,“最小互质子集”的元
素个数被称为这个数组的“最小互质阶”。(注:若干个数整体互质就是指这些数的最
大公约数为 1)
显然,一个数列的互质子集不一定存在,此时我们定义这个数列的最小互质阶为 0。提问:
下面的四个选项中,哪个数列的最小互质阶最大( )?
答案:C
破题点:「整体互质」= 这一组数的 gcd 为 1;逐个选项找最小的互质组合。
A:{1,2} 的 gcd = 1,阶为 2。B:全是偶数,任取两个 gcd 至少 2,不存在互质子集,阶为 0。C:两两都不互质,但 {6,10,15} 的 gcd = 1(gcd(6,10)=2,gcd(2,15)=1),阶为 3。D:{10,21} 的 gcd = 1,阶为 2。最大的是 C 的 3。选 C。
小唐于公历 1888 年 2 月 29 日出生,唐家人有一个习俗:在孩子们出生以后的每年公历生日当天给他们过生日。请问:小唐在公历 1910 年之前过了几次生日? ( )
答案:D
破题点:2月29日只出现在闰年,且 1900 年不是闰年。
1888 年出生,之后 1910 年之前能过生日的年份必须是闰年:1892、1896、1904、1908。1900 年虽能被 4 整除但能被 100 整除且不能被 400 整除,不是闰年(世纪闰年规则)。所以共 4 次。选 D。
下面哪个选项的图形可以实现一笔画出?( )
(本题原卷附四组图形,此处以文字说明:一笔画成立的充要条件是「图形连通且奇点(度数为奇数的顶点)个数为 0 或 2」。请按此法则判断原卷中的四组图形。)
答案:C
破题点:一笔画判定:连通且奇点个数为 0 或 2。
本题原卷附四组图形。一笔画(欧拉回路/路径)的判定法则:图形必须连通,且度数为奇数的顶点(奇点)个数只能是 0 或 2。奇点为 0 时可从任意点出发回到该点(欧拉回路);奇点为 2 时须从一个奇点出发到另一个奇点(欧拉路径)。原卷中只有 C 图满足奇点数为 0 或 2。选 C。
有一位猎人带着一只羊、一头狼和一筐白菜过河。河边有一条小船,但船太小,每次
猎人只能载狼、羊和白菜三者中的一个过河。猎人不在旁边时,狼会吃羊,羊会吃白菜。
请问:猎人把狼、羊、白菜都安全运过河的最少的运法是渡河( )次(过河和返回
各计作一次)。
答案:D
破题点:羊是关键:不能与狼单独留,也不能与白菜单独留。
最少 7 次:①猎人带羊过河;②猎人独自返回;③猎人带狼过河;④猎人带羊返回;⑤猎人带白菜过河;⑥猎人独自返回;⑦猎人带羊过河。共 7 次(过河与返回各计一次)。选 D。
对整型变量N,如果它能够同时被3和5整除,则输出N是含有至少两个质因数。如果用流程图来描述处理过程,则输出语句应该在哪种图形框中( )。
答案:C
输出属于「输入/输出」操作,在流程图中用**平行四边形**表示;矩形表示处理,菱形表示判断,椭圆形表示起止。答案 C。
如果m 和n 为int 类型变量,则执行for (m = 0, n = 1; n < 9; ) n = ((m = 3 * n, m + 1), m - 1); 之后n 的值为偶数。
答案:A
逐轮跟踪:n=1 → m=3、n=2;n=2 → m=6、n=5;n=5 → m=15、n=14;n=14 不满足 n<9 退出。n=14 是偶数。说法正确。答案 A(正确)。
10条直线,最多可以把平面分为多少个区域( )。
答案:B
第 n 条直线最多与已有 n-1 条直线各交于一点,被分成 n 段,从而多出 n 个区域。总数 = 1 + (1+2+…+10) = 1 + 55 = 56。答案 B。
#include <iostream>
using namespace std;
int main(){
int n = 12, cnt = 0;
for(int i = 1; i <= n; i++)
if(n % i == 0) cnt++;
cout << cnt << endl;
return 0;
}程序输出为( )。
这段程序实际在做的事情是( )。
若把第 4 行的 n 改为 7,程序输出为 ______,这说明 7 是质数。
- 第 1 题C 12 的正因数有 1、2、3、4、6、12,共 6 个。程序从 1 试到 12,能整除就让 …
- 第 2 题B cnt 记录的是「能整除 n 的 i 的个数」,即因数个数。若把 cnt++ 改成 sum …
- 第 3 题2 7 只能被 1 和 7 整除,cnt = 2。结论:**因数个数恰为 2 的数是质数**(1…
- 第 1 题A 质数要求恰好两个因数,合数要求至少三个;1 只有 1 个因数,两个都不算。最小质数是 2,最小合数是 4。
- 第 2 题B 2 是唯一的偶质数;其余偶数都能被 2 整除,一定是合数。
- 第 3 题C gcd 要用辗转相除一步步算:299 mod 253 = 46,253 mod 46 = 23,46 mod 23 = 0,答案是 23。
- 第 4 题D `a × b = gcd × lcm` 是数论解题的核心工具,已知其中三个量就能求出第四个。
- 第 5 题A 两数约去最大公约数后,剩下的商不可能再有公因数,所以必然互质,这是“商之和”类题的突破口。
- 第 6 题B 互质只看两数最大公约数是否为 1;gcd(8,9)=1 所以互质,并不要求两数本身都是质数。
- 第 7 题C 欧拉函数数的是 1~n 中与 n 互质的整数个数,n 本身也参与判断;φ(100)=40。
- 第 8 题D 普通年份能被 4 整除即可,但整百年份必须被 400 整除;1900 被 100 整除却不能被 400 整除,所以不是闰年。
- 第 9 题A 这里余数都比除数小 4,属于“差相同”,可写成 n = 504k − 4,比盲目枚举快得多。
- 第 10 题B 一笔画看的是各顶点的度数,而不是边数;奇度顶点的个数决定能否一笔画成。
- 第 11 题C 一笔画要求奇度顶点个数为 0(构成欧拉回路)或 2(欧拉路),其他情况都不行。
- 第 12 题D 这类题把每次渡河都计为 1 次,去与回都算,累加起来才是总次数。
- 第 13 题A 羊不能与狼单独留在一起,也不能与白菜单独留在一起,所以中途必须把羊带回一次,这是解题关键。
- 第 14 题B 被 3 整除看各位数字和能否被 3 整除,被 9 整除看数字和能否被 9 整除;末位法只适用于 2 和 5。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写 100 以内的质数,并说明 1 为什么既不是质数也不是合数。
- 用辗转相除法手算
gcd(253,299)并写出每一步除式,再用a×b = gcd×lcm验证。 - 计算
φ(100),写出 100 的质因数分解和代入公式的全过程。 - 整理闰年判断规则,分别判断 1900 年与 2000 年是否闰年并说明依据。
- 默写一笔画的判别条件(奇度顶点个数为 0 或 2),并动手验证一个具体图形。
- 把“狼、羊、白菜过河”的 7 步完整写出来,标出关键的“把羊带回来”那一步。
- 手算
gcd(253,299)、φ(100)、同余题的完整过程 - 背熟「余数问题三种合并方式」表格 + 闰年规则 + 一笔画条件
- 阶段三总结:C++ 语法 7 天(分支/循环/数组/字符串/函数递归/结构体/数论)覆盖了阅读程序与完善程序的绝大部分素材
- 完成客观题 12 题(
DAY18-01~DAY18-12) - 完成阅读程序小片段 1 组
本日关键记忆:1 不是质数 · 2 是唯一偶质数 · 辗转相除法 ·
a×b = gcd×lcm· 商必互质 · φ(n) = n×Π(1−1/p) · 整百年份须被 400 整除 · 「差同减差」· 一笔画 = 0 或 2 个奇点 · 过河 7 次关键在「把羊带回来」
排列组合与概率
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 27 题 | 填空题 | 3 分 |
| 2022 | 第 29 题 | 填空题 | 3 分 |
| 2022 | 第 30 题 | 填空题 | 3 分 |
| 2023 | 第 29 题 | 填空题 | 3 分 |
| 2023 | 第 30 题 | 填空题 | 3 分 |
| 2024 | 第 27 题 | 填空题 | 3 分 |
| 2024 | 第 29 题 | 填空题 | 3 分 |
| 2024 | 第 30 题 | 填空题 | 3 分 |
| 2025 | 第 29 题 | 单项选择 | 2 分 |
| 2025 | 第 30 题 | 单项选择 | 2 分 |
难易度:较难(★★★★☆) 近 4 年合计:10 题 / 28 分
2026 年备考建议
站在出题人的视角,排列组合是填空和单选的常客:2019 到 2024 年在填空里连考 7 空,2025 年又改成单选连出两题,四年累计 10 题 28 分。命题人爱它是有理由的——题干短、答案是干净的整数无法靠猜,方法一旦选错结果必错,能把“懂方法”和“套公式”的学生精准分开。
所以要练的是“分类清楚、对号入座”:先问顺序有没有影响,有影响用排列 A、没有用组合 C;再按特征挑五种经典方法——相邻用捆绑法、不相邻用插空法、相同物品分给不同人用隔板法、围圆桌用 (n−1)!、“至少”用反面减法。
必背细节刻死:数字题首位不能为 0;插空法 n 个元素形成 n+1 个空;分组给无名字的组要除以组数;隔板法“允许 0 个”是 C(n+m−1,m−1)、“至少 1 个”是 C(n−1,m−1)。
②知识地图 · 本考点思维导图
- 两个基本原理
- 加法原理(分类计数):分类相加
- 乘法原理(分步计数):分步相乘
- 排列与组合公式
- 排列 A(n,m) = n!/(n−m)! ← 有顺序
- 组合 C(n,m) = n!/(m!(n−m)!) ← 无顺序
- 常用阶乘与组合数速查
- 五种经典方法
- 捆绑法(相邻)
- 插空法(不相邻)
- 隔板法(分组/分配)
- 圆桌排列 (n−1)!
- 排除法("至少"类)
- 特殊计数
- 错排(都不在原位)
- 有限制条件的排列
- 简单概率与期望
- 概率 = 符合条件的情况数 / 总情况数
- 常见陷阱
- 0 不能作首位
- 圆桌要除以"旋转"重复
- "至少"要用排除法
③核心精讲
3.1 两个基本原理
| 原理 | 什么时候用 | 怎么算 |
|---|---|---|
| 加法原理 | 完成一件事有几类不同办法(分类,每类都能单独完成) | 各类相加 |
| 乘法原理 | 完成一件事要分几步(分步,每步缺一不可) | 各步相乘 |
判断口诀:「分类用加法,分步用乘法」。
例:从甲地到乙地,有 3 趟火车、2 趟汽车 → 共 3 + 2 = 5 种走法(分类,加法)。 例:从甲到乙有 3 条路,从乙到丙有 2 条路 → 从甲经乙到丙共 3 × 2 = 6 种走法(分步,乘法)。
3.2 排列与组合 ★
| 排列 A(n, m) | 组合 C(n, m) | |
|---|---|---|
| 是否考虑顺序 | ✅ 考虑 | ❌ 不考虑 |
| 典型问法 | 「排成一排」「排队」「上任不同职务」 | 「选出」「选出几个人」「几个人一组」 |
| 公式 | A(n,m) = n!/ (n−m)! | C(n,m) = n! / (m!(n−m)!) |
| 计算捷径 | A(n,m) = n×(n−1)×…×(n−m+1) | 用杨辉三角递推 C(n,m) = C(n−1,m−1) + C(n−1,m) |
★ 阶乘速查(必背)
| n | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|---|
| n! | 1 | 1 | 2 | 6 | 24 | 120 | 720 | 5040 | 40320 | 362880 |
★ 组合数速查表(杨辉三角,务必背熟)
C(0,0)=1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
| 常用组合数 | 值 |
|---|---|
C(5,2) | 10 |
C(6,2) | 15 |
C(6,3) | 20 |
C(7,2) | 21 |
C(8,2) | 28 |
C(10,2) | 45 |
C(10,3) | 120 |
C(16,4) | 1820 |
C(37,4) | 66045 |
C(40,4) | 91390 |
两条常用性质
C(n, m) = C(n, n−m) 从 5 人中选 2 人 = 从 5 人中"留下 2 人"
C(n, 0) = C(n, n) = 1
3.3 ★ 五种经典方法
方法一:捆绑法(要求「相邻」)
思路:把必须相邻的元素捆成一个整体,参与整体排列;再算整体内部的排列。
例:甲乙必须相邻,5 人排一排有多少种?
第 1 步:把甲乙捆成 1 个"大元素" → 与其余 3 人共 4 个元素排列 → 4! = 24
第 2 步:甲乙内部可交换 → 2! = 2
总数 = 24 × 2 = 48
方法二:插空法(要求「不相邻」)★
思路:先排其他元素,形成若干空隙,再把要求不相邻的元素插进空隙。
★ 2023·29 详解:7 人排成一排照相,要求甲、乙、丙三人不相邻,有多少种排法?
第 1 步:先把其余 4 人排好 → 4! = 24 种
第 2 步:4 个人之间有 5 个"空"(含两端):
_人_人_人_人_ ← 5 个空位
第 3 步:从 5 个空中选 3 个放甲、乙、丙(三人有顺序差异)→ A(5,3) = 5×4×3 = 60
总数 = 24 × 60 = 1440
答案:1440
关键:n 个人排好会形成 n + 1 个空(含最左和最右两端)。所以 4 个人 → 5 个空。
如果要求「相间」(必须隔开),就直接用「先排一部分、再插空」,不需要再选位置。
方法三:隔板法(把相同物品分给不同的人)★
思路:把 n 个相同物品分给 m 个不同的人(允许有人分不到),等价于在 n 个物品之间插入 m − 1 块隔板。
公式:方案数 = C(n + m − 1, m − 1)
★ 2025·29 详解:有 12 块巧克力,分给 5 个小朋友(允许有小朋友分不到),有多少种分配方案?
巧克力是"相同物品"(只数个数),5 个小朋友是"不同的人"
公式:C(12 + 5 − 1, 5 − 1) = C(16, 4)
计算:C(16,4) = 16×15×14×13 / (4×3×2×1) = 43680 / 24 = 1820
答案 D(1820)
⚠️ 易错:
- 如果题目要求「每人至少 1 块」,公式变为
C(n − 1, m − 1)(先给每人 1 块,剩下 n−m 块再分);- 如果题目说「分到相同的巧克力」是相同物品 → 用隔板法;如果说「5 块不同的巧克力」→ 用乘法原理
5¹²。
方法四:圆桌排列 ★
n 个人围成一圈,不同的坐法 = (n − 1)!
为什么不是 n!? 因为圆桌没有起点,旋转后相同的坐法要算同一种。固定一个人的位置即可消除旋转重复:n! / n = (n−1)!。
★ 2024·30 详解:6 个人围着一个圆形的桌子坐在一起,有几种坐法?
(6 − 1)! = 5! = 120
答案:120
易错:如果是「圆桌 + 不考虑顺时针逆时针的镜像」(即翻转也算相同,如手链问题),则是
(n−1)! / 2。真题里出现的是普通圆桌,直接用(n−1)!。
方法五:排除法(处理「至少」)★
思路:「至少有一人在内」= 总数 − 一个都不在内。
★ 2024·29 详解:某班级有 40 个同学,从其中任意抽选 4 个人,班长、学习委员、体育委员至少有一人在内的情况有多少种?
总情况数:从 40 人中任选 4 人 → C(40,4) = 91390
反面情况(三人一个都不在内):从其余 37 人中选 4 人 → C(37,4) = 66045
符合条件的情况 = 91390 − 66045 = 25345
答案:25345
「至少」三兄弟的处理方式
问法 处理 至少 1 个 总数 − 0 个 至少 2 个 总数 − 0 个 − 恰 1 个 至多 2 个 恰 0 个 + 恰 1 个 + 恰 2 个 规律:反面越少越好算——「至少」多半用反面减法。
3.4 特殊计数:错排与「至多/至少坐原位」
★ 2022·30 详解:五位同学坐在一排,现让五位同学重新坐,至多有两位同学坐自己原来的位置,有多少种不同的坐法?
第一步:先记住「错排数」(n 个人全部不在原位的排列数)
| n | 2 | 3 | 4 | 5 |
|---|---|---|---|---|
| 错排数 D(n) | 1 | 2 | 9 | 44 |
第二步:分类相加(「至多两位」= 0 位 + 1 位 + 2 位)
恰 0 人坐原位 = D(5) = 44
恰 1 人坐原位 = C(5,1) × D(4) = 5 × 9 = 45
恰 2 人坐原位 = C(5,2) × D(3) = 10 × 2 = 20
合计 = 44 + 45 + 20 = 109
答案:109
★ 破题套路:「恰 k 人坐原位」= 先选出这 k 个人(
C(n,k)),剩下的人全部错排(D(n−k))。 这就是「组合数 × 错排数」的固定搭配。
3.5 含限制条件的排列(含 0 的数字问题)
★ 2022·27 详解:由 0、2、5、8、9 写成的没有重复数字的四位数中,能被 5 整除的最大数和最小数的差是多少?
关键约束:① 千位不能是 0;② 能被 5 整除 → 末位是 0 或 5。
找最大数(千位尽量大)
末位 = 0 → 剩余 2、5、8、9 → 千位取 9、百位 8、十位 5 → 9850
末位 = 5 → 剩余 0、2、8、9 → 千位取 9、百位 8、十位 2 → 9825
最大 = 9850
找最小数(千位尽量小,但不能是 0)
末位 = 5 → 剩余 0、2、8、9 → 千位取 2、百位 0、十位 8 → 2085
末位 = 0 → 剩余 2、5、8、9 → 千位取 2、百位 5、十位 8 → 2580
最小 = 2085
差 = 9850 − 2085 = 7765 答案:7765
★ 破题要点:先固定有硬约束的那一位(末位),再排其余位。 找最值时用「贪心」:最大的数就让高位尽量大,最小的数就让高位尽量小(但千位不能为 0)。
3.6 带「限制位置」的排列
★ 2022·29 详解:安排 7 位工作人员在 10 月 1 日到 10 月 7 日值班,每人值班一天,其中甲、乙二人都不能安排在 10 月 1 日和 2 日,不同的安排方法共有多少种?
第 1 步:给甲、乙安排日期 —— 只能从 3 日~7 日(5 天)中选 2 天并排序
→ A(5,2) = 5 × 4 = 20
第 2 步:其余 5 人安排在剩下的 5 天 → 5! = 120
总数 = 20 × 120 = 2400
答案:2400
另一种思路(排除法):
总排法 − 甲或乙在 1/2 日的排法——但算起来更繁,还是先安排受限制的人更快。
3.7 分组与配对(骰子、球赛)
★ 2023·30 详解:9 名乒乓球运动员(男 5 名、女 4 名),选出 4 人分成两组进行混合双打训练,有多少种不同的分组方法?
混合双打 = 每组 1 男 1 女,共 2 组。
第 1 步:选出 2 名男生 → C(5,2) = 10
第 2 步:选出 2 名女生 → C(4,2) = 6
第 3 步:把选出的 2 男 2 女配成 2 组
(2 名男生分别配对 2 名女生)→ 2! = 2 种配对方式
总数 = 10 × 6 × 2 = 120
答案:120
★ 分组问题的易错点:
情形 处理 分成有名字的两组(如「A 组 vs B 组」) 直接相乘 分成无名字的两组(如「分成两组」不区分组别) 除以 2! 只选出人选、不分组 只用组合数 本题是「2 男 2 女配成 2 对」,配对方式为 2! ——注意题目给的是"分组训练"(要配对)。
★ 2024·27 详解:掷两颗均匀的骰子,第一颗点数大于第二颗点数的情况共有多少种?
配对 (a, b),a 是第 1 颗、b 是第 2 颗,a > b:
a = 2: b = 1 → 1 种
a = 3: b = 1,2 → 2 种
a = 4: b = 1,2,3 → 3 种
a = 5: b = 1,2,3,4 → 4 种
a = 6: b = 1,2,3,4,5 → 5 种
共 1 + 2 + 3 + 4 + 5 = 15 种
答案:15
★ 等价技巧:两颗骰子共 6×6 = 36 种等可能结果,其中「相等」6 种,剩下 30 种中「a>b」与「a<b」各占一半 →
(36 − 6) / 2 = 15。这个"去掉相等再平分"的技巧在骰子、卡片类题目里非常好用!
3.8 简单概率与期望
基本公式
概率 = 符合条件的情况数 ÷ 总情况数
★ 2025·30 详解:有 1~9 九张牌组成从上到下的牌堆,连续从最上方抽牌,直到抽出2 次大于 6 的数,此时抽出牌的张数就是得分。对所有可能的排列,平均得分是多少?
1~9 中大于 6 的数有 3 个(7、8、9)。
思路:要在第 k 次抽牌时恰好出现第 2 个大数(且第 k 次就是大数)。
对称性解法(考场最快):
3 个大数在 9 个位置中随机分布(相当于从 1~9 中随机选 3 个位置)。 「第 2 个大数的位置」记为 X,则 X 的期望为:
3 个位置随机分布时,第 2 个位置的期望 = (第 2 个次序统计量的期望)
= (2 / (3 + 1)) × (9 + 1) = 2/4 × 10 = 5
答案 C(5)
更直观的解释:把 9 个位置分成 4 段——「第 1 个大数前」「第 1、2 个大数间」「第 2、3 个大数间」「第 3 个大数后」。4 段位置数的期望相同,总和为 6(9 个位置中有 3 个是大数),所以每段平均
6 / 4 = 1.5个空位。 第 2 个大数的位置 = 第 1 个大数的位置 + 1 + 中间空位数 而第 1 个大数的位置期望 =(1 / (3+1)) × 10 = 2.5→ 第 2 个大数位置期望 =2.5 + 1 + 1.5 = 5✔考场策略:这类题如果一时想不出公式,就用小规模枚举验证直觉,或直接选居中、最常见的选项(本题 A~D 中 5 最合理)。
3.9 抽屉原理(补充)
原理:把 n + 1 个物体放进 n 个抽屉,至少有一个抽屉里有 ≥ 2 个物体。
推广:把 n 个物体放进 m 个抽屉,至少有一个抽屉里有 ≥ ⌈n / m⌉ 个物体。
例:40 个同学分到 12 个月份,至少有一个月有
⌈40/12⌉ = 4个同学生日。
由 0、2、5、8、9 写成的没有重复数字的四位数中,能被 5 整除的最大数和最小数 的差是( )。
答案:7765
破题点:被 5 整除 → 末位只能是 0 或 5。
被 5 整除的数末位必为 0 或 5。最大:首位取 9,依次 8、5,末位 0 → 9850。最小:首位不能为 0,取 2;要末位为 0 或 5。若末位取 5,则中间两位取 0、8 → 2085;若末位取 0,中间两位取 5、8 → 2580。较小的是 2085。差值 9850 - 2085 = 7765。答案:7765。
安排 7 位工作人员在 10 月 1 日到 10 月 7 日值班,每人值班一天,其中甲、乙二人 都不能安排在 10 月 1 日和 2 日,不同的安排方法共有( )种。
答案:2400
破题点:甲乙只能落在 10月3日~7日这 5 天里。
甲乙二人都不能排在 1 日、2 日,所以两人占 3~7 日中的两天:选位 C(5,2) = 10 种,两人排序 2! = 2 种,共 20 种;其余 5 人占剩下 5 天,5! = 120 种。总计 20 × 120 = 2400。答案:2400。
五位同学坐在一排,现让五位同学重新坐,至多有两位同学坐自己原来的位置,则 不同的坐法有( )种。
答案:109
破题点:用总数减掉「恰有 3 人、5 人在原位」的情况。
5 人全排列共 5! = 120 种。「至少 3 人在原位」的反面情况:恰有 3 人在原位:先选哪 3 人不动的 C(5,3) = 10 种,剩下 2 人必须互换(唯一方式),共 10 种;恰有 4 人在原位不可能(第 5 人只能也在原位);恰有 5 人在原位 1 种。所以符合条件的坐法 = 120 - 10 - 1 = 109。答案:109。
7 人排成一排照相,若要求甲、乙、丙三人不相邻,有( )种不同的排法。
答案:1440
破题点:先排无限制的人,再把受限的人插空。
先排甲乙丙以外的 4 人:4! = 24 种;这 4 人之间及两端共形成 5 个空位;从 5 个空位中选 3 个放甲乙丙并排列:C(5,3) × 3! = 10 × 6 = 60 种。总计 24 × 60 = 1440。答案:1440。
9 名乒乓球运动员, 其中男 5 名,女 4 名,现在要选出4 人分成两组进行混合双打 训练,有( )种不同的分组方法?
答案:120
破题点:混合双打 = 每组一男一女,先把人选出再配对。
两组混合双打需要 2 男 2 女。从 5 男中选 2 人、4 女中选 2 人:C(5,2) × C(4,2) = 10 × 6 = 60 种;把选出的 2 男 2 女分成两对:第 1 位男生可与 2 位女生中的任意一位配对,剩下两人自然成对,共 2 种。总计 60 × 2 = 120。答案:120。
掷两颗均匀的点数为 1 到 6 的两颗骰子,第一颗骰子点数大于第二颗骰子点数的情 况共有( )种。
答案:15
破题点:「第一颗 > 第二颗」与「第一颗 < 第二颗」对称。
两颗骰子共 36 种组合。相等的有 6 种(1-1 到 6-6),剩下 30 种中大于与小于各占一半,即 30 ÷ 2 = 15 种。也可直接数:第二颗为 1 时有 5 种、为 2 时有 4 种……为 5 时有 1 种,5+4+3+2+1 = 15。答案:15。
某班级有 40 个同学,从其中任意抽选 4 个人,班长、学习委员、体育委员至少有一 个人在内的情况有( )种。
答案:25345
破题点:反面思考:一个人都不在内。
从 40 人中抽 4 人的总数为 C(40,4) = 91,390。「三人一个都不在内」即从其余 37 人中抽 4 人:C(37,4) = 66,045。所以至少一人在内的方案 = 91,390 - 66,045 = 25,345。答案:25345。
6 个人围着一个圆形的桌子坐在一起,有( )种坐法。
答案:120
破题点:圆桌排列 = (n-1)!。
圆桌坐法只与相对位置有关,固定一人的位置后其余 5 人任意排列:5! = 120。(一般公式:n 人围圆桌有 (n-1)! 种坐法。若是项链或可翻转的圆桌形状,还需再除以 2。)答案:120。
有 12 块巧克力,要分给 5 个小朋友(允许有小朋友分不到巧克力),有多少种可能
的分配方案( )?
答案:D
破题点:允许有人分不到 → 插板法公式 C(n+k-1, k-1)。
12 块相同的巧克力分给 5 个小朋友、允许为空,属于「可重复组合(隔板法)」:C(12+5-1, 5-1) = C(16,4) = 1820。选 D。
有 1~9 九张牌组成的从上到下的牌堆,我们进行如下游戏:连续从牌堆最上方按顺
序抽牌直到抽出 2 次大于 6 的数,此时抽出牌的张数就是你的得分。对于牌堆所有可能
的排列情况,你的平均得分是多少( )?
答案:C
破题点:得分就是第 2 张「大牌」所在的位置。
大于 6 的牌是 7、8、9 共 3 张。设它们在牌堆中的位置(从上往下)依次为 p1 < p2 < p3,抽到第 2 张大牌时正好抽了 p2 张,所以得分 = p2。3 张大牌在 9 个位置中随机分布,p2 是第 2 次序统计量,其期望为 k(n+1)/(m+1) = 2 × (9+1)/(3+1) = 2 × 10 ÷ 4 = 5。选 C。
有n个同学,从中抽取任意个人数来参加学校组织的大合唱,共有2的n次幂个方法
答案:A
n 个同学中任取若干个(可 0 个、可 n 个)的组合数之和 = 2ⁿ。说法正确。答案 A(正确)。
有ABCD4个人,其中一个是小偷,每个人说一句话,只有小偷说的是假话,其中A说:不是我。B说:是 C。C说:是D。D说:C瞎说,请问谁是小偷( )。
答案:C
逐个假设:若 C 是小偷,则 C 说「是 D」为假 ✓、D 说「C 瞎说」为真 ✓、A 说「不是我」为真 ✓、B 说「是 C」为真 ✓——只有 C 一人说假话,自洽。答案 C。
#include <iostream>
using namespace std;
int main(){
int cnt = 0;
for(int a = 1; a <= 3; a++)
for(int b = 1; b <= 3; b++)
if(a != b) cnt++;
cout << cnt << endl;
return 0;
}程序输出为( )。
这段程序统计的计数问题,用排列组合的记号可以表示为( )。
若把条件 `if(a != b)` 改成 `if(a < b)`,程序输出为 ______。
- 第 1 题B a、b 各有 3 种取值,共 9 种组合;其中 a=b 的有 3 种(1,1)(2,2)(3…
- 第 2 题A a 与 b 要不同,且 (a,b) 与 (b,a) 算两种(有顺序),所以是从 3 个元素中…
- 第 3 题3 a<b 的合法对为 (1,2)(1,3)(2,3),共 3 种,正好是 C(3,2)=3。排…
- 第 1 题A 顺序有影响用 `A`、无影响用 `C`,这是排列与组合的唯一分界线。
- 第 2 题B 数字题首位不能为 0,要先安排首位再排其余位;忘记这条限制会把不合法的排列也算进去。
- 第 3 题C 排好的 n 个元素连同两端共形成 n+1 个空,插入的元素放进这些空里就保证彼此不相邻。
- 第 4 题D 捆绑法把甲乙看成一个人,与其余 3 人共 4 个元素排 4!,别忘再乘甲乙的内部排列 2!。
- 第 5 题A 圆桌排列因为可以整体旋转,要用 `(n−1)!`,6 个人就是 5! = 120。
- 第 6 题B 组没有名字时,同一分法的 k! 种排列其实是同一种,所以必须除以 k!;有名字的组则不用除。
- 第 7 题C 遇到“至少”优先用反面减法,总数减去“一个都没有”(从其余 37 人里选 4 人),比分类相加快得多。
- 第 8 题D 先从 5 人中选出坐原位的 2 人,剩下 3 人必须全部错排,即 `C(n,k) × D(n−k)`。
- 第 9 题A 隔板法只适用于“相同物品”分给“不同的人”,物品不同就不能用隔板法。
- 第 10 题B “允许 0 个”要把 m 个位置先各补 1 个,公式是 `C(n+m−1,m−1)`;“至少 1 个”才是 `C(n−1,m−1)`,两者极易混。
- 第 11 题C 36 种结果里减去 6 种相等的,剩下 30 种里大小关系各占一半,所以是 15 种。
- 第 12 题D 期望题很多有对称性,可直接得出各位置概率相等;拿不准时就缩小规模枚举找规律。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写排列数
A(n,m)与组合数C(n,m)的公式,各算一组数验证。 - 整理捆绑法、插空法、隔板法、圆桌排列、排除法五种方法各自的适用条件与对应公式。
- 默写隔板法“允许 0 个”与“至少 1 个”两套公式,并用 12 块糖分给 5 人各算一遍。
- 由
D(3)=2、D(4)=9、D(5)=44出发算“5 人至多 2 人坐原位”的总数,写出分类过程。 - 掷两颗骰子,统计第一颗大于第二颗的情况有几种,说明为什么要减去相等的 6 种。
- 把 41 个同学分到 12 个月份,用抽屉原理算出至少有一个月至少有几名同学的生日。
- 背熟「五种经典方法」各自的适用场景(相邻/不相邻/分组/圆桌/至少)
- 手算 §3.5 的数字题(找最大最小数)与 §3.4 的错排题
- 记住阶乘表 5! = 120、6! = 720、7! = 5040,以及
C(16,4) = 1820 - 完成客观题 12 题(
DAY19-01~DAY19-12) - 完成阅读程序小片段 1 组
本日关键记忆:分类用加法 / 分步用乘法 · 有顺序用
A/ 无顺序用C· 相邻捆绑 / 不相邻插空(n+1 个空)· 圆桌(n−1)!· 隔板法C(n+m−1, m−1)· 「至少」用反面减法 · 恰 k 人在原位 =C(n,k)×D(n−k)· 0 不能作首位 · 骰子题「去相等再平分」
算法专题:排序·查找·枚举模拟·贪心递推·数据结构
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2022 | 第 41 题 | 完善程序 | 2 分 |
| 2022 | 第 42 题 | 完善程序 | 2 分 |
| 2022 | 第 43 题 | 完善程序 | 2 分 |
| 2022 | 第 44 题 | 完善程序 | 2 分 |
| 2022 | 第 45 题 | 完善程序 | 2 分 |
| 2023 | 第 41 题 | 完善程序 | 2 分 |
| 2023 | 第 42 题 | 完善程序 | 2 分 |
| 2023 | 第 43 题 | 完善程序 | 2 分 |
| 2023 | 第 44 题 | 完善程序 | 2 分 |
| 2023 | 第 45 题 | 完善程序 | 2 分 |
| 2024 | 第 31 题 | 阅读程序 | 3 分 |
| 2024 | 第 32 题 | 阅读程序 | 3 分 |
| 2024 | 第 33 题 | 阅读程序 | 3 分 |
| 2025 | 第 5 题 | 单项选择 | 2 分 |
| 2025 | 第 25 题 | 单项选择 | 2 分 |
| 2025 | 第 31 题 | 阅读程序 | 3 分 |
| 2025 | 第 32 题 | 阅读程序 | 3 分 |
| 2025 | 第 33 题 | 阅读程序 | 3 分 |
难易度:较难(★★★★☆) 近 4 年合计:18 题 / 42 分
2026 年备考建议
站在出题人的视角,排序、查找、枚举模拟、贪心递推和线性表是阅读程序与完善程序共同的素材库:四年里完善程序 10 空、阅读程序 3 空,还有单选 3 题、填空 3 空,几乎每道大题都能从这里取材。原因是这些算法结构清晰、代码不长,却各埋着几个必须清楚的概念,正好用来分辨“真懂”和“背结论”。
所以先要把概念过硬,再谈读程序:五种排序的平均、最坏复杂度和稳定性要脱口而出,快排最坏是 O(n²);sort(a, a+n) 是左闭右开区间,参数必须是指针或迭代器;二分要求序列有序、复杂度 O(log n);栈是 LIFO、队列是 FIFO,分别对应括号匹配和 BFS。
易栽的地方点名:冒泡的交换次数等于逆序对个数;选择排序是“先找最小再交换”;二叉树“先中后”说的是根的位置;模拟题别漏掉循环的第二重条件;贪心只在满足贪心选择性质时才最优。
②知识地图 · 本考点思维导图
- 排序
- 五种排序:冒泡 · 选择 · 插入 · 快速 · 桶
- 交换次数 / 比较次数统计
- 稳定性
- 标准库 sort + cmp
- 查找
- 顺序查找 O(n)
- 二分查找 O(log n)(要求有序)
- 二分答案("最小化最大值" / "最大化最小值")
- 枚举与模拟
- 枚举:逐个试所有可能
- 模拟:照着题意一步步执行
- 贪心
- 每步都选当前最优
- 递推
- 由已知推未知,f[i] 由 f[i-1]、f[i-2] 推
- 数据结构(线性表)
- 栈:后进先出 LIFO
- 队列:先进先出 FIFO
- 二叉树:先序/中序/后序遍历
- 图:深度优先搜索 DFS
- 时间复杂度
- O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)
③核心精讲
3.1 五种排序算法对比 ★
| 算法 | 思想 | 平均时间复杂度 | 最坏 | 稳定 | 适用 |
|---|---|---|---|---|---|
| 冒泡排序 | 相邻两两比较,反序就交换 | O(n²) | O(n²) | ✅ | 教学、小数据 |
| 选择排序 | 每轮选出最小的放到前面 | O(n²) | O(n²) | ❌ | 交换次数少 |
| 插入排序 | 把新元素插入已排好的部分 | O(n²) | O(n²) | ✅ | 数据基本有序时快 |
| 快速排序 | 选基准,分成两半递归 | O(n log n) | O(n²) | ❌ | 通用最快 |
| 桶排序(计数) | 按下标直接放 | O(n + k) | — | ✅ | 数据范围小 |
★ 冒泡排序(代码)
for (int i = 0; i < n - 1; i++) // 共 n−1 轮
for (int j = 0; j < n - 1 - i; j++) // 每轮比较 n−1−i 次
if (a[j] > a[j + 1]) // 升序:前面大就交换
swap(a[j], a[j + 1]);
★ 交换次数怎么数(高频考点):逐轮模拟,数出每一次交换
例:对
[3, 1, 2]从小到大冒泡第 1 轮:比较 (3,1) → 3>1,交换 → [1,3,2] ← 第 1 次交换 比较 (3,2) → 3>2,交换 → [1,2,3] ← 第 2 次交换 第 2 轮:比较 (1,2) → 不用交换 结束 共交换 2 次另一个重要结论:冒泡排序的交换次数 = 数组的「逆序对个数」。 例如
[3,1,2]的逆序对是 (3,1)、(3,2) 共 2 个,正好等于交换次数。 考试时用「数逆序对」往往比逐轮模拟更快。
★ 选择排序:交换次数最少
for (int i = 0; i < n - 1; i++) {
int k = i;
for (int j = i + 1; j < n; j++)
if (a[j] < a[k]) k = j; // 找最小值的下标
if (k != i) swap(a[i], a[k]); // 再交换
}
特点:比较次数固定为
n(n−1)/2,但交换次数最多 n−1 次(比冒泡少很多)。
★ 快速排序(思路)
① 选一个「基准」(通常取中间或第一个元素)
② 把小于基准的放左边、大于的放右边(分区)
③ 对左右两部分分别递归
平均 O(n log n),是最常用的高效排序
★ 桶排序(适合小范围整数)
int cnt[1005] = {0};
for (int i = 0; i < n; i++) cnt[a[i]]++; // 统计个数
for (int v = 1; v <= 1000; v++) // 按值从小到大输出
for (int c = 0; c < cnt[v]; c++) cout << v << " ";
时间复杂度 O(n + 值域),不是比较排序,因此可以突破 O(n log n) 下限。
3.2 ★ 标准库 sort 的用法
#include <algorithm>
int a[5] = {3, 1, 4, 2, 5};
sort(a, a + 5); // 升序:区间 [a, a+5),即 a[0] ~ a[4]
sort(a, a + 5, greater<int>()); // 降序
★ 三个必须记住的要点
| 要点 | 说明 |
|---|---|
| ① 区间是左闭右开 | sort(a, a + n) 排的是 a[0] ~ a[n-1] |
② 对 vector 用迭代器 | sort(v.begin(), v.end()); |
③ 自定义规则用 cmp | sort(a, a + n, cmp); |
★ 2025·25 的考法:判断 sort 的各种写法是否正确。
| 写法 | 是否正确 | 原因 |
|---|---|---|
sort(a[0], a[n]) | ❌ | 传的是元素值而不是地址;应为 sort(a, a+n) |
sort(a, a + n); | ✅ | 标准写法 |
sort(a + 1, a + n + 1); | ✅ | 排 a[1] ~ a[n],也合法 |
sort(a, a + n, cmp); | ✅ | 自定义比较 |
sort(v.begin(), v.end()); | ✅ | vector 写法 |
记忆:
sort(first, last)的两个参数是指针/迭代器,不是元素本身。
3.3 查找
① 顺序查找(数据无序时唯一选择)
for (int i = 0; i < n; i++)
if (a[i] == x) { cout << i; break; }
// 时间复杂度 O(n)
② 二分查找(必须有序)
int l = 0, r = n - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (a[mid] == x) { /* 找到了 */ break; }
else if (a[mid] < x) l = mid + 1; // 目标在右半
else r = mid - 1; // 目标在左半
}
// 时间复杂度 O(log n),每次砍掉一半
★ 二分查找的前提:序列必须已经有序。这是最常考的判断题。
★ ③ 二分答案(2023、2025 完善程序连考) 高频模型!
适用场景(看到这些词就用二分答案)
「使……的最大值最小」 「使……的最小值最大」
「最少需要多少」 「最大能到多少」
★ 模板
int l = 下界, r = 上界, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) { // mid 可行吗?
ans = mid; // 记录可行答案
r = mid - 1; // 想找"最小可行"就收紧右边界
} else {
l = mid + 1; // 不行就放大
}
}
cout << ans;
核心在于 check(mid) 怎么写——通常是「贪心地按 mid 去划分 / 去数一数,能否满足要求」。
★ 2025·41–45 题意:把长度为 N 的正整数数列分成 M 段,使各段和的最大值最小。
check(mid):判断「能否用不超过 M 段,使每段和都 ≤ mid」——贪心:从左往右累加,超过 mid 就断开,数出用了几段。- 段数 ≤ M → mid 可行(还能更小)→
r = mid − 1- 段数 > M → mid 太小 →
l = mid + 1
★ 2023·41–45 题意:
n×m乘法表(f[i][j] = i×j)中第 k 小的数。
check(mid):数出「乘法表中小于等于 mid 的数有几个」——对每一行 i,有min(m, mid / i)个。- 个数 ≥ k → mid 够大 → 记录并收紧上界。
3.4 枚举与模拟
枚举:把所有可能的情况逐个试一遍。
// 求 1~100 中能被 7 整除的数
for (int i = 1; i <= 100; i++)
if (i % 7 == 0) cout << i << " ";
枚举的优化方向(复赛重点)
| 原始做法 | 优化后 |
|---|---|
| 二重枚举 O(n²) | 哈希/双指针 O(n) |
| 枚举所有子集 O(2ⁿ) | 剪枝、动态规划 |
★ 模拟:照着题意一步步执行(阅读程序的主要考法)
★ 2024·31–33 详解:程序如下
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
for (int i = 1; i <= k && x != y; ++i) {
if (x > y) x -= y;
else y -= x;
}
printf("%d %d\n", x, y);
含义:每次把大的那个减去小的,最多做 k 次,直到两数相等。
| 输入 | 逐次模拟 | 输出 |
|---|---|---|
12 15 4 | (12,15)→(12,3)→(9,3)→(6,3)→(3,3) 相等,停止 | 3 3 |
10 1000 90 | (10,1000)→(10,990)→…(每次减 10,共 99 次)但 k=90 只允许 90 次 | 10 100 |
2431 65 100 | 反复相减……100 次后 | 13 13 |
★ 模拟题的三步法: ① 看清循环条件(这里是
i <= k && x != y——两个条件同时满足才继续,任何一个不满足就停); ② 列表逐次推演,每一次都写下来; ③ 注意"提前终止":x == y或超出 k 次都会提前结束。第二个输入是陷阱:如果不注意 k = 90 的限制,会误以为一直减到相等(那需要 99 次),从而算错。
3.5 贪心算法
思想:每一步都选当前看起来最好的,不回头。
两个经典例子
| 问题 | 贪心策略 |
|---|---|
| 找零钱(面额 1、5、10) | 每次都尽量用大面额 |
| 活动安排(选尽可能多的不冲突活动) | 每次选结束时间最早的 |
贪心的两个前提
① 贪心选择性质:局部最优能推出全局最优
② 最优子结构
⚠️ 贪心不是万能的!例如「面额 1、3、4 元,凑 6 元最少几张」:贪心选 4+1+1 = 3 张,而最优是 3+3 = 2 张。贪心失败。 初赛层面只需掌握思路与判别,不要陷入证明。
3.6 递推
思想:由已知的初始值,按照递推式一步步推出后面的值。
★ 2023·25 详解:F(n) = F(n−1) + 3,F(1) = 2,求 F(5)
F(1) = 2
F(2) = F(1) + 3 = 5
F(3) = F(2) + 3 = 8
F(4) = F(3) + 3 = 11
F(5) = F(4) + 3 = 14
答案:14
这其实是等差数列:
F(n) = 2 + 3(n−1)→F(5) = 2 + 12 = 14。 递推题的好习惯:先算前几项,看看像不像等差/等比/斐波那契,能直接套公式更快。
经典递推模型
| 递推式 | 数列 | 名称 |
|---|---|---|
f(n) = f(n−1) + f(n−2),f(1)=f(2)=1 | 1,1,2,3,5,8,13… | 斐波那契 |
f(n) = f(n−1) + d | 等差数列 | 线性递推 |
f(n) = f(n−1) × q | 等比数列 | — |
f(n) = n × f(n−1) | 阶乘 | — |
★ 递推 vs 递归
| 递推(迭代) | 递归 | |
|---|---|---|
| 实现 | 循环,从小到大算 | 函数自己调自己,从大到小拆 |
| 效率 | 高,无重复计算 | 有重复计算和调用开销 |
| 风险 | 无 | 层数太深会栈溢出 |
做题建议:能递推就递推(写循环),递归用来理解问题的结构。
3.7 数据结构(线性表)★
① 栈(Stack):后进先出 LIFO
┌─────┐
│ D │ ← 栈顶(最后进,最先出)
├─────┤
│ C │
├─────┤
│ B │
├─────┤
│ A │ ← 栈底
└─────┘
| 操作 | 含义 |
|---|---|
push(x) | 入栈(压栈),放到顶部 |
pop() | 出栈,弹出顶部元素 |
top() | 查看栈顶(不出栈) |
empty() | 判断是否为空 |
典型应用:括号匹配、表达式求值、撤销操作、函数调用栈、进制转换。
// 用数组模拟栈
int st[1005], top = 0;
st[++top] = x; // push
int y = st[top--]; // pop
if (top == 0) /* 空栈 */;
② 队列(Queue):先进先出 FIFO
出队 ← [ A ][ B ][ C ][ D ] ← 入队
队首 队尾
| 操作 | 含义 |
|---|---|
push(x) | 入队,放到尾部 |
pop() | 出队,弹出队首 |
front() | 查看队首 |
back() | 查看队尾 |
典型应用:排队模拟、广度优先搜索 BFS、缓冲区。
// 用数组模拟队列
int q[1005], head = 1, tail = 0;
q[++tail] = x; // 入队
int y = q[head++]; // 出队
③ 二叉树遍历
1
/ \
2 3
/ \
4 5
| 遍历方式 | 顺序 | 本例结果 |
|---|---|---|
| 先序(根左右) | 根 → 左子树 → 右子树 | 1 2 4 5 3 |
| 中序(左根右) | 左子树 → 根 → 右子树 | 4 2 5 1 3 |
| 后序(左右根) | 左子树 → 右子树 → 根 | 4 5 2 3 1 |
| 层序(BFS) | 一层一层从左往右 | 1 2 3 4 5 |
记忆:「先中后」指的是「根」的位置——先序根在前、中序根在中、后序根在后。
④ 图的深度优先搜索(DFS)
思想:一条路走到黑,走不通就退回上一步换条路
bool vis[N];
void dfs(int u) {
vis[u] = true;
for (每个与 u 相邻的 v)
if (!vis[v]) dfs(v);
}
复习:大纲复赛范围列了「深度优先搜索」,所以 DFS 是必须掌握的内容。与之对应的 BFS(广度优先,用队列实现)也要了解。
3.8 时间复杂度速记
| 复杂度 | 名称 | 典型算法 |
|---|---|---|
O(1) | 常数 | 数组按位访问、一次运算 |
O(log n) | 对数 | 二分查找、二分答案 |
O(n) | 线性 | 一重循环、顺序查找、桶排序 |
O(n log n) | 线性对数 | 快速排序、归并排序、sort |
O(n²) | 平方 | 冒泡、选择、插入排序、双重循环 |
O(n³) | 立方 | 三重循环 |
O(2ⁿ) | 指数 | 枚举子集 |
O(n!) | 阶乘 | 全排列枚举 |
规模对照(竞赛经验)
| n | 可行复杂度 |
|---|---|
| ≤ 20 | O(2ⁿ)、O(n!) |
| ≤ 100 | O(n³) |
| ≤ 10⁴ | O(n²) |
| ≤ 10⁶ | O(n log n) |
| ≤ 10⁸ | O(n) |
阅读程序中的常见问法:「该程序的时间复杂度是多少?」——数循环嵌套层数最直接:
- 一重循环 →
O(n)- 二重循环 →
O(n²)- 每次砍半的循环(
i *= 2、r = mid − 1)→O(log n)
对序列 [5, 2, 4, 1] 进行冒泡排序(从小到大),完成排序过程中共发生( )
次元素交换。
答案:B
破题点:逐趟模拟相邻比较交换。
[5,2,4,1] 冒泡(从小到大):第 1 趟 5 与 2 交换→[2,5,4,1],5 与 4 交换→[2,4,5,1],5 与 1 交换→[2,4,1,5](3 次);第 2 趟 4 与 1 交换→[2,1,4,5](1 次);第 3 趟 2 与 1 交换→[1,2,4,5](1 次)。合计 5 次。选 B。
对于 sort 的使用,以下哪些是正确的( )?
①sort(a[0],a[n])
②sort(a,a+n)
③sort(&a[0],&a[n])
④sort(arr.begin(a),arr.end(a))
答案:C
破题点:sort 的区间是「左闭右开」的指针/迭代器。
② sort(a, a+n) 正确:对 a[0] 到 a[n-1] 排序;③ sort(&a[0], &a[n]) 与 ② 等价,也正确。① sort(a[0], a[n]) 传的是元素的值而不是地址,错误;④ sort(arr.begin(a), arr.end(a)) 括号里不该带参数(应为 arr.begin()、arr.end()),错误。选 C。
排序算法是稳定的(Stable Sorting),就是指排序算法可以保证,在待排序数据中有两个相等记录的关键字R 和S(R 出现在S 之前),在排序后的列表中R 也一定在S 前。下面关于排序稳定性的描述,正确的是( )。
答案:C
稳定性指相等元素排序后相对次序不变。冒泡、插入、归并稳定;选择排序、快速排序、堆排序不稳定。答案 C。
冒泡排序和插入排序都是稳定的排序算法。
答案:A
冒泡排序只在严格逆序时才交换,相等元素不会互换;插入排序同理。两者都稳定。说法正确。答案 A(正确)。
对包含n 个元素的数组进行冒泡排序,平均时间复杂度一般为( )。
答案:C
冒泡排序有两层循环,比较次数约 n²/2,平均与最坏时间复杂度都是 O(n²)。答案 C。
用递归法求n的阶乘,时间复杂度是O(n)。
答案:A
递归求 n! 需要从 n 一路递归到 1,共 n 层调用,每层 O(1) 工作,时间复杂度 O(n)。说法正确。答案 A(正确)。
用枚举法解决 “鸡兔同笼问题:头共 35 个,脚共 94 只,求鸡和兔的数量”,以下枚举逻辑最合理的是:()
答案:A
鸡兔同笼最合理的枚举是:只枚举一个量(鸡 x,0~35),另一个量由头数直接算出(兔 = 35-x),再验脚数,枚举规模最小。答案 A。
枚举可以在保证不漏解的前提下缩小枚举范围,不是必须遍历全部。
答案:A
枚举的关键是「不重不漏」;能通过上下界、数学条件缩小范围就应缩小,不必遍历全部。说法正确。答案 A(正确)。
工人工作一天,会得到一个金环作为工资报酬,某个工作需要15天完成,一条15个环的金环项链,为了严格执行每天工作结束时,完成对工人工资的结算,最少需要将金环项链剪裁成几段,每段几个金环( )
答案:A
每天要支付 1 个环的增量,把 15 个环剪成 1、2、4、8 四段,用二进制组合就能表示 1~15 的任意天数(找零),所以最少剪成 4 段。答案 A。
递推是一种通过已知的初始值和递推公式,逐步求解目标值的算法。
答案:A
递推 = 初始值 + 递推公式 → 逐步求目标值,说法正确。答案 A(正确)。
递推是在给定初始条件下,已知前一项(或前几项)求后一项的过程。
答案:A
递推就是在已知前一项(或前几项)与递推关系的前提下求后一项,说法正确。答案 A(正确)。
关于几种排序算法的说法,下面说法错误的是( )。
答案:B
冒泡排序**是**稳定的排序算法,所以「冒泡不是稳定排序」这个说法错误。答案 B。
下面关于排序算法(冒泡排序、插入排序和选择排序)的描述中,不正确的是( )。
答案:C
冒泡排序在「已基本有序」时只需一趟便可确定无需交换,最好情况时间复杂度是 O(n)(加标志位优化后),并非任何情况都是 O(n²)。答案 C。
选择排序是稳定的排序算法。
答案:B
选择排序每轮把最小元素换到前面,交换会破坏相等元素的原有次序,所以**不稳定**。说法错误。答案 B(错误)。
#include<bits/stdc++.h>
using namespace std;
int main()
{
int x,y,k;
scanf("%d%d%d",&x,&y,&k);
for(int i = 1; i <= k && x != y; ++i) {
if(x > y) x -= y;
else y -= x;
}
printf("%d %d\n",x,y);
return 0;
}输入数据:12 15 4
输出数据:( )
输入数据:10 1000 90
输出数据:( )
输入数据:2431 65 100
输出数据:( )
- 第 1 空3 3 逐轮模拟减法:只要 x≠y 且轮数 <k 就继续;写出每一轮 x、y 的两个值。
- 第 2 空10 100 逐轮模拟减法:只要 x≠y 且轮数 <k 就继续;写出每一轮 x、y 的两个值。
- 第 3 空13 13 逐轮模拟减法:只要 x≠y 且轮数 <k 就继续;写出每一轮 x、y 的两个值。
给定一个长度为 n 且从小到大排好序的序列{a1,a2,a3,...,an},要把这个序列分成 k 段,每段的价值为该段中的最大值减去最小值,现在请你帮忙分段,使得各分段的价值 之和最小(保证计算结果都在 int 范围内)。
#include <bits/stdc++.h>
using namespace std;
const int N=3e5+5;
int n,k,sum,a[N],b[N];
int main()
{
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<n;i++) b[i]= ① ;
if( ② )
printf("0\n");
else if(k==1)
③
else
{
sort(b+1,b+n);
sum=0;
for(int i=1;i<= ④ ;i++)
⑤
printf("%d\n",sum);
}
return 0;
}第①空应填写?( )
第②空应填写?( )
第③空应填写?( )
第④空应填写?( )
第⑤空应填写?( )
- 第 1 空B b[i] 存的是相邻两个元素的差。
- 第 2 空C n==k 时每段只有一个数,代价必为 0。
- 第 3 空B k==1 时整串就是一段,代价为 a[n]-a[1]。
- 第 4 空A 等价于「总跨度减去 k-1 个最大间隔」= 取最小的 n-k 个差。
- 第 5 空D 累加选中间隔。
#include<bits/stdc++.h>
using namespace std;
int main() {
int n,m=3,s=0;
scanf("%d",&n);
for (int i=2;i<=n; i++)
s=(s+m)%i;
printf("%d\n",s+1);
return 0;
}输入 3, 请选出正确输出( )
输入 4, 请选出正确输出( )
输入 20, 请选出正确输出( )
- 第 1 空C 递推式只依赖上一轮的 s,逐轮算余数即可。
- 第 2 空A 递推式只依赖上一轮的 s,逐轮算余数即可。
- 第 3 空D 递推式只依赖上一轮的 s,逐轮算余数即可。
给出 n,m,k(1 ≤ n,m ≤ 5×105,1 ≤ k ≤ n×m),请输出在 n*m 的乘法表中第 k 小的数。即给出一个f[i][j]=i*j(1≤i≤n,1≤j≤m)的数组,输出该数组内所有数(包含重复的)从小到大排序后第 k 大的数。 样例输入:5 5 10 样例输出:5 样例解释:此样例对应的乘法表如下:
#include<bits/stdc++.h>
using namespace std;
long long n, m, k;
bool check(long long x) {
long long sum = 0;
for(int i=1;i<=n;i++) {
sum += _____①_____;
}
return ____②___;
}
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
long long temp = ____③____;
long long L=1, R=temp;
while(L < R) {
long long mid = ____④____;
if(check(mid)) R = mid;
else L = ____⑤____;
}
printf("%lld", L);
}第①空应填写?( )
第②空应填写?( )
第③空应填写?( )
第④空应填写?( )
第⑤空应填写?( )
- 第 1 空B 第 i 行中 ≤x 的数个数是 min(m, ⌊x/i⌋)。
- 第 2 空D 统计值 ≥k 说明 x 已经足够大。
- 第 3 空D 第 k 小的数不可能超过 n×m。
- 第 4 空A 左闭右开的二分取中点。
- 第 5 空C check 为假说明 mid 太小,左边界跳到 mid+1。
- 第 1 题A 二分靠“比较中点后砍掉一半”,只有有序序列才能保证砍对方向;无序数组上二分结果错误。
- 第 2 题B 每一对逆序的元素恰好会被交换一次,所以交换次数正好等于逆序对个数。
- 第 3 题C 选择排序每轮找出最小值再与目标位置交换一次,冒泡则是相邻元素反复交换,交换次数通常更多。
- 第 4 题D `sort` 的参数要传指针或迭代器,正确写法是 `sort(a, a+n)`;传数组元素本身不合法。
- 第 5 题A `sort` 的区间是左闭右开 `[a, a+n)`,右端点不参与排序,所以实际处理 a[0]~a[n-1]。
- 第 6 题B 快排平均 `O(n log n)`,但当基准选得极差(每次取到最大或最小)时退化为 `O(n²)`。
- 第 7 题C 栈后进先出,用于括号匹配、函数调用;队列先进先出,用于排队模拟、BFS。
- 第 8 题D “先中后”说的都是根在哪一步被访问:先序根在前,中序根在中间,后序根在最后。
- 第 9 题A `&&` 连接的两个条件必须同时成立循环才继续,任一不满足就退出,模拟题常靠这个第二条件控制终止。
- 第 10 题B 先算 `F(1)`、`F(2)`、`F(3)` 观察规律,若是等差或等比就能套通项公式,避免大量计算。
- 第 11 题C 贪心不是万能的最优解,只在具备贪心选择性质(局部最优能推出全局最优)时才成立。
- 第 12 题D 复杂度由循环嵌套层数决定,同时要看循环变量是线性变化还是折半变化,后者往往是 `O(log n)`。
- 第 13 题A `check` 若写成暴力,整体复杂度会爆炸;正确做法是用贪心或线性扫描在 `O(n)` 内判断某个答案是否可行。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写冒泡、选择、插入、快速、桶排序的平均与最坏时间复杂度,并标出哪些是稳定排序。
- 默写
sort(a, a + n)的正确调用形式,说明它排的是哪些元素以及左闭右开区间的含义。 - 写出二分查找的完整代码模板,说明它的前提条件和时间复杂度。
- 列表对比栈与队列(LIFO / FIFO)的区别,各写出一个典型应用场景。
- 写出二叉树先序、中序、后序三种遍历的顺序,并说明“先中后”指的是什么的位置。
- 由
F(1)=2、F(n)=F(n−1)+3算出F(5),并写出斐波那契数列的前 8 项。 - 手写冒泡排序,并对
[3,1,2]数出交换次数(再用逆序对验证) - 背熟 §3.8 时间复杂度表与规模对照表
- 手算 §3.4 三道模拟题(尤其注意
k限制) - 完成客观题 14 题(
DAY20-01~DAY20-14) - 完成阅读程序小片段 1 组
本日关键记忆:冒泡交换次数 = 逆序对 · 选择排序交换最少 · 快排平均 O(n log n) / 最坏 O(n²) ·
sort(a, a+n)左闭右开 · 二分必须有序 · 「最大最小」类用二分答案 · 栈 LIFO / 队列 FIFO · 先中后指根的位置 · 递推先算前几项找规律
阅读程序 & 完善程序专项 + 全真模拟
①今日考情 · 近 4 年初赛考察
近 4 年初赛考察
| 年份 | 题号 | 题型 | 分值 |
|---|---|---|---|
| 2023 | 第 34 题 | 阅读程序 | 3 分 |
| 2023 | 第 35 题 | 阅读程序 | 3 分 |
| 2023 | 第 36 题 | 阅读程序 | 3 分 |
| 2023 | 第 37 题 | 阅读程序 | 3 分 |
| 2024 | 第 38 题 | 阅读程序 | 3 分 |
| 2024 | 第 39 题 | 阅读程序 | 3 分 |
| 2024 | 第 40 题 | 阅读程序 | 3 分 |
| 2025 | 第 37 题 | 阅读程序 | 3 分 |
| 2025 | 第 38 题 | 阅读程序 | 3 分 |
| 2025 | 第 39 题 | 阅读程序 | 3 分 |
| 2025 | 第 40 题 | 阅读程序 | 3 分 |
| 2025 | 第 41 题 | 完善程序 | 2 分 |
| 2025 | 第 42 题 | 完善程序 | 2 分 |
| 2025 | 第 43 题 | 完善程序 | 2 分 |
| 2025 | 第 44 题 | 完善程序 | 2 分 |
| 2025 | 第 45 题 | 完善程序 | 2 分 |
难易度:难(★★★★★) 近 4 年合计:16 题 / 43 分
2026 年备考建议
站在出题人的视角,阅读程序加完善程序这 40 分,是四年里唯一没动过的部分——2025 年卷面改版,单选和填空都有调整,这两道大题的类型、题量和分值纹丝不动。原因也简单:阅读程序 10 空每空 3 分、完善程序 5 空每空 2 分,单空分值高于单选,而“看得懂”和“看不懂”之间的差距没法用运气补上,是全卷区分度最高的 40 分。
所以复习要顺着得分结构走:时间优先投给性价比最高的阅读程序,一空卡住就先跳,先把有把握的分数锁住。方法上固化两套流程——阅读程序用“五步法”(读题头、扫变量、找骨架、列表追值、代输入),完善程序抓牢“问题描述 + 已写好的代码 + 样例验证”这三件套。
两个陷阱再点一遍:数组是 1-based 还是 0-based,看 ++t 还是 t++;输出语句里的 +1 不能省,约瑟夫环算出来的是 0-based 编号,题目要 1-based 就必须加 1。
②知识地图 · 本考点思维导图
- 阅读程序(30 分 / 10 空)
- 解题五步法
- 常见程序模型(8 类)
- 2025 新题型:选择题形式
- 完善程序(10 分 / 5 空)
- 解题四步法
- 五类常见空位
- 代入验证法
- 综合策略
- 时间分配
- 得分优先级
- 全真模拟与错题复盘
③核心精讲
3.1 阅读程序题:解题五步法 ★★
第 1 步:读题头 —— 看清"输入是什么、输出是什么"
(题面通常直接写了"输入数据:… 输出数据:___")
第 2 步:扫变量 —— 有哪些变量?哪些数组?分别干什么用?
(变量名往往暗示用途:sum→累加、cnt→计数、ans→答案、mx→最大值)
第 3 步:找骨架 —— 主函数里的大循环在哪?循环几次?
(这是程序"最重要的一段路")
第 4 步:列表追值 —— 每执行一轮,把关键变量的值写进表格
★ 这是得分的关键:不许心算、不许跳步
第 5 步:代输入 —— 把题目给的输入代进去,读表格最后一行
★ 第 4 步「列表追值」示范
题目:输入
3,输出什么?
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m = 3, s = 0;
scanf("%d", &n);
for (int i = 2; i <= n; i++)
s = (s + m) % i;
printf("%d\n", s + 1);
return 0;
}
列一张表(n = 3)
| i | 判断 i <= n | (s + m) % i | s 的值 |
|---|---|---|---|
| — | 初始 | — | 0 |
| 2 | 2 ≤ 3 ✔ | (0 + 3) % 2 = 1 | 1 |
| 3 | 3 ≤ 3 ✔ | (1 + 3) % 3 = 1 | 1 |
| 4 | 4 ≤ 3 ✘ | 循环结束 | — |
最后 printf("%d\n", s + 1) → 输出 1 + 1 = 2
对照选项(2025·31):A. 0 B. 1 C. 2 D. 3 → 答案 C ✔
再看两个输入
| 输入 | s 的变化过程 | s 终值 | 输出 s+1 |
|---|---|---|---|
| 4 | i=2→1;i=3→(1+3)%3=1;i=4→(1+3)%4=0 | 0 | 1 |
| 20 | 逐项推演到底 | 19 | 20 |
这道题其实就是约瑟夫环(m = 3),所以「输入 20 输出 20」这个结果也符合约瑟夫环的规律。
3.2 ★ 八类常见程序模型(覆盖 90% 的阅读程序)
| 模型 | 特征 | 典型代码 |
|---|---|---|
| ① 累加/累乘 | sum += a[i]、ans *= i | 求和、阶乘 |
| ② 计数 | if (条件) cnt++; | 统计满足条件个数 |
| ③ 最值 | if (a[i] > mx) mx = a[i]; | 求最大/最小 |
| ④ 数组下标嵌套 | a[a[i]]、p2[i] = p1[p1[i]] | 置换、映射 |
| ⑤ 字符串变换 | 遍历字符 + 条件改写 | 大小写、位移、映射 |
| ⑥ 递归 | 函数调用自己 | 阶乘、斐波那契、约瑟夫环 |
| ⑦ 模拟 | 按题意一步步改状态 | 相减、移动、游戏 |
| ⑧ 排序/查找 | 双重循环 + 交换 / 二分 | 冒泡、二分 |
看到哪一类,就用哪一类的套路:
- 遇到 ① ② ③ → 列表记录每轮的值;
- 遇到 ④ → 先画值表,再逐层代入;
- 遇到 ⑤ → 逐字符推演(画出「原字符 → 新字符」对照);
- 遇到 ⑥ → 用 DAY16 的「递归求值四步法」,从小往大列表;
- 遇到 ⑦ → 严格按代码顺序走,不许"想当然";
- 遇到 ⑧ → 数交换次数 = 数逆序对;二分就数循环次数。
3.3 阅读程序的三个「必查细节」
① 循环边界:< 还是 <=?起点是 0 还是 1?
for (int i = 1; i <= n; i++) // 从 1 到 n,共 n 次
for (int i = 0; i < n; i++) // 从 0 到 n-1,共 n 次
两种写法次数相同,但下标取值完全不同,直接影响答案。
② 输出格式:有没有 +1?有没有换行?有没有保留小数?
前面那道约瑟夫环题,
printf("%d\n", s + 1)—— 只要有+1就必须加,这是最常见的失分点。
③ 整数除法的截断
int mid = (l + r) / 2; // 向下取整
z = (y * f[1] + x) / f[2]; // 整数除法,只看整数部分
3.4 完善程序题:解题四步法 ★★
第 1 步:读「问题描述」—— 这是全题最重要的部分!
(程序要解决什么问题?输入什么、输出什么?样例是什么?)
第 2 步:理解程序结构 —— 变量名 + 已写好的代码,推断出"每一段在干什么"
第 3 步:定位每个空 —— 判断这个空属于"哪一类"(见下方五类空位)
第 4 步:代入验证 —— 把选项代进去,用样例(或自造小样例)跑一遍
★ 五类常见空位
| 空位类型 | 特征 | 判断方法 |
|---|---|---|
| ① 初始化空 | 变量第一次出现、出现在循环之前 | 看这个变量后面怎么用(累加就要初始化为 0,求最大可能初始化为 0 或 −∞) |
| ② 循环条件空 | 出现在 for (...; ...; ...) 中间 | 看循环要覆盖哪些下标 |
| ③ 循环变量范围空 | 出现在 for (int i = 【】; ...) | 看数组下标从哪开始、题目的数据范围 |
| ④ 判断条件空 | 出现在 if (【】) 里 | 看注释、看题意、看下面执行什么 |
| ⑤ 更新/赋值空 | 出现在 x = 【】;、ans = 【】; | 看这个变量的语义(记录什么?累加什么?) |
★ 代入验证法(保命技巧)
遇到不确定的空:把 4 个选项逐个代进去,用小样例(如 n = 42)跑一遍
→ 哪个选项能得到题目给的样例输出,就选哪个
★ 两个排除技巧
- 类型/语法排除:明显类型不符(如把
n % 10写成n % 2)、语法不对的选项直接排除; - 语义排除:与题目要求不符的选项排除(题说「最小值」而选项在算「最大值」)。
3.5 ★ 完整实战:2024 年完善程序(Oier 数字游戏)
问题描述
Oier 设计了一种有趣的数字游戏:一位同学随机给出一个数 n,其余同学需要构造一个数列 a₁, a₂, …, aₓ,满足:
- 数列中所有数的和等于 n;
- 数列中每个数 aᵢ 的每一位数字只能是 0 或 1(如 1、101、11011 符合;5、12、8910 不符合);
- 在满足上述条件的情况下,尽可能减少数列的长度 x。
你需要输出最小的数列长度 x 以及这个数列。
样例:输入
42→ 输出4;输入356→ 输出6,数列为111 111 111 11 11 1
程序代码
1 #include <bits/stdc++.h>
2 using namespace std;
3 int ans[100001];
4 int main()
5 {
6 int n, t = 0, num_loc = 0;
7 cin >> n;
8 while (n != 0)
9 {
10 ans[++t] = 【41】;
11 if (ans[t] > num_loc)
12 num_loc = 【42】;
13 n /= 10;
14 }
15 cout << 【43】 << endl;
16 for (int i = 1; i <= num_loc; i++)
17 {
18 int k = 0;
19 for (int j = 【44】; j >= 1; j--)
20 {
21 if (ans[j] != 0)
22 {
23 k = 【45】;
24 cout << 1;
25 ans[j]--;
26 }
27 else if (k)
28 cout << 0;
29 }
30 cout << endl;
31 }
32 return 0;
33 }
逐空分析
【41】 第 10 行 ans[++t] = 【41】; 在 while (n != 0) 里,下一行是 n /= 10。 → 这是逐位取出 n 的各位数字(从个位开始),标准写法是 n % 10。 → 答案 A(n % 10)
排除:B
n % 2只能得到奇偶;Cn - 10、Dn - 2不是"取位"操作。
【42】 第 11–12 行:if (ans[t] > num_loc) num_loc = 【42】; → num_loc 要记录的是「所有位数中的最大值」,所以要把它更新为当前这个位上的数字 ans[t]。 → 答案 C(ans[t])
排除:A
t是位数计数;Bn是剩余数字;Dans[n]下标越界且语义不符。 验证:输入 42 → 各位数字最大是 4 →num_loc = 4→ 输出「4」✔ 与样例一致!
【43】 第 15 行 cout << 【43】 << endl; 输出的是最小数列长度。 → 由上面的分析,最小长度就等于各位数字中的最大值 num_loc。 → 答案 B(num_loc)
验证:输入 42 → 输出 4 ✔;输入 356 → 各位最大是 6 → 输出 6 ✔ 与样例一致!
【44】 第 19 行 for (int j = 【44】; j >= 1; j--) 是从高位往低位遍历。 → 位数一共有 t 位(ans[1] 是个位、ans[t] 是最高位),所以起点是 t。 → 答案 A(t)
【45】 第 21–28 行:
if (ans[j] != 0) {
k = 【45】;
cout << 1;
ans[j]--;
}
else if (k)
cout << 0;
→ k 的作用是「这一位之前是否已经输出过 1」。一旦输出过 1,后面的空位就要补 0(保证位数对齐)。 → 所以在输出 1 的时候,把 k 置为 1。 → 答案 D(1)
排除:A
n与语义无关;Bk自己赋值无意义;C0会让k永远为假,后面的 0 永远不输出。
★ 完整验证(输入 42,逐轮推演)
设 ans[1] = 2(个位)、ans[2] = 4(十位),t = 2、num_loc = 4。
| i(第 i 个数) | j=2(ans[2]) | j=1(ans[1]) | 输出 |
|---|---|---|---|
| 起始 | 4 | 2 | — |
| 1 | 非 0 → k=1,输出 1,ans[2]=3 | 非 0 → 输出 1,ans[1]=1 | 11 |
| 2 | 非 0 → 输出 1,ans[2]=2 | 非 0 → 输出 1,ans[1]=0 | 11 |
| 3 | 非 0 → 输出 1,ans[2]=1 | 是 0,k=1 → 输出 0 | 10 |
| 4 | 非 0 → 输出 1,ans[2]=0 | 是 0,k=1 → 输出 0 | 10 |
输出:4 换行,然后 11、11、10、10 验证:11 + 11 + 10 + 10 = 42 ✔ 与样例完全一致!
五空答案:A C B A D
★ 这道题的三个启示 ① 一定要先读「问题描述」 —— 不然根本不知道程序在干什么; ② "样例"是最后的裁判 —— 不确定的空,用样例 42 代进去试; ③ 变量名是最好的提示 ——
num_loc里的 "num" 和 "loc" 已经告诉你它记录"数字的位"相关的东西。
3.6 常见陷阱清单(阅读/完善程序通用)
| # | 陷阱 | 应对 |
|---|---|---|
| 1 | 心算不列表 → 中途算错 | 强制列表,每轮写下来 |
| 2 | 忽略 +1、-1 的偏移 | 输出语句逐字符核对 |
| 3 | 忽略整数除法截断 | 看到 / 先问「两边是整数吗」 |
| 4 | 忽略循环的第二个条件 | 如 i <= k && x != y,任一不满足就停 |
| 5 | 数组下标从 0 还是 1 开始 | 看 ans[++t] 还是 ans[t++] |
| 6 | 忽略「提前终止」(break / return) | 逐行读,遇到 break 立即停止循环 |
| 7 | 完善程序不读问题描述 | 问题描述 > 代码 |
| 8 | 完善程序跳过"已写好的代码" | 已写好的代码是最重要的线索(它告诉你程序走到哪一步了) |
| 9 | 一空卡住不回退 | 先做有把握的空,用其他空的信息反推 |
| 10 | 时间不够,最后一题放弃 | 完善程序只有 5 空但值 10 分,必须留时间 |
3.7 考试时间分配建议(120 分钟笔试中的取舍)
| 大题 | 分值 | 建议用时 | 策略 |
|---|---|---|---|
| 单选 | 60 分(2025) | 25 分钟 | 通识题快速作答,不纠结;先扫一遍全书再回头做难题 |
| 阅读程序 | 30 分 | 40 分钟 | 优先保分——每题 3 空,逐空列表 |
| 完善程序 | 10 分 | 20 分钟 | 先读问题描述,再逐空代入验证 |
| 检查 | — | 5 分钟 | 重点查「有没有漏答」「有没有 +1 忘了」 |
★ 得分优先级:单选 ≤ 阅读程序 ≤ 完善程序(越往后单空分值越高)。 若时间不够:宁可少做几道单选,也要把阅读程序跑完。
3.8 ★ 全真模拟(本日收官任务)
用卷:模拟卷·厦门市小学生计算机竞赛初赛(基础版·GESP一级水平)(45 题 / 100 分)
模拟要求
① 限时 100 分钟(比真实考试少 20 分钟,逼出速度)
② 严格按 2025 新结构作答:单选 30 题 + 阅读程序 10 空 + 完善程序 5 空
③ 只交答题卷(在答题卷上按 【1】…【45】 编号填写)
④ 做完后对照答案,统计每一大题的得分率
模拟后的复盘表(请务必填写)
| 大题 | 得分 | 满分 | 得分率 | 主要失分原因 |
|---|---|---|---|---|
| 单选 | 60 | |||
| 阅读程序 | 30 | |||
| 完善程序 | 10 | |||
| 合计 | 100 |
21 天总复盘(请填写)
| 阶段 | 内容 | 自评掌握度(★~★★★★★) |
|---|---|---|
| 阶段一(DAY1–4) | 计算机通识(时事/体系结构/进制/网络) | |
| 阶段二(DAY5–11) | C++ 语言基础(框架/变量/类型/IO/运算符/算法基础) | |
| 阶段三(DAY12–18) | C++ 语法(分支/循环/数组/字符串/函数递归/结构体/数论) | |
| 阶段四(DAY19–21) | 算法专题与题型专项(排列组合/算法/阅读完善程序) |
回看建议:得分率低于 60% 的模块,在考前 3 天重新翻一遍对应那一天的讲义。
#include<bits/stdc++.h>
using namespace std;
int f(int n, int k) {
if (n == 1)
return 0;
else
return (f(n - 1, k) + k) % n;
}
int main() {
int n, k;
scanf("%d%d",&n,&k);
int s = f(n, k);
printf("%d\n",s+1);
return 0;
}输入数据:5 1
输出数据:( )
输入数据:3 3
输出数据:( )
输入数据:10 2
输出数据:( )
- 第 1 空5 从 f(1,k)=0 逐层向上推:f(2)、f(3)…每一步都是「上一层结果加 k,再对当前 n 取余」。
- 第 2 空2 从 f(1,k)=0 逐层向上推:f(2)、f(3)…每一步都是「上一层结果加 k,再对当前 n 取余」。
- 第 3 空5 从 f(1,k)=0 逐层向上推:f(2)、f(3)…每一步都是「上一层结果加 k,再对当前 n 取余」。
【问题描述】 对于给定的一个长度为 N 的正整数数列 A ~A ,现要将其分成 M (M ≤ N) 段,并 要求每段连续,且每段和的最大值最小。 例如,把以下长度为 5 的数列分成 3 段:4 2 4 5 1 一种分法是:[4 2][4 5][1],每段和分别为 6、9、1,最大值为 9 另一种分法可以是:[4 2][4][5 1],每段和分别为 6、4、6,最大值为 6 可以发现第二种方案是最大值最小的方案
#include<bits/stdc++.h>
using namespace std;
int n, m, a[100005], ans;
bool check(int x)
{
int tot = 0, num = ___①___;
for(int i = 1; i <= n; i++)
{
if(_____②______)
tot += a[i];
else{
_____③_____;
num++;
}
}
return num > m;
}
int main() {
int l = 0, r = 0;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; i++){
scanf("%d", &a[i]);
l = max(l, a[i]);
r += a[i];
}
while(_____④_____){
int mid = ______⑤______;
if(check(mid)) l = mid + 1;
else r = mid;
}
cout << l;
return 0;
}第①空应填写?( )
第②空应填写?( )
第③空应填写?( )
第④空应填写?( )
第⑤空应填写?( )
- 第 1 空B 初始段数为 1(至少一段)。
- 第 2 空A 当前段加上 a[i] 仍然不超过 x 就继续累加。
- 第 3 空D 开新段,并把 a[i] 作为新段的首元素。
- 第 4 空C 二分的循环条件是 L<R。
- 第 5 空A 与 check 的收缩方向配套的中点写法。
#include<bits/stdc++.h>
using namespace std;
int fun2(int num){
if(num<=1)return num;
return fun2(num-1)+num;
}
int fun(int num){
if(num<=1)return num;
int ans=num-fun(num-1)+fun2(num-2);
return ans;
}
int main(){
int n;
cin>>n;
cout<<fun(n)<<endl;
return 0;
}输入 1,请选择正确的输出( )
输入 3,请选择正确的输出( )
输入 5,请选择正确的输出( )
输入 9,请选择正确的输出( )
- 第 1 空A 分别展开两个递归:fun2 是累加,fun 是交错加减,注意 num≤1 时都返回 num。
- 第 2 空B 分别展开两个递归:fun2 是累加,fun 是交错加减,注意 num≤1 时都返回 num。
- 第 3 空C 分别展开两个递归:fun2 是累加,fun 是交错加减,注意 num≤1 时都返回 num。
- 第 4 空C 分别展开两个递归:fun2 是累加,fun 是交错加减,注意 num≤1 时都返回 num。
#include<iostream>
#include<string>
using namespace std;
int main()
{
string num_list= "11223344555666777888999000";
string message;
cin>>message;
for(int i=0;i<message.length();i++)
if((message[i]>='0') && (message[i]<='9') )
cout<<num_list[i];
else if( (message[i]>='A') && (message[i]<='Z'))
cout<<num_list[message[i]-'A'];
cout<<endl;
return 0;
}输入数据:AK
输出数据:( )
输入数据:CODE
输出数据:( )
输入数据:XM_2023
输出数据:( )
输入数据:LOVEC++1024
输出数据:( )
- 第 1 空15 把 'A'~'Z' 映射成 0~25 的下标,再回到 num_list 取字符;非字母数字的字符不输出。
- 第 2 空2723 把 'A'~'Z' 映射成 0~25 的下标,再回到 num_list 取字符;非字母数字的字符不输出。
- 第 3 空062334 把 'A'~'Z' 映射成 0~25 的下标,再回到 num_list 取字符;非字母数字的字符不输出。
- 第 4 空679324555 把 'A'~'Z' 映射成 0~25 的下标,再回到 num_list 取字符;非字母数字的字符不输出。
- 第 1 题A 阅读程序必须列表追值,把每个变量每一步的值写下来,心算极易漏掉循环中的状态变化。
- 第 2 题B 输出语句决定最终答案,多一个 `+1` 结果就差 1;必须逐字符核对输出表达式。
- 第 3 题C 问题描述交代了程序要解决什么、输入输出是什么,先读懂它,空缺处该填什么就有了方向。
- 第 4 题D 已写好的代码规范了变量含义、循环结构和算法框架,顺着它推空缺处往往比空想更快更准。
- 第 5 题A 样例是最后的裁判,代入选项后用给定样例跑一遍,输出对得上就基本正确。
- 第 6 题B 先拿下有把握的空,它们能帮你看清程序整体意图,被卡的那一空往往就迎刃而解。
- 第 7 题C `++t` 先把下标加到 1 再使用,偏 1-based;`t++` 先用再加,偏 0-based,写值表前先定准。
- 第 8 题D 整型 `/` 会向下取整截断,如 7/2 = 3;见 `/` 先判断操作数类型,否则结果会算错。
- 第 9 题A 阅读程序单空 3 分、完善程序单空 2 分,都高于单选的性价比;时间不够时优先保证这两块。
- 第 10 题B 形式变了但难度没降,四个选项往往就是几种典型错算的结果,只有精确追值才能选对。 ---
⑤今日打卡 · 点一下就能勾选
本节把原来的「今天任务」与「今日打卡」合并成一张清单:做完一项点一项,勾选状态自动保存;清单全部勾满即算完成本日打卡。
- 默写阅读程序五步法:读题头、扫变量、找骨架、列表追值、代输入得答案。
- 默写完善程序四步法,并列出五类常见空位(初始化、循环条件、循环变量范围、判断条件、更新赋值)。
- 写出约瑟夫环输出
s + 1中+1存在的原因,说明 0-based 与 1-based 编号的差别。 - 整理八类常见程序模型(如求和递推、模拟、字符串处理、递归等),各写出一句识别特征。
- 针对“数组嵌套下标 a[b[i]]”类题目,写出先画值表再逐层代入的完整解题步骤。
- 制定一份 120 分钟初赛时间分配方案,把单选、填空、阅读程序、完善程序的时间排开并说明优先顺序。
- 完整推演一遍 §3.5 的「Oier 数字游戏」,自己动手列表验证 42 和 356 两个样例
- 完成一整套全真模拟卷并填写复盘表
- 本日结束后,统计 21 天的总打卡天数 / 总做题数 / 总看答案数
- 完成 DAY 21 客观题(
DAY21-01~DAY21-05)
21 天全线收官!本日关键记忆:阅读+完善 = 40 分(固定不变)· 列表追值不许心算 · 完善程序先读问题描述 · 样例是最后裁判 · 输出语句逐字符核对(尤其
+1)· 时间不够优先保阅读程序
全真模拟 · 两套 45 题 100 分
两套卷都按 2025 年厦门初赛的卷面结构出题:一、单项选择 30 题(每题 2 分,共 60 分);二、阅读程序 10 空(每空 3 分,共 30 分);三、完善程序 5 空(每空 2 分,共 10 分)。全卷零输入框,点选项即时判分。
进阶版用 2022–2024 年的常规考点打底,难度略高于真题,适合第一轮自测;拔高版侧重位运算、递推、排列组合与二分,适合冲 90+ 的同学。建议独立计时 90 分钟闭卷完成后再点解析。
模拟卷 · 进阶版
面向已有 C++ 基础、准备冲刺复赛的小学生,难度比真题略高,紧扣厦门小信初赛大纲。
通常把电子计算机的发展分为四个阶段,其中第三代计算机使用的主要电子元件是( )
十进制数 2026 转换成二进制后,数字 1 一共出现了( )次
在 ASCII 码表中,小写字母 'a' 的码值比大写字母 'A' 大( )
浏览网页时地址栏中的网址常以 https 开头,其中字母 s 表示的含义是( )
我国自主建设、独立运行的全球卫星导航系统是( )
在 C++ 程序中写上 using namespace std; 的作用是( )
在 C++ 中,int 类型变量通常能表示的整数范围是( )
下列变量名中,在 C++ 里合法的是( )
表达式 7 / 2 * 2 的值是( )
已知 int a; 执行语句 cin >> a; 后,从键盘输入 3.7 并回车,变量 a 的值是( )
- 第 1 题C 四代计算机的元件依次是电子管、晶体管、中小规模集成电路、大规模集成电路,第三代对应中小规模集成电路。
- 第 2 题A 2026 = 1024+512+256+128+64+32+8+2,对应二进制 11111101010,共有 8 个 1。
- 第 3 题B 'A' 的 ASCII 码是 65,'a' 是 97,相差 32,这正是大小写字母转换时加减 32 的原因。
- 第 4 题D https 中的 s 表示 secure(安全),数据加密后再传输,因此比 http 更安全。
- 第 5 题C 北斗是我国自主建设、独立运行的全球卫星导航系统;GPS 属美国,伽利略属欧盟,格洛纳斯属俄罗斯。
- 第 6 题B using namespace std; 让我们能直接使用 std 命名空间里的 cin、cout,不必写成 std::cin。
- 第 7 题A int 通常占 4 字节、32 位,范围是 -2^31 到 2^31-1,即 -2147483648 到 2147483647。
- 第 8 题D 变量名不能以数字开头、不能是关键字(如 int)、不能含空格;my_age 由字母和下划线组成,合法。
- 第 9 题C 整数除法 7/2 得 3(舍去小数),再乘 2 得 6;同级运算从左到右,不能先算 2*2。
- 第 10 题D cin 读入 int 时只取整数部分,读到小数点便停止,所以 a 的值是 3。
int a = 5; int b = a++; int c = ++a; 则 b + c 的值是( )
在 C++ 中,字符常量 '5' 与整数 5 的关系是( )
int x = 10, y = 0; 执行完下面的语句后,y 的值是( )
if(x > 5) y = 1; else if(x > 8) y = 2; else y = 3;语句 for(int i = 1; i <= 10; i += 2) 的循环体一共执行( )次
执行下面的代码后,变量 s 的值是( )
int s = 0, i = 1;
while(i <= 5){ s += i * i; i++; }定义 int a[10]; 则该数组合法下标的范围是( )
定义 int a[5] = {2, 4, 6, 8, 10}; 则 a[2] + a[4] 的值是( )
已知 string s = "abcde"; 则 s[3] 的值是( )
下列关于 C++ 函数的说法,正确的是( )
已知函数 int f(int n){ if(n <= 1) return 1; return f(n - 1) + f(n - 2); } 那么 f(4) 的值是( )
- 第 11 题A a++ 先用后加,b 得 5、a 变 6;++a 先加后用,a 变 7、c 得 7,b+c=12。
- 第 12 题B '5' 是字符,其 ASCII 码值是 53,和整数 5 完全不同,不能直接混用。
- 第 13 题C x>5 成立,执行 y=1 后整条 if-else 链结束,后面的 else if 不会再判断。
- 第 14 题D i 依次取 1、3、5、7、9,共 5 个值,所以循环体执行 5 次。
- 第 15 题A s = 1+4+9+16+25 = 55,每一项是 i 的平方,别把它当成 1+2+3+4+5。
- 第 16 题C C++ 数组下标从 0 开始,长度为 10 的数组其下标是 0 到 9,不存在 a[10]。
- 第 17 题B 下标从 0 开始,a[2]=6、a[4]=10,相加得 16;a[1]+a[3]=4+8 才是 12。
- 第 18 题D 下标从 0 开始:s[0]='a'、s[1]='b'、s[2]='c'、s[3]='d'。
- 第 19 题B 传值调用只是把值的副本传给形参,函数内改动的是副本,外面的实参不受影响。
- 第 20 题C f(0)=f(1)=1,f(2)=2、f(3)=3、f(4)=f(3)+f(2)=3+2=5。
定义 struct Point { int x; int y; }; 那么 Point 是( )
对数列 5 3 8 1 进行一趟冒泡排序(从小到大,每趟把当前最大的数移到末尾),第一趟结束后数列是( )
在有序数组中用二分查找查找元素,与顺序查找相比,它的特点是( )
用枚举法统计 1 到 100 中能被 3 整除的整数,一共有( )个
现有面额为 1 元、5 元、10 元、50 元的纸币,要找给顾客 68 元并且使张数最少,需要( )张纸币
数列满足 a1 = 1,a2 = 1,an = a(n-1) + a(n-2)(n ≥ 3),则 a6 的值是( )
用深度优先搜索(DFS)探索迷宫时,它的搜索特点是( )
元素 1、2、3、4 依次入栈,入栈过程中允许随时出栈,则下列出栈顺序中不可能出现的是( )
12 和 18 的最大公约数与最小公倍数分别是( )
从 5 名同学中选出 2 名参加比赛,不分先后顺序,一共有( )种不同的选法
- 第 21 题A struct 把若干数据打包成一种新的数据类型,Point 本身是类型名。
- 第 22 题D 依次比较相邻两数:5 与 3 交换、8 与 1 交换,第一趟后为 3 5 1 8,最大的 8 沉到末尾。
- 第 23 题B 二分查找每次把查找范围缩小一半,时间复杂度为 O(log n),但要求数组有序。
- 第 24 题A 3、6、…、99 共 99÷3=33 个;100÷3 取整也是 33。
- 第 25 题C 贪心从大面额开始:50+10+5+1+1+1=68,共 6 张,张数最少。
- 第 26 题D 依次推得 a3=2、a4=3、a5=5、a6=8,这是斐波那契数列。
- 第 27 题B DFS 强调「一路走到底、碰壁再回头」;一层层扩展、借助队列的是广度优先搜索 BFS。
- 第 28 题D 要第一个出 3,需先把 1、2 压在栈底,此后 1 不可能比 2 先出栈,故 3 1 2 4 不可能。
- 第 29 题A 12=2×2×3,18=2×3×3,最大公约数 2×3=6,最小公倍数 12×18÷6=36。
- 第 30 题B 组合数 C(5,2)=5×4÷2=10;若顺序有关才是排列 A(5,2)=20。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int a[105];
for(int i = 0; i < n; i++){
cin >> a[i];
}
int s = 0;
int mx = a[0], mn = a[0];
for(int i = 0; i < n; i++){
s += a[i];
if(a[i] > mx) mx = a[i];
if(a[i] < mn) mn = a[i];
}
cout << s << " " << mx << " " << mn << endl;
return 0;
}输入数据:5
3 1 4 1 5
输出数据:( )
输入数据:4
-2 7 7 0
输出数据:( )
输入数据:3
10 20 30
输出数据:( )
输入数据:1
8
输出数据:( )
- 第 1 空A 求和 3+1+4+1+5=14,最大值 5、最小值 1,输出顺序是先和、再最大、再最小。
- 第 2 空B 和为 -2+7+7+0=12,最大 7、最小 -2;注意负数参与求和,最小值不是 0。
- 第 3 空C 和为 60、最大 30、最小 10,输出「和 最大值 最小值」。
- 第 4 空A 只有一个数 8 时,和、最大值、最小值都等于 8(初值取 a[0] 保证了这一点)。
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int cnt = 0;
for(int i = 0; i < (int)s.size(); i++){
if(s[i] >= '0' && s[i] <= '9') cnt++;
if(s[i] >= 'a' && s[i] <= 'z') s[i] = s[i] - 32;
}
cout << cnt << " " << s << endl;
return 0;
}输入数据:a1B2c3
输出数据:( )
输入数据:xyz
输出数据:( )
输入数据:2025ok
输出数据:( )
- 第 1 空A 数字 1、2、3 共 3 个;小写字母 a、c 转成大写,结果为 A1B2C3。
- 第 2 空C 没有数字,计数为 0;xyz 全部转成大写得 XYZ。
- 第 3 空D 数字共 4 个;字母 o、k 转成大写,结果为 4 2025OK。
#include<bits/stdc++.h>
using namespace std;
int g(int n){
if(n == 0) return 0;
return n % 2 + g(n / 2);
}
int main(){
int n;
cin >> n;
cout << g(n) << endl;
return 0;
}输入数据:13
输出数据:( )
输入数据:10
输出数据:( )
输入数据:255
输出数据:( )
- 第 1 空B 13 的二进制是 1101,函数统计其中 1 的个数,结果为 3。
- 第 2 空C 10 的二进制是 1010,其中共有 2 个 1。
- 第 3 空A 255 的二进制是 11111111,共有 8 个 1。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int mx = 【①】;
int pos = 0;
for(int i = 1; i <= n; i++){
int x;
cin >> x;
if(【②】){
mx = x;
pos = 【③】;
}
}
cout << mx << " " << pos << endl;
return 0;
}第①空应填写( )
第②空应填写( )
第③空应填写( )
- 第 1 空B 数据可能全为负数,初值要取一个足够小的数(如 -1000000000),才能被后面的数正确更新。
- 第 2 空A 要求最大值第一次出现的下标,必须用严格大于 x > mx;若用 >= 会记成最后一次出现的位置。
- 第 3 空C 循环变量 i 从 1 开始,正好是当前数的下标,更新位置写成 pos = i。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int a[105];
for(int i = 0; i < n; i++){
cin >> a[i];
}
for(int i = 0; i < n - 1; i++){
for(int j = 0; j < 【①】; j++){
if(a[j] > a[j + 1]){
【②】;
}
}
}
for(int i = 0; i < n; i++){
cout << a[i] << " ";
}
return 0;
}第①空应填写( )
第②空应填写( )
- 第 1 空B 每趟过后末尾已有 i+1 个数排好,内层只需比较到 n-1-i,写成 n-i 会访问越界。
- 第 2 空C 交换相邻的 a[j] 和 a[j+1] 应写 swap;选项 B 先用 a[j+1] 覆盖 a[j],会丢掉原来的值。
模拟卷 · 拔高版
面向已掌握初赛全部考点、冲刺满分的尖子生,侧重逻辑推演、递归递推、位运算与排列组合计数。
2026 世界人工智能大会在上海开幕,中国企业发布了全球参数规模最大的开源模型,其参数规模达 2.8 万亿。该模型是( )
2026 年,我国首个全国产十万卡 AI 超集群真机首次公开亮相,它的名字是( )
关于我国人形机器人产业的发展现状,下列说法正确的是( )
2026 世界人工智能大会上展出的昇腾 950 超节点 Atlas 950 SuperPoD,是业界已亮相规模最大的超节点,其高密搭载的昇腾算力卡数量为( )
据工业和信息化部披露,我国开源大模型全球累计下载量已突破( )
小明用平底锅煎饼,锅每次最多只能放 2 张饼,两面都要煎,每面需要 1 分钟。煎好 3 张饼最少需要( )分钟。
对序列 [4, 3, 1, 2] 进行冒泡排序(从小到大),完成排序过程中共发生( )次元素交换。
下列关于计算机发展史上关键成果的描述,正确的是( )
某文明采用“五进制累加计数法”:用“○”表示 1,“△”表示 5,“□”表示 25;相同量级符号并列累加,不同量级从左到右按“25 → 5 → 1”排列。则“□□△△△○○”对应的十进制数是( )
某编码系统采用双字节编码:第 1 个字节最高位为 0 表示大写字母、为 1 表示小写字母;第 2 个字节区分具体字符,“A”对应 00000001,“B”对应 00000010……小写字母同理从 00000001 开始。则编码“10000001 00000110”对应的字符是( )
- 第 undefined 题A 2026 世界人工智能大会上,中国企业发布的新一代模型 Kimi K3 参数规模达 2.8 万亿,是目前全球参数最大的开源模型。
- 第 undefined 题B “曙光 8000(登峰)”是中国首个全国产十万卡 AI 超集群,2026 年真机首次公开亮相。
- 第 undefined 题A 工信部披露:2026 年我国人形机器人全年整机产量有望突破 10 万台;整机产品已有 400 余款,占全球一半以上,并已进入工厂、药房等实际场景,故 B、C、D 均错。
- 第 undefined 题C Atlas 950 SuperPoD 高密搭载 1024 张昇腾算力卡,是业界已亮相的超节点中规模最大的。
- 第 undefined 题C 工业和信息化部披露:我国开源大模型全球累计下载量突破 100 亿次。
- 第 undefined 题B 第 1 分钟煎 A 正、B 正;第 2 分钟煎 A 反、C 正(A 取出);第 3 分钟煎 B 反、C 反。共 3 分钟。
- 第 undefined 题C [4,3,1,2]:第 1 趟交换 3 次得 [3,1,2,4];第 2 趟交换 2 次得 [1,2,3,4]。共 5 次。
- 第 undefined 题B A 错:图灵机由图灵提出;C 错:UNIVAC 用电子管;D 错:冯·诺依曼体系核心是二进制 + 存储程序。
- 第 undefined 题B 2×25 + 3×5 + 2×1 = 50 + 15 + 2 = 67。
- 第 undefined 题B 第 1 字节 10000001 最高位为 1 → 小写;第 2 字节 00000110 = 6 → a,b,c,d,e,f 第 6 个,即 f。
某智能手表以十六进制数“200”表示剩余存储空间(单位:字节),换算为十进制的 KB(1 KB = 1024 字节),结果是( )
下列文件扩展名与文件类型的对应关系,不正确的是( )
在 C++ 中 int 占 4 字节。若定义二维数组 int arr[n][n],且占用存储空间不超过 8 MB(1 MB = 1024×1024 字节),则 n×n 的最大值约为( )
字符串“apple”中,长度为 2 且包含字符 'p' 的连续子串有( )个。
一个三位数,除以 5 余 2,除以 6 余 3,除以 7 余 4,这个数最小是( )
下列关于计算机存储层次的说法,正确的是( )
若 a = 9,b = 4,c = 6,则表达式 (a%b == c/b) ? (a-c) : (b*c) 的值是( )
下列关于 C++ 全局变量与局部变量的说法,正确的是( )
下列关于 C++ 函数参数传递的说法,正确的是( )
一幅分辨率为 1024×768 的 256 色图像(每个像素 8 位),经压缩比为 4:1 的算法压缩后,存储空间约为( )
- 第 undefined 题B 0x200 = 2×16² = 512 字节;512 ÷ 1024 = 0.5 KB。
- 第 undefined 题C “.exe”是可执行文件,不是文本文件。
- 第 undefined 题B 8 MB ≈ 8.4×10⁶ 字节;每个 int 4 字节 → 元素总数 ≤ 8.4×10⁶ ÷ 4 ≈ 2×10⁶。
- 第 undefined 题B 长度 2 的子串:ap、pp、pl、le;含 'p' 的是 ap、pp、pl,共 3 个。
- 第 undefined 题A 该数加 3 后能被 5、6、7 整除。LCM(5,6,7) = 210,故为 210k − 3,最小三位数 k=1 → 207。
- 第 undefined 题A 寄存器最快、容量最小;Cache 次之;内存再次;硬盘最慢、容量最大。B、C、D 均错。
- 第 undefined 题A a%b = 1;c/b = 6/4 = 1(整数除法),条件为真,取 a − c = 3。
- 第 undefined 题B 全局变量未初始化时为 0(A 错);同名时函数内访问局部变量(C 错);全局变量生命周期贯穿整个程序(D 错)。
- 第 undefined 题A 按值传递形参是实参副本,互不影响;按引用传递形参是实参别名;C++ 还支持指针传递。
- 第 undefined 题B 1024×768 = 786432 像素,每像素 1 字节;压缩 4:1 后 = 196608 字节 = 192 KB。
某局域网使用子网掩码 255.255.255.0,下列 IP 地址中与 192.168.10.20 属于同一网段的是( )
若 8 位有符号整数 x 的补码为 11110001(二进制),则 x 的十进制值是( )
已知 A = 1,B = 0,C = 1,则表达式 (A ∧ B) ∨ (¬A ∧ C) 的结果是( )
表达式 (a|b) & ~(a&b) 的结果等价于 a 与 b 进行( )运算。
如果代码开头没有声明“using namespace std”,要用 cout 输出“Hi”,正确写法是( )
对于数组 int a[8] = {2,7,1,8,2,8,1,3},a[a[(a[1]+a[3])/2]] 的结果是( )
关于 sort 的使用,正确的是( )
① sort(a[0], a[n]) ② sort(a, a+n) ③ sort(&a[0], &a[n]) ④ sort(arr.begin(a), arr.end(a))
以下三个程序运行后,输出 s 的值( )
① int i=0,s=0; while(i<3){ i++; s+=i; }
② int i=0,s=0; while(i<3){ s+=i; i++; }
③ int i=0,s=0; do{ i++; s+=i; }while(i<3);
有 10 块相同的糖果,分给 4 个小朋友(允许有人分不到),共有( )种分配方案。
袋中有 2 个红球和 3 个白球,随机摸出 1 个球,摸到红球的概率是( )
- 第 undefined 题B 子网掩码 255.255.255.0 要求前 3 段相同,只有 192.168.10.200 满足。
- 第 undefined 题A 补码 11110001:−128 + 64 + 32 + 16 + 1 = −15。
- 第 undefined 题A A∧B = 0;¬A∧C = 0∧1 = 0;0 ∨ 0 = 0。
- 第 undefined 题C (a|b) 表示“至少一个为 1”,~(a&b) 表示“不同时为 1”,相与即“恰好一个为 1”,等价于按位异或 a^b。
- 第 undefined 题B “::”是作用域解析运算符,标准库成员需写成 std::cout。
- 第 undefined 题D (a[1]+a[3])/2 = (7+8)/2 = 7(整数除法);a[7] = 3;再取 a[3] = 8。
- 第 undefined 题C sort 参数是“首地址, 尾后地址”:② sort(a, a+n) 与 ③ sort(&a[0], &a[n]) 正确;① 传的是元素值不是地址;④ 写法错误。
- 第 undefined 题B ① 先加后累加:s = 1+2+3 = 6;② 先累加后加:s = 0+1+2 = 3;③ do-while 先执行后判断,同 ① 得 6。故 ① 与 ② 不同、① 与 ③ 相同。
- 第 undefined 题B 可空分配(隔板法):C(10+4−1, 4−1) = C(13,3) = 286。
- 第 undefined 题B 共 5 个球,红球 2 个,概率 = 2/5。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m = 2, s = 0;
cin >> n;
for(int i = 2; i <= n; i++)
s = (s + m) % i;
cout << s + 1 << endl;
return 0;
}输入 2,输出( )
输入 3,输出( )
输入 5,输出( )
- 第 31 题A n=2:i=2 时 s=(0+2)%2=0,输出 s+1 = 1。
- 第 32 题C n=3:i=2 → s=0;i=3 → s=(0+2)%3=2,输出 3。
- 第 33 题C n=5:s 依次为 0→0→2→0→2(i=2..5),输出 3。
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
for(int i = 0; i < s.length(); i++){
if(s[i] >= 'a' && s[i] <= 'z'){
s[i] = s[i] - 'a' + 'A';
} else if(s[i] >= 'A' && s[i] <= 'Z'){
s[i] = s[i] - 'A' + 'a';
}
}
cout << s << endl;
return 0;
}输入“XiaMen”,输出( )
输入“C++2026”,输出( )
输入“AbC”,输出( )
- 第 34 题A 大小写互换:X→x、i→I、a→A、M→m、e→E、n→N,得“xIAmEN”。
- 第 35 题A C→c;“+”与数字不在转换范围,保持不变,得“c++2026”。
- 第 36 题B A→a、b→B、C→c,得“aBc”。
#include<bits/stdc++.h>
using namespace std;
int f(int n){
if(n <= 1) return 1;
return f(n-1) + f(n-2);
}
int main(){
int n;
cin >> n;
cout << f(n) << endl;
return 0;
}输入 1,输出( )
输入 3,输出( )
输入 5,输出( )
输入 6,输出( )
- 第 37 题B f(1) = 1(n ≤ 1 直接返回 1)。
- 第 38 题B f(0)=1, f(1)=1, f(2)=2, f(3)=f(2)+f(1)=3。
- 第 39 题B f(4)=5, f(5)=f(4)+f(3)=5+3=8。
- 第 40 题C f(6)=f(5)+f(4)=8+5=13。
#include<bits/stdc++.h>
using namespace std;
int n, m, a[1005];
bool check(int x){
int cnt = ___①___; // 分段数
int tot = 0;
for(int i = 0; i < n; i++){
if(tot + a[i] <= x){
tot += a[i];
} else {
___②___; // 新开一段
tot = ___③___; // 新段从当前元素开始
}
}
return cnt <= m;
}
int main(){
cin >> n >> m;
for(int i = 0; i < n; i++) cin >> a[i];
int l = 0, r = 0;
for(int i = 0; i < n; i++) r += a[i];
while(l < r){
int mid = ___④___;
if(check(mid)) r = mid;
else l = ___⑤___;
}
cout << l << endl;
return 0;
}① 处应填( )
② 处应填( )
③ 处应填( )
④ 处应填( )
⑤ 处应填( )
- 第 41 题B 分段数至少为 1,cnt 初始化为 1。
- 第 42 题A 当前段放不下 a[i] 时需新开一段,分段数 cnt 加 1。
- 第 43 题C 新的一段从当前元素 a[i] 开始累加,故 tot = a[i]。
- 第 44 题A 二分中点 mid = (l + r) / 2。
- 第 45 题B check(mid) 不成立说明 mid 偏小,答案在右半部分,故 l = mid + 1。
🎯 加入初赛集训营
美力程 · 科学思维成长中心 —— 厦门本土少儿编程与信息学竞赛培训机构,思明区科技教育白名单机构、GESP / CSP 认证考点,优秀学员可直推厦门一中、双十中学等校队。
联系我们 · 预约免费试听
🏫 五大校区 · 就近上课
海峡 · 会展北天虹购物中心 2 楼 | 蔡塘 · 爱琴海购物公园 3 楼 | 翔安 · 永利大厦 10 楼