一、单项选择题(共 15 题,每题2分,共计30分,每题有且仅有一个正确选项)
1、以下断电后仍能保存数据的有（ ）。
A. 硬盘
B. 高速缓存
C. 显存
D. RAM
【答案】A
【解析】计算机基础，其他断电都会消失
2、十进制算术表达式：3*512+7*64+4*8+5 的运算结果，用二进制表示为（）。
A.10111100101
B.11111100101
C.11110100101
D.11111101101
【答案】B
【解析】3*512+7*64+4*8+5 可以等于 3*83+7*82+4*81+5*80 ,所以3745是个8进制，把每个数转成3位2进制，连起来即可
3、已知小写字母“m”的十六进制的 ASCII 码值是 6D，则小写字母“c”的十六进制 数的 ASCII 码值是（ ）。
A.98
B.62
C.99
D.63
【答案】D
【解析】6D的十进制是109，那么c的十进制ASCII码值是99，所以，16进制是63
4、在下列关于计算机语言的说法中，正确的有（ ）。
A. 高级语言比汇编语言更高级，是因为它的程序的运行效率更高
B. 随着 Pascal、C 等高级语言的出现，机器语言和汇编语言已经退出
了历史舞台
C. 高级语言比汇编语言程序更容易从一种计算机上移植到另一种计算
机上
D. C 是一种面向对象的高级计算机语言
【答案】C
【解析】A高级语言运行效率低 B.机器语言和汇编语言依然在使用
D. c语言是面向过程的计算机语言
5、入栈的顺序是12345，那么出栈的顺序不可能的是（ ）：
A. 12345
B. 54321
C. 21435 改 21534
D. 21543 改 21345
【答案】C
【解析】画图即可，在345进来的情况下，4不可能在3的前面出栈
6、以下（ ）属于互联网上的 文件传输服务协议。
A. HTTP
B. FTP
C. POP3
D. SMTP
【答案】B
【解析】A是超文本传输协议 C和D都是邮箱协议
7、在程序中用到的一个常数 2e-3 在内存中占（ ）空间。
A、4B
B、4b
C、6B
D、8B
【答案】D
【解析】2e-3是2乘以10的-3次幂，所以是0.002，是小数，默认是double类型，所以在8Byte
8、以下不是队列的特点（ ）
A. 只能在一端进行操作 （只能在两端
B. 是一种特殊的线性表
C. 从顶部出去的元素被称为队头元素 （顶部这种称法是栈
D. 具有先进后出的特点 (先进先出
【答案】A
【解析】队列是队尾进，队头出
9、一个 32 位整型变量占用（ ）个字节。
A. 4
B. 8
C. 32
D. 128
【答案】A
【解析】数据类型尝试
10、中国的国家顶级域名是（ ）。
A. .chn
B. .ch
C. .cn
D. .china
【答案】C
【解析】计算机常识
11、请问下面的程序循环一共执行了多少次（ ）
。
A. 20
B. 10
C. 12
D. 11
【答案】D
【解析】i从1开始，if判断偶数，i又在自增，所以，10个偶数加上初始的1，一共11次
12、深度优先搜索需要用到以下哪个（）算法。
A. 二分
B. 递归
C. 递推
D. 枚举
【答案】B
【解析】深搜概念
13、以下哪一种设备属于输出设备( )。
A. 扫描仪
B. 键盘
C. 鼠标
D. 打印机
【答案】D
【解析】其他都是输入设备
14、在二进制下，1011001+（）=1100110。
A. 1011
B. 1101
C. 1010
D. 1111
【答案】B
【解析】根据二进制逢2进1原理，可以用减法，也可以直接把选项带入，答案是B
15、广度优先搜索需要用到的数据结构( )
A. 队列
B. 栈
C. 链表
D. 图
【答案】A
【解析】广搜概念
二、阅读程序(程序输入不超过数组或字符串定义的范围，判断题正确填√，错误填×;除特殊说明外，判断题1.5分，选择题3分，共计40分)
（1）
1. #include <iostream>
2. #include <string>
3. using namespace std;
4. int main()
5. {
6. string s;
7. char m1, m2;
8. int i;
9.
10. getline(cin, s);
11. m1 = ' ';
12. m2 = ' ';
13. for (i = 0; i < s.length(); i++)
14. if (s[i] > m1) {
15. m2 = m1;
16. m1 = s[i];
17. }
18. else if (s[i] > m2)
19. m2 = s[i];
20. cout<<int(m1)<<' '<<int(m2)<<endl;
21. return 0;
22. }
输入的字符串都是字母和空格
提示：空格的ASCII码值是32
判断题
1. 将第10行程序修改成cin>>s，程序结果不变 （ ）
【答案】×
【解析】getline()支持空格输入，cin不支持
2. 第13行s.length( )可以改成s.size( ) （ ）
【答案】√
【解析】s.length()和s.size()都是获取字符串长度
3. m1变量记录的是字符串中的最大值（ ）
【答案】√
【解析】当s字符串中的元素比m1大的时候，m1就等于s[i]，所以就是在记录最大值
单选题
4. 当输入A B C，最后的结果是（）。
A. 67 66 B. 66 67 C. 97 96 D. 96 97
【答案】A
【解析】m1记录的是最大值，是C，ASCII码值就是67。
m2记录的是次大值，是B，ASCII码值就是66
5. 当输入的字符串是A到Z和a-z的字符串，最的结果是（）
A. 97 65 B. 32 31 C. 122 121 D. 90 89
【答案】C
【解析】m1记录的是最大值，是z，ASCII码值就是122。
m2记录的是次大值，是y，ASCII码值就是121
(2)
1. #include <iostream>
2. using namespace std;
3. int main(){
4. int map[6][6];
5. for(int i=1;i<=5;i++){
6. for(int j=1;j<=5;j++){
7. cin>>map[i][j];
8. }
9. }
10. for(int i=1;i<=5;i++){
11. int m=0;
12. int k;
13. for(int j=1;j<=5;j++){
14. if(map[i][j]>m){
15. m=map[i][j];
16. k=j;
17. }
18. }
19. int n=0x7f7f7f7f;
20. for(int j=1;j<=5;j++){
21. n=min(n,map[j][k]);
22. }
23. if(n==m){
24. cout<<i<<" "<<k<<" "<<n;
25. return 0;
26. }
27. }
28. cout<<"not found";
29. return 0;
30. }
判断题
1. 将第11行的m赋值去掉，程序运行结果一定不变。（）
【答案】×
【解析】m是局部变量，未赋值，不确定值
2. m记录了第i行的最大值。（）
【答案】√
【解析】m记录的是第i行的最大值，k记录了的是最大值所在列
3. n记录了第i行的最小值。（）
【答案】×
【解析】n记录的是第k列的最小值
4. 第25行可以删除，不影响程序结果（）
【答案】×
【解析】程序会往后执行，永远会输出not found
单选题
5. 当输入
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 35
结果是：（）。
A. not found B. 4 1 8 C. 4 5 2 D. 5 5 35
【答案】B
【解析】查找矩阵中所在行最大，所在列最小的数的位置和当前元素，所以8这个元素符合条件
6. 当输入
1 18 319 20 3
78 90 65 31 2
0 8 67 13 32
41 13 89 132 1
4 8 127 31 92
结果是：（）。
A. not found B. 1 1 1 C. 3 1 0 D. 4 4 132
【答案】A
【解析】找不到符合条件的数字
1. #include <iostream>
2. using namespace std;
3. int arr[105][105],n;
4. int dfs(int x,int y){
5. if(x==n){
6. return arr[x][y];
7. }
8. return max(dfs(x+1,y),dfs(x+1,y+1))+arr[x][y];
9. }
10. int main(){
11. cin>>n;
12. for(int i=1;i<=n;i++){
13. for(int j=1;j<=i;j++){
14. cin>>arr[i][j];
15. }
16. }
17. cout<<dfs(1,1);
18. return 0;
19. }
判断题
1. 第18行的dfs(1,1)改成dfs(0,0)，结果不变（）
【答案】√
【解析】因为数组是从下标为1开始的，下标都为0的位置的元素是0，多递归搜索一次，最后还是+0，结果不变
2. 第6行返回的是一定是最后一行的元素（）
【答案】√
【解析】n表示行数，当边界为n的时候，说明搜索到了最后一行
3. 如果n=100，这个程序也能快速运行出结果（）
【答案】×
【解析】程序的时间复杂度为O(2n)，所以100的时候程序运行所需时间非常长，不可能快速运行
单选题
4. 当输入
5
2
-1 4
2 -1 -2
-1 6 4 0
3 2 -1 5 8
输出的结果（）。
A. 16 B. 14 C. 12 D. 10
【答案】B
【解析】从顶端开始往下或者往左，找一条最长的路径之和，所以路线为
2+ 4+ -1+ 6 + 3=14
5. 整个程序的时间复杂度为（）。
A. O(nlogn) B. O(2n) C. O(n3) D. O(n2)
【答案】B
【解析】因为在dfs递归函数中，每次递归都会有两个选择（向右下角或向右下侧），而三角形最多有n层，因此总共的递归次数为2^n，每次递归的时间复杂度为O(1)（只进行了一次比较和一次加法），因此算法总的时间复杂度为O(2^n)。
6. 当输入n=10，依次输入1，2，3，4……，最后的结果（）。
A. 240 B. 250 C. 230 D. 220
【答案】D
【解析】10层，每层都是递增的值，所以路线最长肯定是一直走到右下角，找规律得出1+3+6+10+15+21+28+36+45+55=220
三、完善程序(每题15分,共计 30分)
1. 小码军团是一个 n 行 m 列的矩阵，每个位置是一个编写程序的小能手，特殊位置还有超级小能手。这时候，矩阵上出现了若干感染源，感染瘟疫的人，每过一个小时，就会向四周扩散瘟疫，直到所有人全部感染上瘟疫，被感染的人将忘记C++的所有内容，你已经掌握了感染源的位置，任务是算出超级小能手感染瘟疫的时间，并且将它报告给小码军团负责人。
输入格式
第 1 行：四个整数 n，m，a，b，表示军团矩阵有 n 行 m 列。有 a 个感染源，b 为血色敢死队中超级小能手的数量。
接下来 a 行：每行有两个整数 x，y，表示感染源在第 x 行第 y 列。
接下来 b 行：每行有两个整数 x，y，表示超级小能手的位置在第 x 行第 y 列。
输出格式
第 1 至 b 行：每行一个整数，表示这个超级小能手感染瘟疫的时间，输出顺序与输入顺序一致。如果某个人的位置在感染源，那么他感染瘟疫的时间为 0。
试补全程序。
#include<bits/stdc++.h>
using namespace std;
int n,m,a,b;
int sx[100005][3];
bool vis[505][505];
int maps[505][505];
int fx[4][2] = {{0,-1},{0,1},{1,0},{-1,0}};
struct node{
int x,y,steps;
};
queue <node> Q;
void p(int a,int b){
node tmp;
tmp.x = a;
tmp.y = b;
tmp.steps = 0;
Q.push(tmp);
vis[x][y] = true;
}
void bfs(){
while(!Q.empty()){
node tmp;
node t=Q.front();
for(int i=0;i<=3;i++){
int xx = t.x+fx[i][0];
int yy = t.y+fx[i][1];
if(② && !vis[xx][yy]){
vis[xx][yy] = true;
tmp.x = xx;
tmp.y = yy;
③
Q.push(tmp);
}
}
④
Q.pop();
}
}
int main(){
memset(vis,false,sizeof(vis));
cin>>n>>m>>a>>b;
int x,y;
for(int i=1;i<=a;i++){
cin>>x>>y;
① ;
}
for(int i=1;i<=b;i++){
cin>>sx[i][1]>>sx[i][2];
}
bfs();
for(int i=1;i<=b;i++){
cout<<⑤<<endl;
}
}
1. ① 处应填（ ）。
A. p(y,x)
B. p(x,y)
C. vis[x][y]=true
D. vis[x][y]=false
【答案】B
【解析】先将所有超级小能手的位置入队
2. ② 处应填（ ）。
A. xx<0 && xx>n && yy<0 && yy>m
B. xx>=1 && xx<n && yy>=1 && yy<m
C. xx>=1 && xx<=n && yy>=1 && yy<=m
D. xx>=0 && xx<=n && yy>=0 && yy<=m
【答案】C
【解析】判断是否越界，题目没有明确起始下标，通过选项对比即可
3. ③ 处应填（ ）。
A. tmp.steps = t.steps+1;
B. t.steps = t.steps+1;
C. t.steps = tmp.steps+1;
D. tmp.steps = tmp.steps+1;
【答案】A
【解析】新的位置被感染的步数必定是原步数+1
4. ④ 处应填（ ）。
A. maps[tmp.x][tmp.y] = t.steps;
B. maps[tmp.x][tmp.y] = t.steps+1;
C. maps[t.x][t.y] = t.steps+1;
D. maps[t.x][t.y] = t.steps;
【答案】D
【解析】这个程序中没有在新位置更新步数，所以在当前位置的4个方向搜索完毕后，需要更新自己的位置的步数
5. ⑤ 处应填（ ）。
A. maps[sx[i][1]][sx[i][2]]
B. maps[i][j]
C. maps[sx[i][0]][sx[i][1]]
D. maps[fx[i][1]][fy[i][2]]
【答案】A
【解析】sx数组保存了每个超级小能手的位置，而每个位置的最小步数保存在maps数组中，所以答案选A，
2、(全排列) 输出自然数 1 到 n 所有不重复的排列，即 n 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。
试补全程序。
1. #include <iostream>
2. using namespace std;
3. int arr[100000];
4. void perm(int start,int end){
5. if(start == ①){
6. for(int i = 0; i < end;i++){
7. cout << arr[i] << " ";
8. }
9. cout << endl;
10. return;
11. }
12. for(int i = ②; i < end;i++){
13. swap(arr[start],arr[i]);
14. perm(③,end);
15. ④
16. }
17. }
18. int main(){
19. int n;
20. cin >> n;
21. for(int i = 0; i < n; i++){
22. arr[i] = i + 1 ;
23. }
24. ⑤
25. return 0;
26. }
1. ①处应填( ).
A. end
B. n+1
C. end+1
D. n
【答案】A
【解析】递归的边界条件，end是数组的长度，start一直在增加，加到等于end了，说明排列已经完成，那么D错的原因是n是个局部变量，如果是全局变量，也是对的
2. ②处应填( )
A. 0
B. 1
C. start
D. start + 1
【答案】C
【解析】这个递归全排列的过程就是把元素放在数组当中，从第一个数开始排列，确定完第一个数之后，后面的数组继续全排列，所以递归中会start+1，去排列下个数，那么循环就是当前的start
3. ③处应填( )
A. i
B. start + 1
C. i + 1
D. start
【答案】B
【解析】这个递归全排列的过程就是把元素放在数组当中，从第一个数开始排列，确定完第一个数之后，后面的数组继续全排列，所以递归中会start+1，去排列下个数
4. ④处应填( )
A. swap(arr[start],arr[i]);
B. swap(arr[start],arr[end]);
C. swap(start,i);
D. swap(arr[start+1],arr[i]);
【答案】A
【解析】这个递归全排列的过程就是把元素放在数组当中，从第一个数开始排列，确定完第一个数之后，后面的数组继续全排列，然后会交换元素的位置，交换完之后一定要换回来，否则会导致数据重复
5. ⑤处应填( )
A. perm(0,n-1);
B. perm(1,n);
C. perm(0,n);
D. perm(0,n+1);
答案】C
【解析】perm是递归函数，通过第6行，可以发现i<end，所以end肯定是数组的长度了
0 comments
No comments so far...
