十三の博客
0%

2019年真题解析

发表于 更新于 分类于

2019年真题解析

哪个学校的我就不说了，你们信息收集那么厉害肯定找得到

单纯放一下我对一些题目的总结

临时存答案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
答题卡
一、单选题
1.D 2.D 3.A 4.C 5.B
6.C 7.D 8.D 9.A 10.B
//正确答案  CDACB CADAB 错2个  
//16分
二、判断题
1.对 2.错 3.错 4.错 5.错
6.错 7.对 8.错 9.对 10.对
//正确答案  TFFTF FTFFF 错了3个
//14分
三、程序分析题
21.
程序功能：输出年龄最大的那个人的姓名和年龄
程序运行结果：Liming,58  
//正确 10分
22.
程序功能：判断第二个字符串是否在第一个字符串里面，在的话就输出yes，不在就输出no //正确
（1）程序结果：no //正确
（2）程序结果：yes //错误
//3分吧
23.
程序功能：把大写变成小写，把小写变成大写
程序结果：tHIS IS A TEST OF c pROGRAM lANGUAGE!
//十分

四、程序设计图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//24题
#include <stdio.h>
#define M 3
#define N 4

int fun(int array[M][N]) {
    int sum = 0;
    //计算数周围，也就是第一行的，最后一行的，中间行的第一个和最后一个加起来即可
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            if (i == 0 || i == M - 1) {
                sum += array[i][j];
                printf("%d\n", sum);
            }
            else if ((0<i<M) && ((j == 0) || (j == N - 1))) {
                sum += array[i][j];
                printf("%d\n", sum);
            }
            else {
                ;
            }
        }
    }
    return sum;
}

int main() {
    //首先获取二维数组
    int hang, lie;
    printf("这是一个3行4列的二维数组，请按照提示输入数组的内容");
    int arry[M][N];
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("\n请输入第%d行的第%d列的元素:\n",i+1,j+1);
            scanf("%d", &arry[i][j]);
        }
    }

    //展示数组
    printf("\n展示数组\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d  ",arry[i][j]);
        }
        printf("\n");
    }
    printf("数组的边界之和为：%d", fun(arry));

    
}

image-20230918191104976

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//25题
#include <stdio.h>
#define N 4
struct Student {
	char name[30];
	int data;
};

int main() {
	struct Student arr[4];
	char name[30];
	int data;
	for (int i = 0; i < N; i++) {
		printf("请输入第%d个学生的姓名和成绩:",i+1);
		scanf("%s%d",&arr[i].name,&arr[i].data);
	}

	//排序
	struct Student buff;
	for (int i = 0; i < N  ; i++) {
		for (int j = i + 1; j < N; j++) {
			if (arr[i].data < arr[j].data) {
				buff = arr[i];
				arr[i] = arr[j];
				arr[j] = buff;
			}
		}
	}
	//存放最大的成绩的人
	struct Student max[4];
	max[0] = arr[0];
	int bf = 1;
	for (int i = 1; i < N; i++) {
		if (arr[0].data == arr[i].data) {
			max[bf] = arr[i];
			bf++;
		}
	}

	for (int i = 0; i < bf; i++) {
		printf("\n成绩最大的人有：%s,分数为%d", max[i].name, max[i].data);
	}
}
//

image-20230918194123643

最后一道题sort函数我不知道。哦他让我们自己设计sort函数，不管，先放上来哈。

C语言sort函数_李歘歘的博客-CSDN博客

1

最后一道没写出来，54分

总分就是105分，我超这才105.。。。。。🥲要死掉惹

整个习题的总结

下面开始每一个题目每一个题目的进行解析和相关知识点总结啊

填空题

1

image-20230920090248486

编译程序的功能是将”高级语言”翻译为”机器语言”,将C语言语句转换成二进制的机器指令。

C语言程序编译的步骤通常包括：预处理、编译、汇编、链接。

但是首要工作是检查语法错误，所以这道题选c

1
2
3
4
5
6
gcc编译过程分为4个阶段：预处理、编译、汇编、链接。
预处理：头⽂件包含、宏替换、条件编译、删除注释
编译：主要进⾏词法、语法、语义分析等，检查⽆误后将预处理好的⽂件编译成汇编⽂件。
汇编：将汇编⽂件转换成 ⼆进制⽬标⽂件
链接：将项⽬中的各个⼆进制⽂件+所需的库+启动代码链接成可执⾏⽂件。
程序的逻辑和完整性，编译器在编译阶段可以进行检查，但不是其首要目的。

2

image-20230920090818142

这道题选D，这个学过数学的都知道选D吧。看不出来直接立即推算了。

其他的也不多解析了，随便看看吧，A选项要把与和或都交换一下就对了，B选项要把两个括号中间的换成或，C选项是个几把，正负号和加法有毛关系。

3

image-20230920091038948

这个也是很简单的啦，首先看看fun函数，他就是接收一个整数x，然后返回x即可。但是在main函数中，a变量是一个float类型。这个时候我们就需要复习一下我们学过的隐式数据类型转换了。下面介绍两种经典情况

以实参类型为准的情况
在一些情况下，编译器会自动转换实参的类型以匹配形参的类型，这意味着实参的类型将起决定作用。
例如：
假设函数的形参为int类型，实参为float类型的值。在调用函数时，编译器会自动将float类型的实参转换为int类型。这种情况下，实参的类型起决定作用，即使会损失精度。

以形参类型为准的情况

在其他情况下，编译器将以形参类型为准，要求实参类型与之严格匹配。
例如：
假设函数的形参为char类型，实参为int类型的值。在调用函数时，编译器将会发出警告或错误，因为int类型无法自动转换为char类型。这种情况下，形参的类型起决定作用，必须确保实参与之严格匹配。

其实总结来说，编译器会先尝试隐式转换，如果不行，就会报错。那么这个float是可以转换成int的，那么就直接转换成int就可以了。

那么看回题目，这道题我们就以int类型为准，最后输出的时候，又是按照%f输出，那么就是酱紫，直接上程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<string.h>
#include <stdio.h>

int fun(int x) {
	return x;
}
int main() {
	float a = 3.14;
	a = fun(a);
	//printf(".2%f\n",a);//我得出这个.23.000000//原题有误
	printf("%.2f\n", a);//改正后
	return 0;
}

image-20230920093254080

多次运行修改程序之后我发现了一件事情，顺序是这样的，A首先变量a是float类型，B传入fun函数之后转换为int类型，只剩下3如下

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<string.h>
#include <stdio.h>

int fun(int x) {
	return x;
}
int main() {
	float a = 3.14;
	//a = fun(a);
	//printf(".2%f\n",a);//我得出这个.23.000000//原题有误
	printf("%d\n", fun(a));//改正后
	return 0;
}

image-20230920094656690

C然后传出来之后又到a变量中，变成float但是只有3了,D最后按%f输出，就是3.00了。但是如果按照%d输出，只会得到0或者乱码，因为是float类型的。所以这道题选A

4

image-20230920095005452

这里p指针指向的是s数组中第二个元素，也就是1。

那么下面a变量就是1*4*6所以最后答案就是C

5

image-20230920095118674

这个位运算我们之前没学啊，后面我会单独找时间补上。（没想到当时我写的时候还蒙对了哈）答案是B

解析:左移运算符“< <”是双目运算符。其功能把“< <”左边的运算数的各二进位全部左移若干位,由“< <”右边的数指定移动的位数,高位丢弃,低位补0。左移1位,相当于该数乘以2。有一说一，我考试的时候就是这么想的

但是我发现，考研的这些题目在百度上面都搜得到，所以我们还是要把找到的题库刷完。

6

image-20230920095422332

三行二列，换成索引的话就是，[2][1]

然后注意看啊！！这个scanf，是输入，也就是说留下的东西是地址就可以，不用引用了。

由于这个是二维数组，所以行索引的话，其实也是一个指针，那么然后你引用了指向指针的指针，就是这个了*(a+2)这个东西其实也是一个地址，是第三行的第一个元素的地址，然后+1就是第三行的第二个元素了。

7

image-20230920100734098

本身定义数组的时候，数组名就是指向数组的第一个元素的指针。//我考试时候的错误思维。

然而，a 是一个一维数组，它的类型是 int[4]，而 p 的类型是指向包含四个整型元素的数组的指针，即 int(*)[4]。它们的类型不匹配，因此在给 p 赋值时会发生编译错误。

但是这道题选A！

int (*p)[10]; p即为指向数组的指针，又称数组指针。

这里不得不提到我们的小董了，有请小董同学😎

二维数组复习 | 小董的BLOG (gitee.io)

我们来解释一下数组指针和指针数组的区别(直接复制的捏)

  • 指针数组

    1
    int *p[3];

    在C语言中，[]的优先级高于*因此此式正确理解为：int *(p[3])，说明p为一个数组，且该数组用于存放地址，此时p是一个数组，但其元素内存储的为某个地址

  • 数组指针

    1
    int (*p)[3];

    先表明了p是一个指针变量，再说明了p指向的对象是一个int[3]型的数组，且p本身保存的是指向数组的首地址，此时p是一个指针

所以正确定义数组指针的方法就是这个捏

1
2
3
4
5
6
7
8
9
10
#include<string.h>
#include <stdio.h>

int main() {
	int a[2][2] = {0,1,2,3};
	int (*p)[2];
	p = a;
	printf("%X\n",**p);
	return 0;
}

8

image-20230920103553873

第一行定义了一个结构体，person。

第二行穿件了一个结构体的数组，M是第三个的name值的第一个字母.所以这道题就选D

9

image-20230920103702815

这个很简单的，需要画图，我当时考试的时候也是花了图才弄出来的。我们直接解析正确答案吧，要不然耗时太久了。

这道题选A，首先题目说的是不能讲s所指的节点插入到链表末尾仍构成单向链表的语句组。

image-20230920104434650

这样的话，后面两个就是循环状态了，就不是单向链表了，所以a选项是错的。

10

image-20230920104509660

这个不多说了哈，B

判断题

11

image-20230920104634120

对的

为0就是表达式不满足了，不满足表达式就不执行。（c语言中，非零整数表示ture）

12

image-20230920104715362

这道题是错的

在用字符串常量初始化字符数组时，数组的长度应该至少是字符串有效字符的个数加上一个额外的位置用于存储字符串结束的空字符（’\0’）。

13

image-20230920104854665

错的

实际上传递给函数的是数组的地址，也就是指向数组第一个元素的指针。

14

image-20230920105542440

这是对的

复合语句用花括号 { } 括起来，可以包含一系列的语句，形成一个逻辑上的代码块。在这个代码块中定义的变量只在该代码块内部有效。

15

image-20230920105731270

错的

有时候我们可以利用switch语句的特性做程序，没必要配对。

16

image-20230920105804898

错的

情况是不确定的，大多都是已形参为准

  1. 如果实参的类型比形参的类型更窄（例如传递整数给浮点数形参），实参会被隐式转换为形参的类型。例如，将整数值 3 传递给形参为浮点数的函数 foo(float num)，实际上会将整数 3 隐式转换为浮点数 3.0。
  2. 如果实参的类型比形参的类型更宽（例如传递一个 long 类型给 int 形参），实参也会通过隐式转换适应形参的类型。
  3. 如果实参和形参的类型完全不匹配，编译器会发出错误。例如，将字符串类型传递给整型形参，或者传递一个指针类型给一个非指针形参。

17

image-20230920110110905

对的

18

image-20230920110123542

指向无参函数的指针

对于这种复杂类型的变量，建议参考本人的博客，c语言碎碎念 | 十三の博客 (wanheiqiyihu.top)

搜一下复杂数据类型，我详细介绍了如何理解。

所以用一下这个方法，设int （）是A,那这个就是（*p）A，这个就是一个指向A的指针了，所以就是指向无参函数的指针。

19

image-20230920110857028

错的

数组初始化时被赋值的元素个数并不决定数组所占内存单元的个数。数组的内存大小是由数组的类型和数组的长度决定的。

image-20230920111037487

image-20230920111104382

20

image-20230920111116410

在程序中定义一个结构体类型后，编译器并不会为结构体的各成员分配内存空间，直到你创建该结构体类型的变量时，内存空间才会被分配。

所以这道题是错误的！

出门吃个国服砂锅😋

程序分析题

21

image-20230921090431970

这种题一定要细心，有时候不是你想的那样的。

不过这个就很简单了，首先定义了一个结构体person，里面会存储名字和年龄。随后跟着定义了一个存有三个结构的数组。

然后主函数中，每有一个最大的age值就把它存在key变量中，同时把对应的person结构体放到q变量中。最后输出q和key。

所以程序的功能就是输出年龄最大的那个人，并且输出其对应的年龄。

image-20230921093514511

22

image-20230921093536777

这个就是我之前说的，有时候并不是你想的那样。

他两个答案都是No!嘿~

image-20230921093744846

这就需要我们一句一句解析了，我直接用注释的方式写出来好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<string.h>
#include <stdio.h>
int main() {
	char str1[100], str2[100];
	char *p1,*p2;
	int k, j, i, len;
	//定义了一些基础的变量
	p1 = str1;
	p2 = str2;//将指针指向之前定义的两个字符串
	scanf("%s",p1);
	scanf("%s",p2);//接收字符串
	k = j = i = 0;//初始化变量
	len = strlen(str2);//这个是计算第二个字符串的长度
	while (p2[k] != '\0' && p1[j] != '\0') {//当两个字符串任何一个执行到\0字符的时候就会停止循环
		//注意这里是p2k！！else后面重置的是k！
		if (p1[k] == p2[j]) {//如果两个字符相等就将光标向后移动
			k++;
			j++;
			printf("相等,%c,%c\n", p1[k], p2[j]);
		}
		else {//如果两个字符不相等就给i加一，顺便k从i开始循环，j从0开始循环。
			i++;
			k = i;
			j = 0;
			printf("不想等,%c,%c,i=%d\n", p1[k], p2[j],i);
		}
	}//也就是说，直到str1的某个字符和str2的第一个字符相等的时候才会执行if中的语句
	if (j > len)//如果j大于第二个字符串的长度的时候就会输出yes。
		//但是也许永远都不可能输出yes了
		//因为str是不会记录\0的，而j的值会停留在\0，虽然j的值会因为是索引少一个，但是多了个\0
		//所以匹配成功也只能是j=len
		printf("Yes!\n");
	else 
		printf("No!\n");
	return 0;
}//再看题目第二个

总结：每一个字符都要看清楚哈！！！这个while好阴。

23

image-20230921101708082

这个就是大写转小写，小写转大写

值得注意的是A的ASCII码是65，a的ASCII码是97

大写转小写是加，小写转大写是减。

程序设计题

这个题要人手搓代码，所以我们要多多练习！

24

image-20230921102006609

这里值得注意的是，由符号常量来确定的意思就是让你define一个预编译。

这个我已经写出来了,中间的注释就是核心思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//24题
#include <stdio.h>
#define M 3
#define N 4

int fun(int array[M][N]) {
    int sum = 0;
    //计算数周围，也就是第一行的，最后一行的，中间行的第一个和最后一个加起来即可
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            if (i == 0 || i == M - 1) {
                sum += array[i][j];
                printf("%d\n", sum);
            }
            else if ((0<i<M) && ((j == 0) || (j == N - 1))) {
                sum += array[i][j];
                printf("%d\n", sum);
            }
            else {
                ;
            }
        }
    }
    return sum;
}

int main() {
    //首先获取二维数组
    int hang, lie;
    printf("这是一个3行4列的二维数组，请按照提示输入数组的内容");
    int arry[M][N];
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("\n请输入第%d行的第%d列的元素:\n",i+1,j+1);
            scanf("%d", &arry[i][j]);
        }
    }

    //展示数组
    printf("\n展示数组\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d  ",arry[i][j]);
        }
        printf("\n");
    }
    printf("数组的边界之和为：%d", fun(arry));

    
}

25

image-20230921102307672

这些题都太简单了，如果是python的话，我用屁股写，可惜是c语言捏，当年写python的难度比这个大多了吧。😅（那为什么最后一道题没有写出来啊喂！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//25题
#include <stdio.h>
#define N 4
struct Student {
	char name[30];
	int data;
};

int main() {
	struct Student arr[4];
	char name[30];
	int data;
	for (int i = 0; i < N; i++) {
		printf("请输入第%d个学生的姓名和成绩:",i+1);
		scanf("%s%d",&arr[i].name,&arr[i].data);
	}

	//排序
	struct Student buff;
	for (int i = 0; i < N  ; i++) {
		for (int j = i + 1; j < N; j++) {
			if (arr[i].data < arr[j].data) {
				buff = arr[i];
				arr[i] = arr[j];
				arr[j] = buff;
			}
		}
	}
	//存放最大的成绩的人
	struct Student max[4];
	max[0] = arr[0];
	int bf = 1;
	for (int i = 1; i < N; i++) {
		if (arr[0].data == arr[i].data) {
			max[bf] = arr[i];
			bf++;
		}
	}

	for (int i = 0; i < bf; i++) {
		printf("\n成绩最大的人有：%s,分数为%d", max[i].name, max[i].data);
	}
}
//

很好！看最后一道题

26

image-20230921103128821

这道题是什么意思，意思就是要求你学生手搓冒泡排序捏。我再来试试吧（又轮到猫鼬小粥的歌了，真的好好听，以前高中就是听这些挺过来的，😋考研也是）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<string.h>
#include <stdio.h>
int show(int array[10]) {
	for (int i = 0; i < 10; i++) {
		printf("%d\n", array[i]);
	}
	return 0;
}

int sort(int array[10]) {
	int temp = 0;
	for (int j = 9; j > 0; j--) {
		for (int i = 0; i < j; i++) {
			if (array[i] > array[i + 1]) {
				temp = array[i];
				array[i] = array[i+1];
				array[i + 1] = temp;
			}
		}
	}
	return 0;
}

int main() {
	int a[10] = { 3,1,10,2,4,5,6,7,9 };
	show(a);
	printf("排序之后捏");
	sort(a);
	show(a);
}

很好已经搓了一个冒泡，然后就不会了。看看学长的答案吧

我草我好纯，根本没想到用现成的函数，我想起来了。那节课我睡着了😅

这道题意思应该是输入10个字符串，然后用strcmp函数来排序,strcpy复制交换字符串

现在要补的就是两节，字符串相关函数，位运算相关的知识。

在C语言中，strcmp函数用于比较字符串str1和str2是否相同。其语法结构为：int strcmp(char *str1, char *str2)。如果str1的字符大于str2的字符，则返回负1；如果相同则返回0。

char * strcpy( char * dst, const char * src );这个函数把字符串src复制到一分配好的字符串空间dst中，复制的时候包括标志字符串结尾的空字符一起复制。

我还以为要手搓挨个字母挨个字母进行对比呢。。。。我是蠢b🥲