西北农林科技大学历年C语言上机考试题.docx
《西北农林科技大学历年C语言上机考试题.docx》由会员分享，可在线阅读，更多相关《西北农林科技大学历年C语言上机考试题.docx（134页珍藏版）》请在冰点文库上搜索。
西北农林科技大学历年C语言上机考试题
西北农林科技大学本科课程考试试题（卷）
2014—2015学年《C语言程序设计》期末考试编程题
专业班级：
命题教师：
集体命题审题教师：
学生姓名：
学号：
考试成绩：
一、计算n个数倒数之和
描述：
编写程序计算（1+1/2+1/3+1/4+…+1/n）的结果，其中变量n从键盘输入，要求n是大于0的整数。
输入：
n
输出：
公式（1+1/2+1/3+1/4+…+1/n）的计算结果。
输入样例：
10
输出样例：
sum=2.928968
提示：
结果输出，请使用代码：
printf（"sum=%lf",sum）;
示例代码：
#include
intmain（）
{
inti=1,n;
do
{
scanf（"%d",&n）;
}
while（n<0）;
doublesum=0;
while（i<=n）
{
sum+=1.0/i;
i++;
}
printf（"sum=%lf",sum）;
return0;
}
测试用例：
用例
输出结果
10
sum=2.928968
15
sum=3.318229
20
sum=3.597740
25
sum=3.815958
30
sum=3.994987
二、数组排序
描述：
从键盘上输入6个整型数，利用函数指针实现这6个整型数的升序和降序排列，并输出排序后的结果，要求使用函数调用、函数指针以及数组编程实现。
提示：
1、实现“大于”函数，该函数比较两个整型数的大小，并返回x>y的值，要求函数原型为：
intgreater（intx,inty）。
2、实现“小于”函数，该函数比较两个整型数的大小，并返回xintlessthan（intx,inty）。
3、实现排序函数，排序函数依据传入的函数不同，实现整型数组的降序或者升序排序，要求函数原型为：
voidsort（inta[],intn,int（*comp）（int,int））。
注意：
指定的3个函数原型不能有任何改动，包括其函数名称及形参列表等。
4、本题目不限制排序算法，常用的选择排序和冒泡排序流程图如下：
图（a）选择排序图（b）冒泡排序
5、在main函数中，首先从键盘中输入6个整型数，然后利用函数指针指向不同的比较函数（大于或者小于函数），调用sort（a,N,comp）子函数实现升序以及降序功能，其中int（*comp）（int,int）;用于声明函数指针comp。
6、结果输出，请使用代码：
for（i=0;iprintf（"%d",…）;//请注意添加需要的代码
printf（"\n"）;
输入：
6个整型数
输出：
以降序和升序的形式输出6个整型数
输入样例：
1417100238945
输出样例：
1008945231714
1417234589100
示例代码：
#include
#defineN6
intgreater（intx,inty）
{
returnx>y;
}
intlessthan（intx,inty）
{
returnx}
voidselection_sort（inta[],intn,int（*comp）（int,int））
{
inti,j;
inttemp,k;
for（i=0;i{
k=i;
for（j=i+1;j{
if（comp（a[j],a[k]））
k=j;
}
if（k!
=i）
{
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
intmain（）
{
inta[N];
inti;
int（*fun）（int,int）;
for（i=0;iscanf（"%d",&a[i]）;
fun=greater;
selection_sort（a,N,fun）;
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
fun=lessthan;
selection_sort（a,N,fun）;
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
return0;
}
测试用例：
用例
输出结果
-19292802816
292828160-19
-19016282829
78-12-45791231
12379781-12-45
-45-1217879123
1828907690232-10
1828232909076-10
-107690902321828
785433-180773
787354337-18
-18733547378
三、计算矩阵卷积
描述：
编程计算整型矩阵A和整型卷积核H的卷积（卷积核是大小为h_size的方阵，且行列数均为奇数，即h_size×h_size的方阵），并输出结果。
若计算机内存不足，则直接终止程序并输出"NotEnoughMemory!
"。
提示：
卷积是一种用途很广的算法，其物理含义是：
输出对输入的响应不仅与当前输入有关，往往还与以前的输入（邻域）有关，输出是这些输入的加权和。
例如对于矩阵A中的某一点，用3×3卷积核进行卷积运算的过程如下图所示：
（1）取出当前点P5的3×3邻域（必须与卷积核大小相同）的各个位置的值（左上、上、右上、左、当前值、右、左下、下、右下）。
（2）分别与卷积核中的对应元素相乘，再求和，将计算结果为P5的新值，替换原位置的数据。
（3）在卷积运算过程中，若当前点位于矩阵A的边缘时，将无法取得其邻域数据（二维数组超界），本题目要求不处理边缘数据，保持原数据不变。
（4）在卷积运算过程中，由于当前点的输出不仅与当前点的值有关，还与其邻域的值有关，因此不能将计算结果直接写回原矩阵，应该再申请一个与原矩阵大小一样的矩阵T，复制原数据到矩阵T，从A中取出数据并处理，处理结果写入T对应位置，运算结束后，矩阵T的内容即为卷积计算的结果。
在程序设计中：
1、矩阵A和卷积核H可用二维数组实现，其大小可变，需要使用动态内存分配，同时注意内存释放的问题（注意不能用C99变长数组）。
2、二维数组的动态内存分配可采用两种方式实现：
（1）先分配m个空间存储行地址，再为每一行分配n个空间存储整型数，二维数组第i行第j列元素对应为a[i][j]，此时内存空间不一定连续。
如：
int**a,m=3,n=4,i;
//先分配m个空间存储行地址
a=（int**）malloc（m*sizeof（int*））;
//再为每一行分配n个空间存储整型数
for（i=0;i{
a[i]=（int*）malloc（n*sizeof（int））;
}
（2）采用大小为m*n的一维数组模拟二维数组，二维数组第i行第j列元素对应为a[i*n+j]，此时内存空间是连续的。
如：
int*a,m=3,n=4;
a=（int*）malloc（m*n*sizeof（int））;
//二维数组第i行第j列元素对应为a[i*n+j]
3、设当前点的位置为P（x,y），则其3×3邻域为P（x-1,y-1）、P（x,y-1）、P（x+1,y-1）、P（x-1,y）、P（x,y）、P（x+1,y）、P（x-1,y+1）、P（x,y+1）、P（x+1,y+1），对于其它尺寸的卷积核，其令域定义以此类推,得到各邻域元素的值的参考代码如下：
//设卷积核的大小为h_size
for（i=0;i{
for（j=0;j{
x_offset=i-h_size/2;
y_offset=j-h_size/2;
//用P（x+x_offset,y+y_offset）便可以得到各邻域元素的值
}
}
4、内存不足提示信息的输出，请使用代码：
printf（"NotEnoughMemory!
\n"）;
结果输出，请使用代码：
for（i=0;I{
for（j=0;j{
printf（"%d",…）;//请注意添加需要的代码
}
printf（"\n"）;
}
输入：
第1行输入2个整数，表示第1个矩阵的行数m1和列数n1。
第2行到第m1+1行顺次输入m1*n1个整数，每行n1个整型元素，表示矩阵A的数据。
第m1+2行输入1个整数，表示卷积核H的行数和列数m2（奇数）。
第m1+3行到第m1+m2+2行顺次输入m2*m2个整数，每行m2个整型元素，表示卷积核H的数据。
输出：
卷积结果
输入样例：
44<---矩阵A的行数和列数
1111<---矩阵A的数据
1111
1111
1111
3<---卷积核H的大小
111<---卷积核H的数据
111
111
输出样例：
1111
1991
1991
1111
示例代码：
/*-------------------------------------------------------
*Copyright（c）2010,西北农林科技大学信息学院计算机科学系
*Allrightsreserved.
*
*文件名称：
convolution.c
*文件标识：
2014-1015学年度期末考试题3
*摘要：
实现voidread_matrix（int**,int,int）;
voidoutput_matrix（int**,int,int）;
voidconvolution（int**,int**,int**,int,int,int）;
voiddestroy（int**,int）;
函数。
*
*当前版本：
1.0
*作者：
耿楠
*完成日期：
2015年1月9日
*
*取代版本：
无
*原作者：
无
*完成日期：
无
-------------------------------------------------*/
#include
#include
#include
//读取矩阵
voidread_matrix（int**,int,int）;
//显示矩阵
voidoutput_matrix（int**,int,int）;
//计算卷积
voidconvolution（int**,int**,int**,int,int,int）;
//销毁矩阵
voiddestroy（int**,int）;
intmain（）
{
intm,n;
inti,j;
inth_size;
int**a,**h,**t;
//读入矩阵行、列大小
scanf（"%d%d",&m,&n）;
//测试数据
//分配原矩阵内存空间
//先分配m个空间存储行地址
a=（int**）malloc（m*sizeof（int*））;
if（a==NULL）
{
printf（"NotEnoughMemory!
\n"）;
return2;
}
//再为每一行分配n个空间存储整型数
for（i=0;i{
a[i]=（int*）malloc（n*sizeof（int））;
if（a[i]==NULL）
{
printf（"NotEnoughMemory!
\n"）;
return2;
}
}
//测试数据
for（i=0;i{
for（j=0;jscanf（"%d",&a[i][j]）;
}
//分配目的矩阵内存空间
//先分配m个空间存储行地址
t=（int**）malloc（m*sizeof（int*））;
//再为每一行分配n个空间存储整型数
for（i=0;i{
t[i]=（int*）malloc（n*sizeof（int））;
}
//输出原数据
//output_matrix（a,m,n）;
//读入卷积核尺寸
scanf（"%d",&h_size）;
//分配卷积核内存空间
//先分配m个空间存储行地址
h=（int**）malloc（h_size*sizeof（int*））;
//再为每一行分配n个空间存储整型数
for（i=0;i{
h[i]=（int*）malloc（h_size*sizeof（int））;
}
//测试数据
for（i=0;i{
for（j=0;jscanf（"%d",&h[i][j]）;
}
//读入卷积核数据
//read_matrix（h,m,m）;
//输出卷积核数据
//output_matrix（h,h_size,h_size）;
//计算卷积
convolution（a,t,h,m,n,h_size）;
//输出计算结果
output_matrix（t,m,n）;
//销毁各矩阵
destroy（a,m）;
destroy（t,m）;
destroy（h,h_size）;
return0;
}
//--------------------------------------------------------------
//原型：
voiddestroy（int**matrix,intm）
//功能：
销毁通过二级指针申请的内存
//参数：
//[int**matrix]---矩阵首地址（二级指针）
//[intm]---矩阵行数
//返回：
无
//作者：
耿楠
//日期：
2015年1月9日
//--------------------------------------------------------------
voiddestroy（int**matrix,intm）
{
inti;
//先销毁各行数据
for（i=0;i{
free（matrix[i]）;
}
//销毁指针数组
free（matrix）;
//指针赋空
matrix=NULL;
}
//--------------------------------------------------------------
//原型：
voidread_matrix（int**matrix,intm,intn）
//功能：
读入矩阵数据
//参数：
//[int**matrix]---矩阵首地址（二级指针）
//[intm]---矩阵行数
//[intm]---矩阵列数
//返回：
无
//作者：
耿楠
//日期：
2015年1月9日
//--------------------------------------------------------------
voidread_matrix（int**matrix,intm,intn）
{
inti,j;
for（i=0;i{
for（j=0;j{
scanf（"%d",&matrix[i][j]）;
}
}
}
//--------------------------------------------------------------
//原型：
output_matrix（int**matrix,intm,intn）
//功能：
输出矩阵数据
//参数：
//[int**matrix]---矩阵首地址（二级指针）
//[intm]---矩阵行数
//[intm]---矩阵列数
//返回：
无
//作者：
耿楠
//日期：
2015年1月9日
//--------------------------------------------------------------
voidoutput_matrix（int**matrix,intm,intn）
{
inti,j;
for（i=0;i{
for（j=0;j{
printf（"%d",matrix[i][j]）;
}
printf（"\n"）;
}
}
//--------------------------------------------------------------
//原型：
voidconvolution（int**matrix,int**result,int**kernel,intm,intn,inth_size）
//功能：
输出矩阵数据
//参数：
//[int**matrix]---源矩阵首地址（二级指针）
//[int**result]---结果矩阵首地址（二级指针）
//[int**kernel]---卷积核矩阵首地址（二级指针）
//[intm]---矩阵行数
//[intm]---矩阵列数
//[inth_size]---卷积核大小（h_size×h_size的矩阵）
//返回：
无
//作者：
耿楠
//日期：
2015年1月9日
//--------------------------------------------------------------
voidconvolution（int**matrix,int**result,int**kernel,intm,intn,inth_size）
{
//控制矩阵循环
intx,y;
//控制卷积核循环
inti,j;
//取邻域数据时的位置偏移量
intx_offset,y_offset;
//计算卷积和
intsum;
//复制矩阵
for（i=0;i{
//利用memcpy（）函数复制每行的整行数据
memcpy（（void*）result[i],（void*）matrix[i],n*sizeof（int））;
}
//计算卷积（h_size/2为无法处理的边缘数据行数和列数）
for（x=h_size/2;x{
for（y=h_size/2;y{
//卷积结果赋0
sum=0;
for（i=0;i{
for（j=0;j{
//计算取邻域数据时的位置偏移量
x_offset=i-h_size/2;
y_offset=j-h_size/2;
//计算卷积
sum=sum+matrix[x+x_offset][y+y_offset]*kernel[i][j];
}
}
//将计算结果写入目标矩阵
result[x][y]=sum;
}
}
}
测试用例：
用例
输出结果
44
1111
1111
1111
1111
3
111
111
111
1111
1991
1991
1111
44
3456
5678
78910
9101112
3
123
456
789
3456
53123578
740244710
9101112
55
22222
22222
22222
22222
22222
3
111
111
111
22222
21818182
21818182
21818182
22222
88
22222222
22222222
22222222
22222222
22222222
22222222
22222222
22222222
5
11111
11111
11111
11111
11111
22222222
22222222
225050505022
225050505022
225050505022
225050505022
22222222
22222222
210000000210000000
NotEnoughMemory!
西北农林科技大学本科课程考试试题（卷）
2014—2015学年《C语言程序设计》期末考试编程题（补考）
专业班级：
命题教师：
集体命题审题教师：
学生姓名：
学号：
考试成绩：
一、计算数列的和
描述：
数列的定义如下，数列的第一
升级会员 