5 这道题又是一道经典的“人肉模拟”题，但它隐藏了一个非常常见的“陷阱”，很多初学者都会掉进去。我们一起来把它揪出来！

第 5 题 执行下面C++代码后，输出是 ()。

string str = ("chen");
int x = str.length();
int temp = 0;
for (int i = 0; i <= x; i++){
    temp++;
}
cout << temp << endl;

• A. 4
• B. 2
• C. 5
• D. 3

启发式讲解

这道题就像一个简单的报数游戏，我们来看看这个游戏是怎么玩的，一共报了多少个数。

第一步：搞清楚游戏规则

1. string str = ("chen");

   • 我们拿到一个单词 "chen"。

2. int x = str.length();

   • 我们要数一下这个单词有多长。c-h-e-n，一共 4 个字母。
   • 所以，变量 x 的值现在就是 4。

3. int temp = 0;

   • 我们准备一个计数器 temp，一开始是 0。

4. for (int i = 0; i <= x; i++)

   • 这是游戏的核心规则！它说：
     • 从 i = 0 开始报数。
     • 只要 i 还小于或者等于 x (也就是 4)，就继续报数。
     • 每报一个数，i 自己就加 1。
   • temp++;
     • 每报一次数，计数器 temp 就加 1。

第二步：开始玩游戏（模拟循环）

我们来跟着规则走一遍：

• 第 1 轮: i 是 0。 0 <= 4 吗？是的。好，temp 变成 1。
• 第 2 轮: i 变成 1。 1 <= 4 吗？是的。好，temp 变成 2。
• 第 3 轮: i 变成 2。 2 <= 4 吗？是的。好，temp 变成 3。
• 第 4 轮: i 变成 3。 3 <= 4 吗？是的。好，temp 变成 4。
• 第 5 轮: i 变成 4。 4 <= 4 吗？是的！ 因为条件是 i <= x (小于等于)，所以 i 等于 4 的时候，游戏还要继续！好，temp 变成 5。
• 下一轮: i 变成 5。 5 <= 4 吗？不是了。游戏结束！

第三步：公布最终结果

游戏结束时，我们的计数器 temp 停在了 5。所以，程序最后会输出 5。

结论

这道题的“陷阱”就在于循环的条件 i <= x。

教练提醒（敲黑板！）：

• for (int i = 0; i < x; i++) -> 这个循环会执行 x 次（i 从 0 到 x-1）。
• for (int i = 0; i <= x; i++) -> 这个循环会执行 x + 1 次（i 从 0 到 x）。

因为多了一个 =，就多循环了一次。这是编程中非常经典的 "off-by-one" (差一错误) 问题。一定要看清楚循环的边界条件！

所以，正确答案是 C. 5。

4 这道题是经典的“人肉模拟”题，考验的是我们的耐心和细心，以及对一个非常关键的 C++ 特性的理解。让我们像电脑一样，一步一步地把答案跑出来。

第 4 题 执行下面C++代码输出是 ()。

int temp = 0;
for (int i = 1; i < 7; i++){
    for (int j = 1; j < 5; j++){
        if (i / j == 2){
            temp++;
        }
    }
}
cout << temp << endl;

• A. 10
• B. 8
• C. 4
• D. 3

启发式讲解

这道题的核心，就是那个双层 for 循环和一个 if 判断。我们的任务就像一个侦探，去寻找所有能让 if (i / j == 2) 这个条件成立的 (i, j) 组合。每找到一组，我们的计分器 temp 就会加 1。

第一步：明确侦查范围

• 外层循环 for (int i = 1; i < 7; i++) 告诉我们，变量 i 的侦查范围是：1, 2, 3, 4, 5, 6。
• 内层循环 for (int j = 1; j < 5; j++) 告诉我们，变量 j 的侦查范围是：1, 2, 3, 4。

第二步：理解破案的关键线索

关键线索就是 if (i / j == 2)。这里藏着一个最重要的“陷阱”！

教练提醒（敲黑板！）： 在 C++ 中，当两个整数（int）做除法时，结果也是整数，小数部分会被直接砍掉！ 比如：

• 5 / 2 的结果是 2，不是 2.5。
• 4 / 2 的结果是 2。
• 3 / 2 的结果是 1。

所以，我们的目标是找到所有 i 除以 j (整除) 等于 2 的情况。

第三步：开始地毯式搜索！

我们固定 i，然后用 j 去试，就像一个一个房间地搜查。

• 当 i = 1 时:

  • j = 1, 1/1 = 1 (不等于2)
  • j = 2, 1/2 = 0 (不等于2)
  • ... (后面 j 更大，商只会更小) -> 没有找到

• 当 i = 2 时:

  • j = 1, 2/1 = 2 -> 找到一组！ temp 变成 1。
  • j = 2, 2/2 = 1 (不等于2)
  • ... -> 本轮共找到 1 组

• 当 i = 3 时:

  • j = 1, 3/1 = 3
  • j = 2, 3/2 = 1 -> 没有找到

• 当 i = 4 时:

  • j = 1, 4/1 = 4
  • j = 2, 4/2 = 2 -> 找到一组！ temp 变成 2。
  • j = 3, 4/3 = 1 -> 本轮共找到 1 组

• 当 i = 5 时:

  • j = 1, 5/1 = 5
  • j = 2, 5/2 = 2 -> 找到一组！ temp 变成 3。
  • j = 3, 5/3 = 1 -> 本轮共找到 1 组

• 当 i = 6 时:

  • j = 1, 6/1 = 6
  • j = 2, 6/2 = 3
  • j = 3, 6/3 = 2 -> 找到一组！ temp 变成 4。
  • j = 4, 6/4 = 1 -> 本轮共找到 1 组

第四步：汇报战果

我们总共找到了几组？

1. (i=2, j=1)
2. (i=4, j=2)
3. (i=5, j=2)
4. (i=6, j=3)

一共是 4 组。所以，temp 从 0 开始，被 ++ 了 4 次，最终的值就是 4。

结论

因此，程序的最终输出是 4，对应选项 C。

一句话总结：做这种题，不要怕麻烦，像机器一样一步步地模拟，并且死死记住“整数除法会丢掉小数”这个关键点，就能轻松拿下！

3 这道题表面上在考字符串输出，但实际上它在偷偷地测试一个我们编程中最最最基本，也最容易犯错的知识点。

先把原题展示出来：

第 3 题 下面C++代码执行后不能输出 "GESP" 的是()。

• A. string str("GESP"); cout<<str<<endl;
• B. string str="GESP"; cout<<str<<endl;
• C. string str("GESP"); cout<<str[1]<<str[2]<<str[3]<<str[4]<<endl;
• D. string str{"GESP"}; cout<<str<<endl;

启发式讲解

这道题就像给你几种不同的方法来制作一个写着 "GESP" 的名牌，然后问你哪种方法做出来的名牌是错的。

第一步：排除法，看看哪些是肯定对的

我们先看 A、B、D 这三个选项。

• A. string str("GESP");
• B. string str="GESP";
• D. string str{"GESP"};

这三种写法，虽然括号、等号、花括号长得不一样，但它们都是 C++ 里标准且正确的初始化字符串的方式。它们都在告诉电脑：“嘿，帮我创建一个名为 str 的字符串名牌，上面写上 'GESP' 这几个字。”

然后它们都用了 cout << str << endl; 来输出。这句代码的意思就是“把整个 str 名牌上的内容完整地打印出来”。

所以，A、B、D 这三种方法，都能正确地制作出 "GESP" 名牌，并完整地把它展示出来。它们都是对的。

第二步：聚焦嫌疑人 C

现在只剩下 C 选项了。我们来看看它在干什么。

C. string str("GESP"); cout<<str[1]<<str[2]<<str[3]<<str[4]<<endl;

第一部分 string str("GESP"); 是对的，它成功地创建了 "GESP" 这个名牌。

问题出在第二部分，也就是输出的方式。它没有直接打印整个名牌，而是想一个一个字母地往外蹦。

str[1] 是什么意思？这是在取字符串里的第 1 个字符吗？

教练提醒（敲黑板！）： 在 C++ 和几乎所有主流编程语言里，我们有一个黄金法则：数数永远从 0 开始！

所以，对于字符串 "GESP"：

• 'G' 是第 0 个字符，地址是 str[0]
• 'E' 是第 1 个字符，地址是 str[1]
• 'S' 是第 2 个字符，地址是 str[2]
• 'P' 是第 3 个字符，地址是 str[3]

现在我们再看 C 选项的输出代码：

• cout << str[1] -> 它会输出 'E'。
• cout << str[2] -> 它会输出 'S'。
• cout << str[3] -> 它会输出 'P'。

到这里，屏幕上显示的是 "ESP"。已经不对了，因为它把开头的 'G' (str[0]) 给漏掉了！

更严重的问题： 代码还试图输出 str[4]。我们的字符串只有 4 个字符，地址是从 0 到 3。那地址 4 上有什么？ 什么都没有！ 这就像你住在一个只有 0、1、2、3 号房间的楼里，却非要去敲 4 号房的门，这是不存在的房间。

在编程里，访问一个不存在的地址，我们称之为“数组越界”。这会导致程序出错（Undefined Behavior），可能会输出一个奇怪的乱码，甚至直接崩溃。

结论

所以，C 选项不仅因为从 str[1] 开始输出而漏掉了 'G'，还因为试图访问不存在的 str[4] 而犯了更严重的错误。它无论如何都不可能输出 "GESP"。

一句话总结：记住编程世界的铁律——下标从 0 开始！C 选项忘了这条，所以它错了。

2 这道题是考察我们对不同进制之间转换的基本功，这是信息竞赛里必须掌握的技能。我们把它想象成一个“破译密码”的游戏。

第 2 题 在下列编码中，不能够和二进制 "1101 1101" 相等的是()。

• A. (221) 10进制
• B. (335) 8进制
• C. (dd) 16进制
• D. (5d) 16进制

启发式讲解

第一步：找到我们的“标准答案”

要判断谁跟 1101 1101 不一样，我们首先得知道 1101 1101 这个“二进制密码”到底代表了什么。最直接的方法，就是把它翻译成我们最熟悉的 十进制。

我们来翻译一下 11011101（为了方便，我把空格去掉了）： 这就像给每一位标上“身价”，从右往左，身价分别是 1, 2, 4, 8, 16, 32, 64, 128... (也就是 2 的 0 次方, 2 的 1 次方, ...)。然后把位上是 1 的“身价”加起来。

  1    1    0    1    1    1    0    1   (二进制数)
  |    |    |    |    |    |    |    |
 128   64   32   16   8    4    2    1   (对应的“身价”)

现在，我们把所有是 1 的位的身价加起来： 128 + 64 + 16 + 8 + 4 + 1 = 221

好了！我们破译出来了，这个二进制数在十进制里就是 221。现在我们的任务就变成了：在四个选项里，找到哪个数不等于 221。

第二步：逐个“验证嫌疑人”

• A. (221) 10进制

  • 这个已经是十进制了，就是 221。它和我们的标准答案完全一样。所以 A 是相等的。

• C 和 D. (dd) 16进制 和 (5d) 16进制 (我们先看这两个，因为有个超酷的技巧！)

  教练小提示（超级捷径！）： 二进制和十六进制之间有非常亲密的关系！因为 16 = 2^4，所以每 4 位二进制数，正好能对应 1 位十六进制数。

  我们来试试用这个捷径破译 1101 1101：

  1. 把它分成 4 位一组：1101 和 1101。
  2. 我们来翻译 1101 是多少：8 + 4 + 0 + 1 = 13。
  3. 在十六进制里，10 是 A, 11 是 B, 12 是 C, 13 是 D。
  4. 所以，1101 对应 D。

  那么，1101 1101 这个二进制数，翻译成十六进制就是 DD！

  • C. (dd) 16进制： Bingo！完全匹配！所以 C 是相等的。
  • D. (5d) 16进制： 这个是 5D，明显和我们算出来的 DD 不一样。所以 D 不相等。

  到这里，我们其实已经找到答案了！

• B. (335) 8进制 (我们来验证一下)

  教练小提示 2： 类似的，因为 8 = 2^3，所以每 3 位二进制数，正好能对应 1 位八进制数。

  我们来破译 11011101：

  1. 从右往左，3 位一组：11 011 101 (最左边不足3位，可以在前面补0，变成 011)
  2. 011 -> 0*4 + 1*2 + 1*1 = 3
  3. 011 -> 0*4 + 1*2 + 1*1 = 3
  4. 101 -> 1*4 + 0*2 + 1*1 = 5

  组合起来，就是 335。所以 B 也是相等的。

结论

通过我们的“破译”，我们发现 A、B、C 三个选项所代表的数值都是 221，而 D 选项的 (5d) 16进制 是一个完全不同的数 (5*16 + 13 = 93)。

所以，不能够和二进制 "1101 1101" 相等的是 D。

一句话总结：做这种题，要么都换算成最熟悉的十进制来比较，要么利用二进制与八/十六进制之间的分组换算“捷径”来快速识别，后者在竞赛中更快哦！

1 这道题其实是在考验我们对 C++ 里各种“篮子”能装多大东西的理解。

先把题目放出来：

第 1 题 下面C++数组的定义中，会丢失数据的是()。

• A. char dict_key[] = {'p', 't', 'o'};
• B. int dict_value[] = {33, 22, 11};
• C. char dict_name[] = {'chen', 'wang', 'zhou'};
• D. float dict_value[] = {3, 2, 1};

启发式讲解

想象一下，我们有几种不同大小的篮子：

• char：这是一个 小号篮子，规定了只能放一个水果，比如一个苹果 'a'，一个橘子 'o'。
• int：这是一个 中号篮子，可以放一串整数，比如 33。
• float：这也是一个 中号篮子，可以放带小数的数字，比如 3.14。

现在我们来分析每个选项，看看哪个选项在“放东西”的时候会把东西弄丢。

A. char dict_key[] = {'p', 't', 'o'};

这里我们有一堆 小号篮子 (char 数组)，然后依次放入 'p', 't', 'o' 这三个水果。 一个 char 篮子放一个字符 'p'，刚刚好。一个篮子放一个 't'，也刚刚好。没问题，东西都好好地放进去了。

B. int dict_value[] = {33, 22, 11};

这里我们有一堆 中号篮子 (int 数组)，然后依次放入 33, 22, 11 这几个整数。 一个 int 篮子放一个整数 33，容量足够。这也是最常规的操作，不会丢失数据。

D. float dict_value[] = {3, 2, 1};

这里我们有一堆 专门放小数的中号篮子 (float 数组)，但我们放进去的是整数 3, 2, 1。 这就像你用一个能装 5.5 公斤东西的篮子去装 5 公斤的东西，完全没问题。计算机会自动把整数 3 变成小数 3.0 放进去。数据不仅没丢，反而变得更“精确”了。所以这个也没问题。

C. char dict_name[] = {'chen', 'wang', 'zhou'};

重点来了！ 这里我们用的还是一堆 小号篮子 (char 数组)，每个篮子规定了只能放一个水果。

但是，你现在要放的东西是 'chen'。这是什么？这是把 'c', 'h', 'e', 'n' 四个水果用胶带捆在了一起，试图硬塞进一个只能放一个水果的小篮子里！

结果会怎么样？

篮子肯定装不下！为了能塞进去，你不得不把 'c', 'h', 'e' 都扔掉，可能最后只留下了 'n'（或者一个烂掉的果泥，也就是乱码）。无论如何，前面三个水果的信息（数据）都丢失了。

结论

所以，选项 C 的做法是错误的。它试图将一个多字符的“水果捆” ('chen') 塞进一个单字符的“小篮子” (char)，必然会导致大部分数据被丢弃。

一句话总结：char 的篮子太小，一次只能装一个字符，'cher' 这种写法太贪心，东西会掉出来（数据丢失）！