一、单选题
1、以下不是微软公司出品的软件是（ ）。
A Powerpoint
B Word
C Excel
D Acrobat Reader
解析：【喵呜刷题小喵解析】：
根据题目要求，我们需要找出不是微软公司出品的软件。
A选项Powerpoint是微软公司出品的演示文稿制作软件。
B选项Word是微软公司出品的文字处理软件。
C选项Excel是微软公司出品的电子表格软件。
D选项Acrobat Reader是由Adobe公司出品的PDF阅读器软件，不是微软公司出品的。
因此，不是微软公司出品的软件是D选项Acrobat Reader。
2、如果256种颜色用二进制编码来表示，至少需要（ ）位。
A 6
B 7
C 8
D 9
解析：【喵呜刷题小喵解析】：在计算机科学中，二进制是一种基本的计数制，它使用0和1两个数字来表示数值。在二进制编码中，每种颜色通常由一组二进制位来表示。对于256种颜色，我们需要找到一个最小的整数n，使得2^n >= 256。通过计算，我们可以发现2^7 = 128 < 256，而2^8 = 256，正好满足条件。因此，至少需要8位二进制位来表示256种颜色。因此，选项C是正确答案。
3、以下不属于无线通信技术的是（ ）。
A、
蓝牙
B、
WiFi
C、
GPRS
D、 以太网
解析：【喵呜刷题小喵解析】：
无线通信技术是一种利用电磁波在空间中传输数据的技术。蓝牙、WiFi和GPRS都是无线通信技术，它们分别用于近距离无线通信、无线局域网和移动数据通信。以太网则是一种有线网络技术，用于连接计算机和其他设备，通过双绞线或光纤等有线介质传输数据。因此，以太网不属于无线通信技术，选项D是正确答案。
4、以下不是CPU生产厂商的是（ ）。
A Intel
B AMD
C Microsoft
D IBM
解析：【喵呜刷题小喵解析】：CPU（中央处理器）是计算机的核心部件，负责执行计算机程序中的指令。在选项中，Intel、AMD和IBM都是知名的CPU生产厂商。而Microsoft是一家知名的计算机软件公司，主要提供操作系统、办公软件等软件产品，不是CPU的生产厂商。因此，选项C“Microsoft”不是CPU生产厂商。
5、以下不是存储设备的是（ ）。
A 光盘
B 磁盘
C 固态硬盘
D 鼠标
解析：【喵呜刷题小喵解析】存储设备是用于存储数据的设备，如硬盘、U盘、光盘等。而鼠标是一种输入设备，用于在计算机中定位和控制光标，不属于存储设备。因此，选项D“鼠标”不是存储设备。
6、如果开始时计算机处于小写输入状态，现在有一只小老鼠反复按照CapsLock、 字母键 A、字母键 S 和字母键 D 的顺序循环按键，即 CapsLock 、A 、S 、D 、 CapsLock 、A 、S 、D 、……，屏幕上输出的第 81 个字符是字母（ ）。
A A
B S
C D
D a
解析：【喵呜刷题小喵解析】根据题目，小老鼠按键的顺序是CapsLock、A、S、D循环。每4个按键为一个循环周期，即CapsLock、A、S、D。要找出第81个字符，我们可以先计算第81个字符在一个完整循环周期内的位置，再确定其字符。
计算第81个字符在一个完整循环周期内的位置：
$位置 = 81 \mod 4 = 1$
根据计算出的位置，我们可以确定第81个字符是循环周期内的第二个字符，即字母A。但是，由于开始时计算机处于小写输入状态，并且小老鼠首先按下了CapsLock键，因此，实际输出的第81个字符将是小写字母s。因此，答案是B，即S。
7、二进制数00101100和00010101的和是（ ）。
A 00101000
B 01000001
C 01000100
D 00111000
解析：【喵呜刷题小喵解析】：二进制数00101100和00010101的和是00111000。根据二进制加法规则，从低位到高位逐位相加，如果某一位的和超过1，则向高位进位。本题中，00101100和00010101相加，0+0=0，0+1=1，1+1=2，向高位进位1，0+1=1，1+0=1，1+1=2，向高位进位1，0+1=1，所以结果为00111000。
8、与二进制小数0.1相等的八进制数是（ ）。
A 0.8
B 0.4
C 0.2
D 0.1
解析：【喵呜刷题小喵解析】：二进制小数0.1转换为八进制数，首先将其转换为二进制小数0.0001100110011...，然后将其转换为八进制数0.4。这是因为0.00011在二进制中等于0.375，0.000110011等于0.371875，0.0001100110011等于0.37109375，依此类推，越来越接近0.375，即0.4。因此，与二进制小数0.1相等的八进制数是0.4，选项B正确。
9、以下是32位机器和64位机器的区别的是（ ）。
A 显示器不同
B 硬盘大小不同
C 寻址空间不同
D 输入法不同
解析：【喵呜刷题小喵解析】：32位机器和64位机器的主要区别在于其寻址空间不同。32位机器一次可以处理32位数据，即4字节，其寻址空间为2的32次方，约为4GB。而64位机器一次可以处理64位数据，即8字节，其寻址空间为2的64次方，理论上几乎可以无限大。因此，选项C“寻址空间不同”是32位机器和64位机器的主要区别。而选项A“显示器不同”、选项B“硬盘大小不同”和选项D“输入法不同”与机器的位数无关，因此不是正确答案。
10、以下关于字符串的判定语句中正确的是（ ）。
A 字符串是一种特殊的线性表
B 串的长度必须大于零
C 字符串不可以用数组来表示
D 空格字符组成的串就是空串
解析：【喵呜刷题小喵解析】：
A选项：字符串是一种特殊的线性表。这是正确的，字符串在计算机科学中通常被视为字符的线性序列，因此可以看作是一种特殊的线性表。
B选项：串的长度必须大于零。这是错误的，字符串的长度可以为零，即空字符串。
C选项：字符串不可以用数组来表示。这是错误的，字符串通常可以用数组来表示，其中每个元素都是一个字符。
D选项：空格字符组成的串就是空串。这是错误的，空串是不包含任何字符的字符串，而由空格字符组成的串则是由一个或多个空格字符组成的字符串，其长度大于零。
因此，正确答案是A选项：字符串是一种特殊的线性表。
11、一棵二叉树如右图所示，若采用顺序存储结构，即用一维数组元素存储该二叉树中的结点（根结点的下标为1 ，若某结点的下标为i ，则其左孩子位于下标2i 处、右孩子位于下标(2i+1)处） ，则图中所有结点的最大下标为 ( ) 。
A 6
B 10
C 12
D 15
解析：【喵呜刷题小喵解析】根据题目描述，二叉树采用顺序存储结构，根节点的下标为1，左孩子位于下标2i处，右孩子位于下标2i+1处。
对于给定的二叉树，我们可以从根节点开始，按照左孩子、右孩子的顺序，依次计算每个节点的下标。
根节点下标为1，左孩子下标为2，右孩子下标为3。
左孩子的左孩子下标为2*2=4，右孩子下标为2*2+1=5。
右孩子的左孩子下标为2*3=6，右孩子下标为2*3+1=7。
左孩子的左孩子的左孩子下标为2*4=8，右孩子下标为2*4+1=9。
左孩子的左孩子的右孩子下标为2*5=10。
左孩子的右孩子的左孩子下标为2*6=12，右孩子下标为2*6+1=13。
右孩子的左孩子的左孩子下标为2*7=14，右孩子下标为2*7+1=15。
从上述计算中，我们可以发现，最大的下标为15。因此，答案是D选项，即15。
12、若有如下程序段，其中s 、a 、b 、c均已定义为整型变量，且a 、c均已赋值（c大于0）。
s = a;
for (b = 1; b <= c; b++)
s = s + 1;
则与上述程序段修改 s 值的功能等价的赋值语句是（ ）。
A s = a + b;
B s = a + c;
C s = s + c;
D s = b + c;
解析：【喵呜刷题小喵解析】：根据题目中的程序段，变量s的初始值为a，然后通过for循环，每次循环s都增加1，循环次数为c。因此，s的最终值应该是a加上c。选项C中的赋值语句s = s + c与程序段的功能等价，因为s = s + c表示s的值增加c，与程序段中的循环效果相同。选项A中的赋值语句s = a + b将s的值设置为a和b的和，选项B中的赋值语句s = a + c将s的值设置为a和c的和，但b的值并没有参与运算，选项D中的赋值语句s = b + c将s的值设置为b和c的和，a的值并没有参与运算，因此选项A、B、D都不正确。
13、有以下程序：
#include <iostream>
using namespace std;
int main() {
int k = 4, n = 0;
while (n < k) {
n++;
if (n % 3 != 0)
continue;
k--;
}
cout << k << "," << n << endl;
return 0;
}
程序运行后的输出结果是（ ）。
A 2,2
B 2,3
C 3,2
D 3,3
解析：【喵呜刷题小喵解析】程序从 `n = 0` 开始，进入循环，只要 `n` 小于 `k`（初始为4）就继续执行循环。循环中，`n` 每次都自增1，然后判断 `n` 是否能被3整除，如果不能，就跳过此次循环，执行 `continue`；如果能被3整除，则 `k` 自减1。循环继续执行，直到 `n` 不再小于 `k`。在这个循环过程中，`n` 的值依次是0, 1, 2，而 `k` 的值则由于 `continue` 和 `k--` 操作，减小到2。所以最后输出 `k` 和 `n` 的值，输出结果为2,3。
14、给定含有n个不同的数的数组L=<x1,x2, ...,xn>。如果 L 中存在xi（1<i<n） 使得 x1<x2< ... <xi-1<xi>xi+1>... >xn， 则称L是单峰的，并称xi 是L的“峰顶”。现在已知 L 是单峰的，请把a-c 三行代码补全到算法中使得算法 正确找到L的峰顶。
Search(k+1, n)
Search(1, k-1)
return L[k]
Search(1, n)
1. k←⌊n/2⌋
2. if L[k] > L[k-1] and L[k] > L[k+1]
3. then
4. else if L[k] > L[k-1] and L[k] < L[k+1]
5. then
6. else
正确的填空顺序是（ ）。
A c, a, b
B c, b, a
C a, b, c
D b, a, c
解析：【喵呜刷题小喵解析】：根据题目描述，我们需要找到单峰数组的峰顶。在二分查找中，我们首先取数组的中间元素作为候选峰顶，然后检查它是否满足峰顶的条件。如果中间元素大于其相邻元素，那么它可能是峰顶；如果中间元素小于其相邻元素，那么峰顶一定在左侧或右侧。因此，我们需要递归地在左侧或右侧继续查找。
首先，我们定义了一个函数Search(left, right)，其中left和right分别表示要查找的数组范围的左右边界。在函数内部，我们取中间元素k作为候选峰顶，然后检查它是否满足峰顶的条件。如果满足，则返回该元素；否则，根据中间元素与相邻元素的大小关系，递归地在左侧或右侧继续查找。
对于题目中给出的三行代码，它们应该是Search函数的递归调用。其中，第一行Search(k+1, n)表示在数组右半部分继续查找；第二行Search(1, k-1)表示在数组左半部分继续查找；第三行return L[k]表示返回当前候选峰顶元素。
根据题目要求，我们需要补全这三行代码，使得算法能够正确找到峰顶。根据二分查找的思想，我们可以将这三行代码按照以下顺序排列：
1. 搜索函数入口：Search(1, n)
2. 取中间元素k作为候选峰顶：k←⌊n/2⌋
3. 检查中间元素是否满足峰顶条件：if L[k] > L[k-1] and L[k] > L[k+1]
* 如果是，则返回当前候选峰顶元素：return L[k]
* 否则，递归地在左侧继续查找：Search(1, k-1)
4. 否则，递归地在右侧继续查找：Search(k+1, n)
因此，正确的填空顺序是c, b, a。
15、设简单无向图G16条边且每个顶点的度数都是2，则图G有（ ）个顶点。
A 10
B 12
C 8
D 16
解析：【喵呜刷题小喵解析】设图G有n个顶点，因为每个顶点的度数都是2，所以每个顶点都有2条边与其相连，总共有16条边，所以有2n=16，解得n=8，但是每个顶点有2条边与其相连，所以一个顶点的两条边不能和自己相连，所以每个顶点都只能和其他的n-1个顶点相连，所以总边数应该是n(n-1)/2=16，解这个方程得到n=8或n=-2（舍去），但是因为一个顶点不能和自己相连，所以总的顶点数应该是n+1=9，但是还需要一个顶点使得其他的8个顶点都能和它相连，所以总的顶点数应该是9+1=10，但是题目要求的是每个顶点的度数都是2，也就是每个顶点都有2条边与其相连，所以总的顶点数应该是n+2=12。因此，图G有12个顶点。
16、有7个一模一样的苹果，放到3个一样的盘子中， 一共有（ ）种放法。
A 7
B 8
C 21
D 37
解析：【喵呜刷题小喵解析】：这是一个经典的组合问题。有7个苹果需要放到3个盘子中，每个盘子至少放一个苹果。我们可以按照以下方式考虑：
1. 首先，从7个苹果中选出1个苹果放到第一个盘子，有7种选择方式。
2. 接着，从剩下的6个苹果中选出1个苹果放到第二个盘子，有6种选择方式。
3. 最后，剩下的5个苹果自动放入第三个盘子。
因此，总的放法是7 × 6 = 42种。但是，由于7个苹果是一模一样的，所以3个盘子的顺序不影响放法的种类。因此，我们需要除以3!（3的阶乘）来去除重复。
3! = 3 × 2 × 1 = 6
所以，42 ÷ 6 = 7种放法。但是，当第一个盘子放1个苹果，第二个盘子放2个苹果，第三个盘子放4个苹果时，与第一个盘子放2个苹果，第二个盘子放1个苹果，第三个盘子放4个苹果是同一种放法。因此，我们需要再除以2。
2 = 2
所以，7 ÷ 2 = 3.5种放法，但这不是一个整数，因此这种分法是不合理的。
实际上，我们考虑的是每个盘子至少放一个苹果的情况。当其中一个盘子放了2个苹果时，其他两个盘子各放1个苹果，这样只有3种放法：
* 第一个盘子放2个，第二、三个盘子各放1个
* 第二个盘子放2个，第一、三个盘子各放1个
* 第三个盘子放2个，第一、第二个盘子各放1个
因此，总共有3种放法。但是，由于苹果和盘子都是一模一样的，所以盘子的排列顺序不影响放法的种类。因此，实际的放法是3 ÷ 3! = 1种放法。
但是，我们还需要考虑其他情况：
* 第一个盘子放3个苹果，第二、三个盘子各放2个苹果。这种情况与第一个盘子放2个苹果，第二个盘子放3个苹果，第三个盘子放2个苹果是同一种放法。因此，只有1种放法。
* 第一个盘子放4个苹果，第二、三个盘子各放1个苹果。这种情况与第一个盘子放1个苹果，第二个盘子放4个苹果，第三个盘子放2个苹果是同一种放法。因此，只有1种放法。
* 第一个盘子放5个苹果，第二个、第三个盘子各放1个苹果。这种情况与第一个盘子放2个苹果，第二个盘子放5个苹果，第三个盘子不放苹果是同一种放法。因此，只有1种放法。
综上，总共有1 + 1 + 1 = 3种放法。但是，由于苹果和盘子都是一模一样的，所以盘子的排列顺序不影响放法的种类。因此，实际的放法是3 ÷ 3! = 1种放法。
但是，这样计算是错误的。正确的放法是：
* 第一个盘子放1个苹果，第二个盘子放2个苹果，第三个盘子放4个苹果
* 第一个盘子放1个苹果，第二个盘子放3个苹果，第三个盘子放3个苹果
* 第一个盘子放2个苹果，第二个盘子放2个苹果，第三个盘子放3个苹果
因此，总共有3种放法。
所以，答案是C选项，一共有21种放法。
17、下图表示一个果园灌溉系统，有A、B、C、D四个阀门，每个阀门可以打开 或关上，所有管道粗细相同， 以下设置阀门的方法中， 可以让果树浇上水的是（ ）。
A B打开，其他都关上
B AB 都打开，CD都关上
C A打开，其他都关上
D D打开，其他都关上
解析：【喵呜刷题小喵解析】：根据题目中的图片，我们可以观察到果园灌溉系统中有A、B、C、D四个阀门，以及四个对应的管道。
首先，我们来看选项A，B打开，其他都关上。如果B阀门打开，水会通过B阀门流入到与B阀门相连的管道中，但是该管道并没有与其他管道相连，所以水无法流到其他果树所在的管道中，果树无法浇上水。因此，选项A不正确。
接着，我们看选项B，AB都打开，CD都关上。如果A和B阀门都打开，水会通过A和B阀门流入到与它们相连的管道中，但是这两条管道并没有与其他管道相连，所以水无法流到其他果树所在的管道中，果树无法浇上水。因此，选项B不正确。
然后，我们看选项C，A打开，其他都关上。如果A阀门打开，水会通过A阀门流入到与A阀门相连的管道中，并且该管道与其他管道相连，所以水可以流到果树所在的管道中，果树可以浇上水。因此，选项C是正确的。
最后，我们看选项D，D打开，其他都关上。如果D阀门打开，水会通过D阀门流入到与D阀门相连的管道中，但是该管道并没有与其他管道相连，所以水无法流到其他果树所在的管道中，果树无法浇上水。因此，选项D不正确。
综上所述，只有选项C可以让果树浇上水，所以正确答案是C。
18、Lucia 和她的朋友以及朋友的朋友都在某社交网站上注册了账号。下图是他 们之间的关系图，两个人之间有边相连代表这两个人是朋友，没有边相连代 表不是朋友。这个社交网站的规则是：如果某人A向他（她）的朋友B分享了某张照片， 那么B就可以对该照片进行评论；如果B评论了该照片，那 么他（她）的所有朋友都可以看见这个评论以及被评论的照片，但是不能对 该照片进行评论（除非A也向他（她）分享了该照片）。现在Lucia已经上 传了一张照片，但是她不想让Jacob看见这张照片，那么她可以向以下朋友 ( ) 分享该照片。
A Dana, Michael, Eve
B Dana, Eve, Monica
C Michael, Eve, Jacob
D Micheal, Peter, Monica
解析：【喵呜刷题小喵解析】：根据题目描述，如果Lucia向她的朋友分享了照片，那么她的朋友可以对照片进行评论，并且他们的朋友也可以看到评论和照片。但是，如果Lucia不想让Jacob看到照片，那么她不能向Jacob的朋友分享照片。
观察关系图，我们可以看到：
* Dana是Lucia的朋友，但不是Jacob的朋友，所以Lucia可以向Dana分享照片。
* Eve是Lucia的朋友，但不是Jacob的朋友，所以Lucia可以向Eve分享照片。
* Monica是Jacob的朋友，所以Lucia不能向Monica分享照片。
* Michael是Jacob的朋友，所以Lucia也不能向Michael分享照片。
因此，Lucia可以向Dana和Eve分享照片，但不能向Monica或Michael分享照片。所以正确答案是B选项：Dana, Eve, Monica。
19、周末小明和爸爸妈妈三个人一起想动手做三道菜。小明负责洗菜、爸爸负责切菜、妈妈负责炒菜。假设做每道菜的顺序都是：先洗菜10 分钟，然后切菜10分钟，最后炒菜10分钟。那么做一道菜需要30分钟。注意：两道不 同的菜的相同步骤不可以同时进行。例如第一道菜和第二道的菜不能同时洗，也不能同时切。那么做完三道菜的最短时间需要（ ）分钟。
A 90
B 60
C 50
D 40
解析：【喵呜刷题小喵解析】根据题目，做一道菜需要30分钟，包括洗菜10分钟，切菜10分钟，炒菜10分钟。由于两道不同的菜的相同步骤不可以同时进行，所以做一道菜需要30分钟，做三道菜的最短时间就是30 × 3 = 90分钟。因此，答案是90分钟。
20、参加NOI比赛，以下不能带入考场的是（ ）。
A 钢笔
B 适量的衣服
C U 盘
D 铅笔
解析：【喵呜刷题小喵解析】：根据NOI比赛的规定，参赛者不能带入考场的是U盘。U盘可能包含作弊工具或违规信息，因此是被禁止带入考场的。而钢笔、适量的衣服和铅笔都是常见的考试用品，没有违反比赛规定。因此，正确答案是C选项。
二、简答题
21、从一个4×4的棋盘（不可旋转）中选取不在同一行也不在同一列上的两个方格，共有 种方法。
参考答案：在一个4×4的棋盘中，选取不在同一行也不在同一列上的两个方格共有12种方法。
解析：【喵呜刷题小喵解析】：
首先，考虑第一行，有4个方格可以选择。
对于第二行，由于不能与第一行在同一列，所以只有3个方格可以选择。
对于第三行，由于不能与第一、二行在同一列，所以只有2个方格可以选择。
对于第四行，由于不能与前三行在同一列，所以只有1个方格可以选择。
对于每一行的第一个方格，第二列、第三列和第四列都可以选择，所以共有3种选择。
对于每一行的第二个方格，第三列和第四列可以选择，所以共有2种选择。
对于每一行的第三个方格，只有第四列可以选择，所以只有1种选择。
因此，总的选取方法为：
4×(3+2+1)=24
但是，由于两个方格不能在同一列，所以每两个方格的组合都要除以2，因此实际的选取方法为：
24÷2=12
所以，从4×4的棋盘中选取不在同一行也不在同一列上的两个方格共有12种方法。
22、约定二叉树的根节点高度为1。一棵结点数为2016的二叉树最少有 个叶子结点；一棵结点数为2016的二叉树最小的高度值是 。
参考答案：一棵结点数为2016的二叉树最少有1008个叶子结点；一棵结点数为2016的二叉树最小的高度值是10。
解析：【喵呜刷题小喵解析】：
首先，我们需要了解二叉树的性质。一个具有n个节点的完全二叉树最少叶子节点数是⌊n/2⌋+1。在这个情况下，n=2016，所以最少叶子节点数为⌊2016/2⌋+1=1008+1=1009。但是，题目中给出的是“最少有”，所以我们取整数部分，即最少有1008个叶子节点。
接下来，我们需要找到高度。由于完全二叉树的高度可以通过公式log2(n+1)向上取整来得到，所以高度为⌈log2(2016+1)⌉=⌈log2(2017)⌉=10。因此，一棵结点数为2016的二叉树最小的高度值是10。
23、
#include <iostream>
using namespace std;
int main() {
int max, min, sum, count = 0;
int tmp;
cin >> tmp;
if (tmp == 0)
return 0;
max = min = sum = tmp;
count++;
while (tmp != 0) {
cin >> tmp;
if (tmp != 0) {
sum += tmp;
count++;
if (tmp > max)
max = tmp;
if (tmp < min)
min = tmp;
}
}
cout << max << "," << min << "," << sum / count << endl;
return 0;
}
输入: 1 2 3 4 5 6 0 7
输出：
参考答案：输出：6, 1, 21/3
解析：【喵呜刷题小喵解析】：
根据给定的代码，程序的功能是计算输入数字中的最大值、最小值和平均值。程序首先定义了一些变量，包括最大值(max)、最小值(min)、总和(sum)和计数(count)。然后，程序读取用户输入的第一个数字，如果这个数字是0，则程序结束。否则，程序将这个数字赋值给max、min和sum，并将count设为1。
接下来，程序进入一个循环，持续读取用户输入的数字，直到输入0为止。对于每个非零数字，程序将其加到sum上，增加count，并更新max和min，如果当前数字大于max，则更新max；如果当前数字小于min，则更新min。
最后，程序输出max、min和sum/count，即输入数字的最大值、最小值和平均值。
对于输入的数字序列"1 2 3 4 5 6 0 7"，程序首先读取数字1，然后读取数字2，以此类推，直到读取数字7。程序计算最大值为6，最小值为1，总和为21，计数为6。因此，输出为"6, 1, 21/3"。
24、
#include <iostream>
using namespace std;
int main() {
int i = 100, x = 0, y = 0;
while (i > 0) {
i--;
x = i % 8;
if (x == 1)
y++;
}
cout << y << endl;
return 0;
}
输出：
参考答案：输出结果为：12
解析：【喵呜刷题小喵解析】：
该程序的主要目的是计算从100开始递减到0的过程中，变量i除以8的余数等于1的次数。
首先，程序定义了三个整数变量i、x和y，并初始化了i为100，x和y都为0。
然后，程序进入一个while循环，条件是i大于0。在每次循环中，程序执行以下操作：
1. 将i减1。
2. 计算i除以8的余数，并将结果赋值给x。
3. 如果x等于1，则将y加1。
循环继续执行，直到i变为0。
最后，程序输出y的值。
在这个例子中，从100到0递减的过程中，i除以8的余数等于1的数值有：100、92、84、76、68、60、52、44、36、28、20、12和0。总共有12个这样的数值，所以y的值为12。因此，程序的输出结果为12。
25、
#include <iostream>
using namespace std;
int main() {
int a[6] = {1, 2, 3, 4, 5, 6};
int pi = 0;
int pj = 5;
int t , i;
while (pi < pj) {
t = a[pi];
a[pi] = a[pj];
a[pj] = t;
pi++;
pj--;
}
for (i = 0; i < 6; i++)
cout << a[i] << ",";
cout << endl;
return 0;
}
输出：
参考答案：该程序旨在反转一个整数数组。代码首先将数组元素的位置交换，从而反转数组。但是，由于`pi`从0开始，`pj`从5开始，当`pi`小于`pj`时，循环实际上没有执行任何交换，因为`pi`始终小于`pj`。因此，输出数组仍然是初始的1,2,3,4,5,6，没有反转。
解析：【喵呜刷题小喵解析】：在这个C++程序中，我们看到一个整数数组`a`被初始化，并且有两个整数变量`pi`和`pj`被赋值。接着，程序进入一个`while`循环，条件是`pi`小于`pj`。在循环内部，变量`t`被赋值为`a[pi]`，然后`a[pi]`和`a[pj]`的值被交换，接着`pi`增加1，`pj`减少1。然而，由于`pi`从0开始，而`pj`从5开始，这个`while`循环实际上永远不会执行，因为`pi`始终小于`pj`。因此，数组`a`没有被反转，输出仍然是初始的数组元素。
要修复这个问题，你可以将`pi`初始化为5，`pj`初始化为0，或者将`while`循环的条件改为`pi < j`，其中`j`是数组的长度（在这个例子中是6）。这样，循环就会正确地交换数组的元素，从而反转数组。
26、
#include <iostream>
using namespace std;
int main() {
int i, length1, length2;
string s1, s2;
s1 = "I have a dream.";
s2 = "I Have A Dream.";
length1 = s1.size();
length2 = s2.size();
for (i = 0; i < length1; i++)
if (s1[i] >= 'a' && s1[i] <= 'z')
s1[i] -= 'a' - 'A';
for (i = 0; i < length2; i++)
if (s2[i] >= 'a' && s2[i] <= 'z')
s2[i] -= 'a' - 'A';
if (s1 == s2)
cout << "=" << endl;
else if (s1 > s2)
cout << ">" << endl;
else
cout << "<" << endl;
return 0;
}
输出：
参考答案：输出结果为："<"
解析：【喵呜刷题小喵解析】：
该程序的主要目的是比较两个字符串s1和s2，其中s1="I have a dream."，s2="I Have A Dream."。程序首先计算两个字符串的长度，然后遍历字符串s1和s2，将其中所有的小写字母转换为大写字母。这是因为程序中的转换操作s1[i]-='a'-'A'会将小写字母转换为对应的大写字母。
转换后的s1和s2分别为"I HAVE A DREAM."和"I HAVE A DREAM."。然后程序比较这两个字符串，由于s1和s2完全相同，因此输出"<"。
然而，这里有一个逻辑错误。程序在比较两个字符串之前，应该先判断两个字符串是否相等，如果相等则直接输出"="，而不是进入后面的比较。所以，程序应该首先比较s1和s2是否相等，如果不相等，再比较它们的字典序大小。
修正后的代码如下：
```cpp
#include
using namespace std;
int main() {
string s1, s2;
s1 = "I have a dream.";
s2 = "I Have A Dream.";
// Convert s1 to uppercase
for (int i = 0; i < s1.size(); i++)
if (s1[i] >= 'a' && s1[i] <= 'z')
s1[i] -= 'a' - 'A';
// Convert s2 to uppercase
for (int i = 0; i < s2.size(); i++)
if (s2[i] >= 'a' && s2[i] <= 'z')
s2[i] -= 'a' - 'A';
if (s1 == s2)
cout << "=" << endl;
else if (s1 > s2)
cout << ">" << endl;
else
cout << "<" << endl;
return 0;
}
```
这样，程序会先比较s1和s2是否相等，如果相等则输出"="，否则再比较它们的字典序大小。在这个例子中，由于s1和s2并不相等，程序会输出"<"。
三、实操题
27、（读入整数）请完善下面的程序，使得程序能够读入两个int范围内的整数，并将这两个整数分别输出，每行一个。（第一、五空2.5分，其余 3 分）
输入的整数之间和前后只会出现空格或者回车。 输入数据保证合法。 例如：
输入：
123-789
输出：
123 -789
#include <iostream>
using namespace std;
int readint() {
int num = 0; // 存储读取到的整数
int negative = 0; // 负数标识
char c;// 存储当前读取到的字符
c = cin.get();
while ((c < '0' || c > '9') && c != '-')
c = (1) ;
if (c == '-')
negative = 1;
else
(2) ;
c = cin.get();
while ( (3) ) {
(4) ;
c = cin.get();
}
if (negative == 1)
(5) ;
return num;
}
int main() {
int a, b;
a = readint();
b = readint();
cout << a << endl << b << endl;
return 0;
}
参考答案：(1) cin.get();(2) num = 0;(3) c >= '0' && c <= '9'(4) num = num * 10 + (c - '0');(5) num = -num;
解析：【喵呜刷题小喵解析】：
1. (1) cin.get();
* 读取输入流中的第一个字符，并将其存储在变量`c`中。
2. (2) num = 0;
* 初始化`num`为0，用于存储读取到的整数。
3. (3) c >= '0' && c <= '9'
* 当读取到的字符`c`是数字（0-9）时，进入循环。
4. (4) num = num * 10 + (c - '0');
* 将读取到的数字字符`c`转换为对应的整数值，并累加到`num`上。
5. (5) num = -num;
* 如果读取到的第一个字符是负号`-`，则将`num`取负。
这个程序通过循环读取输入流中的数字字符，并将其转换为对应的整数值，直到读取到非数字字符为止。如果读取到的第一个字符是负号`-`，则后续读取到的数字将取负。最后，程序返回读取到的整数。
28、（郊游活动）有n名同学参加学校组织的郊游活动，已知学校给这n名同学 的郊游总经费为A元，与此同时第 i 位同学自己携带了Mi元。为了方便郊游， 活动地点提供B(≥n)辆自行车供人租用，租用第j 辆自行车的价格为Cj元， 每位同学可以使用自己携带的钱或者学校的郊游经费，为了方便账务管 理，每位同学只能为自己租用自行车， 且不会借钱给他人， 他们想知道最多 有多少位同学能够租用到自行车。（第四、五空2.5分，其余3分）
本题采用二分法。对于区间[l, r] ，我们取中间点mid并判断租用到自行车的人数能否达到mid。判断的过程是利用贪心算法实现的。
#include <iostream>
using namespace std;
#define MAXN 1000000
int n, B, A, M[MAXN], C[MAXN], l, r, ans, mid;
bool check(int nn) {
int count = 0, i, j;
i = (1) ;
j = 1;
while (i <= n) {
if ( (2) )
count += C[j] - M[i];
i++;
j++;
}
return (3) ;
}
void sort(int a[], int l, int r) {
int i = l, j = r, x = a[(l + r) / 2], y;
while (i <= j) {
while (a[i] < x) i++;
while (a[j] > x) j--;
if (i <= j) {
y = a[i]; a[i] = a[j]; a[j] = y;
i++; j--;
}
}
if (i < r) sort(a, i, r);
if (l < j) sort(a, l, j);
}
int main() {
int i;
cin >> n >> B >> A;
for (i = 1; i <= n; i++)
cin >> M[i];
for (i = 1; i <= B; i++)
cin >> C[i];
sort(M, 1, n);
sort(C, 1, B);
l = 0;
r = n;
while (l <= r) {
mid = (l + r) / 2;
if ( (4) ) {
ans = mid;
l = mid + 1;
} else
r = (5) ;
}
cout << ans << endl;
return 0;
}
参考答案：(1) i = 1;(2) M[i] <= C[j](3) count >= nn(4) check(mid)(5) mid - 1
解析：【喵呜刷题小喵解析】：
1. (1) i = 1;
* 在`check`函数中，我们需要遍历每个同学和每辆自行车，所以`i`和`j`分别表示当前正在考虑的同学和自行车。开始时，`i`和`j`都初始化为1。
2. (2) M[i] <= C[j]
* 这个条件用于判断第`i`位同学是否有足够的钱来租用第`j`辆自行车。如果`M[i]`（第`i`位同学携带的钱）小于或等于`C[j]`（第`j`辆自行车的价格），那么这位同学可以租用这辆自行车。
3. (3) count >= nn
* 在`check`函数中，`count`表示当前已经能够租用到自行车的同学数量。如果`count`大于或等于`nn`（即当前正在检查的中间值），那么说明在`nn`位同学中，至少有`nn`位同学能够租用到自行车，因此返回`true`。
4. (4) check(mid)
* 在`main`函数中，我们使用二分法来寻找最多能够租用到自行车的同学数量。对于区间`[l, r]`，我们取中间点`mid`，并调用`check`函数来判断`mid`是否是一个可能的解。
5. (5) mid - 1
* 如果`check(mid)`返回`false`，说明在`mid`位同学中，不能确保所有同学都能租用到自行车。因此，我们需要缩小搜索范围，将`r`更新为`mid - 1`，继续搜索左半部分。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
