2024-09-16
浏览量: 51
【题型】单选题
【题干】
C语言中(以16位PC机为例)，各数据类型的存储空间长度的排列顺序为（ ）。
【选项】
A.char＜int＜long＜=float＜double
B.char=int＜long＜=float＜double
C.char＜int＜long=float=double
D.char=int=long＜=float＜double
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列四组选项中,均不是C语言关键字的选项是（ ）。
【选项】
A.define IF type
B.getc char char
C.include scanf case
D.while go pow
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面四个选项中,均是不合法的用户标识符的选项是（ ）。
【选项】
A.A P_0 do
B.float la0 _A
C.b-a goto int
D._123 temp INT
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有int x=3,y=4,z=5;则下面表达式中值为0的是（ ）。
【选项】
A.'x'&&'y'
B. x＜=y
C. x||y+z&&y-z
D.!((x＜y)&&!z||1)
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下if语句语法正确的是（ ）。
【选项】
A.if(x＞0)printf("%f",x) else printf("%f",-x);
B.if(x＞0){x=x+y;printf("%f",x);} else printf("%f",-x);
C.if(x＞0){x=x+y;printf("%f",x);};else printf("%f",-x);
D.if(x＞0){x=x+y;printf("%f",x)} else printf("%f",-x);
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：int a[10];则对数组元素的正确引用是。 （ ）。
【选项】
A. a[10]
B. a[3,5]
C. a(5)
D. a[10-10]
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面是对s的初始化，其中不正确的是（ ）。
【选项】
A. char s[5]={"abc"};
B. char s[5]={'a','b','c'};
C. char s[5]="";
D. char s[5]="abcde";
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若使用一位数组名作为函数实参，则以下正确的说法是( )。
【选项】
A.必须在主调函数中说明此数组的大小
B.实参数组类型与形参数组类型可以不匹配
C.在被调函数中，不需要考虑形参数组的大小
D.实参数组名与形参数组名必须一致
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
else if(m＞a[mid]) 【2】;
else return(mid);
}
return(-1);
}（ ）。
【选项】
A. high=mid-1
B. high=mid+1
C. low=mid-1
D. low=mid+1
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下程序的正确运行结果是（ ）。
#include＜stdio.h＞
main()
{int k=4,m=1,p;
p=func(k,m); printf("%d,",p);
p=func(k,m); printf("%d"\n",p);
}
func(int a,int b)
{static int m=0,i=2;
i+=m+1;
m=i+a+b;
return(m);
}
【选项】
A. 8,17
B. 8,16
C. 8,20
D. 8,8
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若已定义a为int型变量，则（ ）是对指针变量p的正确说明和初始化。
【选项】
A. int *p=a；
B. int *p=*a；
C. int p=&a；
D. int *p=&a；
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下与库函数strcpy(char *s1, char *s2)功能不相等的函数是( )。
【选项】
A.funa(char *s1, char *s2) {while (*s1++=*s2++);}
B.funb(char *s1, char *s2) {while (*s2) s1++=s2++;}
C.func(char *s1, char *s2) {while (*s1=*s2) {s1++;s2++;}}
D.fund(char *s1, char *s2) {while ((*s1++=*s2++)!=’\0’); }
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
对for(表达式1; ;表达式3)可理解为( )。
【选项】
A.for (表达式1;0;表达式3)
B.for (表达式1;1;表达式3)
C.在for (表达式1;null;表达式
D.缺少一个表达式
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序，若a是数值类型，则逻辑表达式(a= =1)||(a!=1)的值是（ ）。
【选项】
A.1
B.0
C.2
D.不知道a的值，不能确定
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
成无限循环
若要定义一个具有4个元素的整型数组，以下错误的定义语句是
【选项】
A.int a[ 4 ] = { 0 } ;
B.int b[ ] = { 0,0,0,0 } ;
C.int c[ 1+3 ] ;
D.int i = 4 , d{ i };
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义：int x[10],*p=x;，以下能给数组x下标为6的元素读入数据的正确语句是
【选项】
A.scanf("%d",x[6]);
B.scanf("%d",*(x+6));
C.scanf("%d",p+6);
D.scanf("%d",p[6]);
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若变量已正确定义，在if(W) printf("%d\n",k);中，以下不可替代W的是__________
【选项】
A.a ＜＞ b+c
B.ch = getchar ( )
C.a==b+c
D.a++
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：int a=10;double b=3.14;，则表达式'A'+a+b值的类型是__________
【选项】
A.char
B.int
C.double
D.float
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：int k1=10,k2=20;，执行表达式(k1=k1＞k2)＆＆(k2=k2＞k1)后，k1和k2的值分别为__________
【选项】
A.0和1
B.0和20
C.10和1
D.10和20
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下程序段完全正确的是__________
【选项】
A.int *p ; scanf ( “ %d ” , & p) ;
B.int *p ; scanf( “ %d ” , p ) ;
C.int k , *p = &k ; scanf ( “%d” , p) ;
D.int k , *p ; *p = &k; scanf ( “ %d” ,p);
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义：struct {char mark[12];int num1;double num2;} t1,t2;，若变量均已正确赋初值，则以下语句中错误的是__________
【选项】
A.t1=t2;
B.t2.num1=t1.num1;
C.t2.mark=t1.mark;
D.t2.num2=t1.num2;
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义double a[10]，*s=a；，以下能够代表数组元素a[3]的是__________
【选项】
A.(*s)[3]
B.*(s+3)
C.*s[3]
D.*s+3
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序
#include ＜stdio. h ＞
#include ＜string. h ＞
main ( )
{ char x[ ] = "STRING";
x[0]=0 ; x[1] ='\0' ; x[2] = '0' ;
printf ( " %d %d\n " , sizeof(x) , strlen(x)) ;
}程序运行后的输出结果是_____________。
【选项】
A.6 1
B.7 0
C.6 3
D.7 1
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
为了避免嵌套的if-else语句的二义性，C语言规定else总是与____________组成配对关系。
【选项】
A.缩排位置相同的if
B.在其之前未配对的if
C.在其之前未配对的最近的if
D.同一行上的if
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是_________
【选项】
A.地址传递
B.单向值传递
C.由实参传给形参，再由形参传回实参
D.传递方式由用户指定
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
整型变量x和y的值相等且为非0值，则以下选项中，结果为零的表达式是__________
【选项】
A.x || y
B.x | y
C.x & y
D.x ^ y
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若x是单精度实型变量，表达式（x=10/4）的值是____________
【选项】
A.2.5
B.2.0
C.3
D.2
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下语句或语句组中，能正确进行字符串赋值的是____________
【选项】
A.char *sp; *sp="right!";
B.char s[10];s="right!";
C.char s[10]; *s="right!";
D.char *sp="right!";
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
调用strlen("abcd\0ef\ng\0")的结果为____________
【选项】
A.4
B.5
C.8
D.10
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义int a[3][4];，则正确定义一个指向a数组的行指针的语句是__________
【选项】
A.int **p;
B.int (*p)[4];
C.int (*p)[3];
D.int *p[4];
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】若有以下定义,则数值为4的表达式是 。
int w[3][4]={{0,1},{2,4},{5,8}},(*p)[4]=w;
【选项】
A. *w[1]+1
B. p++,*(p+1)
C. w[2][2]
D. p[1][1]
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列语句中，将c定义为文件型指针的是________。
【选项】
A. FILE c;
B. FILE *c;
C. file c;
D. file *c;
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是________。
【选项】
A.for(i=1,p=1;i＜=5;i++) p*=i;
B.for(i=1;i＜=5;i++) {p=1;p*=i;}
C.i=1;p=1;while(i＜=5){p*=i;i++;}
D.i=1;p=1;do{p*=i;i++;}while(i＜=5);
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
数学式
在C程序中正确的表示形式为_________。
【选项】
A.sqrt (a)/2*b
B.sqrt (a)/2/b
C.sqrt (a)/2b
D.sqrt a /(2*b)
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已知有预处理命令#include 和声明char s[10]= "Thank you"; int i;，要求输出字符串"Thank you"，以下选项中不能达到该要求的语句是____________。
【选项】
A.puts(s);
B.printf("%s", s[10]);
C.for(i=0;s[i]!= '\0';i++) printf("%c", s[i]);
D.for(i=0;s[i]!= '\0';i++) putchar(s[i]);
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
以下正确的 if 语句形式是（）。
【选项】
A.if (x>y && x!=y) ;
B. if (x==y) x+=y ;
C.if (x!=y) scanf("%d",&x) else scanf("%d",&y);
D. if (x<y) { x++; y++; }
E. if (x) printf("%d",x);
【答案】
B;D;E
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
关系表达式的结果可以有（）。
【选项】
A. 非0值
B. 1
C.0
D. true
E. false
【答案】
B;C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
关于数组说法正确的有（）。
【选项】
A. 数组的下标从0开始
B. 数组的各个元素在内存中是连续存放的
C.C编译系统对数组下标是否越界不做检查
D. C语言允许对整型数组名进行整体赋值
E.二维数组在内存中是按行存放的
【答案】
A;B;C;E
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
以下叙述正确的是（）。
【选项】
A. C语言严格区分大小写英文字母
B. 一个语句和数据声明的最后必须有一个";"
C.C程序书写格式自由,一行内可以写几个语句,一个语句也可以写在几行上
D. 可以使用/*…*/对C程序中的任何部分作注释
E.C语言是结构化程序设计语言
【答案】
A;B;C;D;E
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
若以下选项中的变量已正确定义,则不正确的赋值语句有（）。
【选项】
A. x1=26.8%3;
B. x=3*x+x;
C. x3=0x12;
D. x4=1+2=3;
E. x4=x3=3;
【答案】
A;D
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
使用const语句定义一个符号常量时，则必须对它同时进行初始化。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
假定二维数组的定义语句为“double a[M][N];”，则每个数组元素的行下标取值范围在1~M之间。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
已知“int a[10], *p=a;”，则进行p++运算是不允许的。
【答案】
F
【解析】
【难度】4
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一个函数定义中，参数表可以为空。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
对于不加static标识的局部变量，若没有对它进行初始化，则它的初值是不确定的。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一个链表中，表头结点和表尾结点均无前驱结点。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一个链表中，表头结点和表尾结点均无前驱结点。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言中，打开一个数据文件的系统函数为fopen()，它带有一个字符串参数，用来给定文件的打开方式。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
每次只能向文本文件中写入一个字符，不能一次写入一个字符串
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
关系表达式(x!=0)的等价表达式为(!x)。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
已知字母A的ASCII码为十进制数65,且c2为字符型,则执行语句c2='A'+'6'-'3';后,c2的值为（ ）。
【选项】
A.D
B.68
C.不确定的值
D. C
【答案】
A
【解析】
表达式中的各字符以各自的ASCII码参与运算。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
逻辑运算符两则运算对象的数据类型（ ）。
【选项】
A.只能是0或1
B.只能是0或非0正数
C.只能是整型或字符型数据
D.可以是任何类型的数据
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
能正确表示“当x的取值在[1,10]和[200,210]范围内为真”的C语言表达式为（ ）。
【选项】
A.(x＞=1)&&(x＜=10)&&(x＞=200)&&(x＜=210)
B.(x＞=1)&&(x＜=10)||(x＞=200)&&(x＜=210)
C.(x＞=1)||(x＜=10)||(x＞=200)||(x＜=210)
D.(x＞=1)||(x＜=10)&&(x＞=200)||(x＜=210)
【答案】
B
【解析】
C语言中实际上与运算和或运算优先级相等，由于C采用短路算法，所以不会影响B的结果,即不需要改成((x＞=1)＆＆(x＜=10))||((x＞=200) ＆＆(x＜=210))
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若运行时给变量输入12，则以下程序的运行结果是（ ）。
main()
{int x,y;
scanf("%d",&x);
y=x＞12?x+10:x-12;
printf("%d\n",y);
}
【选项】
A.0
B.22
C.12
D.10
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：static int a[3][4];则数组中各元素。（ ）。
【选项】
A.可在程序的运行阶段得到初值0
B.可在程序的编译阶段得到初值0
C.不能得到确定的初值
D.可在程序的编译或运行阶段得到初值0
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下正确的函数定义形式是 （ ）。
【选项】
A. double fun(int x,int y){z=x+y;return z;}
B. double fun(int x,y){int z;return z;}
C. fun(x,y){int x,y;double z; z=x+y; return z;}
D. double fun(int x,int y){double z;z=x+y;return z;}
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在一个C源程序文件中，若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是。（ ）。
【选项】
A. extern
B. register
C. auto
D. static
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若用数组名作为实参, 则传递给形参的是（ ）。
【选项】
A.数组首地址
B.数组第一个元素的值
C.数组元素的个数
D.数组中全部元素的值
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设p为指向结构体的指针，num为该结构体中的一个整型成员，y为一整型变量， y=++p-＞ num ; 与（ ）等价。
【选项】
A.+p；y=p-＞num
B. y=(++p)-＞num
C.++(p-＞num);y=p-＞num
D. y=p-＞num; ++y
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
当说明一个结构体类型变量时系统分配给它的内存是（ ）。
【选项】
A.各成员所需内存容量的总和；
B.结构体中第一个成员所需内存数；
C.成员中占内存量最大者所需的容量；
D.结构中最后—个成员所占内存量。
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有程序段 int k=10;
while(k=0) k=k-1;
则下面描述中正确的是（ ）。
【选项】
A. while循环执行10次
B.循环是无限循环
C.循环体语句一次也不执行
D.循环体语句执行一次
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的功能是计算正整数2345的各位数字平方和。（ ）。
#include "stdio.h"
main()
{int n,sum=0;
n=2345;
do {sum=sum+(?);
【选项】
A.n%10
B.(n%10)*(n%10)
C. n/10
D.(n/10)*(n/10);
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
n=(?);
} while(n);
printf("sum=%d",sum);}
【选项】
A.n/1000
B. b/100
C.n/10
D. n%10
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下正确的描述是（ ）。
【选项】
A. continue语句的作用是结束整个循环的执行。
B.只能在循环体内和switch语句体内使用break语句。
C.在循环体内使用break语句或continue语句的作用相同。
D.从多层循环嵌套中退出时，只能使用goto语句。
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序段（ ）。
for(t=1;t＜=100;t++)
{scanf("%d",&x); if(x＜0)continue; printf("%3d",t);
}
【选项】
A.当x＜0时整个循环结束
B. x＞=0时什么也不输出
C. printf函数永远也不执行
D.最多允许输出100个非负整数
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下关于C语言数据类型使用的叙述中错误的是__________
【选项】
A.若要准确无误差的表示自然数，应使用整数类型
B.若要保存带有多位小数的数据，应使用双精度类型
C.若要处理如“人员信息”等含有不同类型的相关数据，应自定义结构体类型
D.若只处理“真”和“假”两种逻辑值，应使用逻辑类型
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】若函数中有定义语句：int k则_____________。
【选项】
A.系统将自动给k赋初值0
B.这时k中的值无定义
C.系统将自动给k赋初值-1
D.这时k中无任何值
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下程序段完全正确的是______________。
【选项】
A.int *p ; scanf ("%d" , & p) ;
B.int *p ; scanf("%d" , p ) ;
C.int k , *p = &k ; scanf ("% d" , p) ;
D.int k , *p ; *p = &k; scanf ("%d" ,p);
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言程序的基本单位是____________
【选项】
A.程序行
B.语句
C.函数
D.字符
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
一个函数返回值的类型是由____________决定的
【选项】
A. return语句中表达式的类型
B.在调用函数时临时指定
C.定义函数时指定的函数类型
D.调用该函数的主调函数的类型
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义：int bb[ 8]；。则以下表达式中不能代表数组元bb[1]的地址的是__________
【选项】
A. &bb[0]+1
B. &bb[1]
C. &bb[0]++
D. bb+1
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若已定义int a=5; 下面对（1）、（2）两个语句的正确解释是（ ）。
(1) int *p=&a;
(2) *p=a;
【选项】
A. 语句（1）和（2）中的*p含义相同，都表示给指针变量p赋值。
B. (1)和(2)语句的执行结果，都是把变量a的地址值赋给指针变量p。
C. (1)在对p进行说明的同时进行初始化，使p指向a；(2)变量a的值赋给指针变量。
D. (1)在对p进行说明的同时进行初始化，使p指向a；(2)将变量a的值赋予*p。
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下不能定义为用户标识符的是_____________
【选项】
A. Main
B. _0
C. _int
D. sizeof
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下的定义、说明和语句，则值为101的表达式是________。
struct CW
{ int a;
int *b;
}*p;
int x0[]={11,12},x1[]={31,32};
struct CW x[2]={100,x0,300,x1};
p=x;
【选项】
A.*p-＞b
B.p-＞a
C.++(p-＞a)
D.(p++)-＞a
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中正确的是______
【选项】
A.在C程序中无论是整数还是实数，只要在允许范围内都能准确无误的表示
B.在C程序中只要是整数在允许范围内都能准确无误的表示
C.在C程序中只要是实数在允许范围内都能准确无误的表示
D.在C程序中无论是整数还是实数，都无法准确无误的表示
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中不正确的是________。
【选项】
A.在不同的函数中可以使用相同名字的变量
B.函数中的形式参数是局部变量
C.在一个函数内定义的变量只在本函数范围内有效
D.在一个函数内的复合语句中定义的变量在本函数范围内都有效
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下的说明和语句：
main()
{int t[3][2],*pt[3],k;
for(k=0;k＜3;k++)
pt[k]=t[k]; }
则以下选项中能正确表示t数组元素地址的表达式是____________。
【选项】
A.&t[3][2]
B.*pt[0]
C.*(pt[1])
D.&pt[2][0]
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
结构化程序设计的三种基本结构分别是（）。
【选项】
A.顺序结构
B.选择结构
C.重复结构
D.循环结构
E.跳转结构
【答案】
A;B;D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
设有语句float ave(int a[10]); float f; int w[10]; 则正确的函数调用形式是（）。
【选项】
A. f=ave(w[ ]);
B. f=ave(w);
C.f=ave(w[10]);
D. printf("%f",ave(w));
E.f=w(ave[ ]);
【答案】
A;B;C
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
C语言中合法的字符常量是（）。
【选项】
A. ‘\0xff’
B. ‘\65’
C.‘&’
D. ‘\27’
E. ‘\18’
【答案】
B;C;D
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
常数3.26f是单精度定点数。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言中，求一个整数的绝对值的数学函数为abs(x)。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
表达式x=x+1表示成增量表达式为x++。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
存储一个长度为0的空字符串至少需要占用1个字节的存储空间。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在定义指针变量的语句中，最前面的类型关键字仍然允许是指针类型。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言中，一个结构类型的长度等于所含的所有数据成员类型长度的最大值。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
一个C语言程序能够包含多个用户头文件。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
以下有关宏替换的叙述不正确的是（ ）。
【选项】
A.宏替换不占用运行时间
B.宏名无类型
C.宏替换只是字符替换
D.宏名必须用大写字母表示
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已知x=43,ch='A',y=0;则表达式(x＞=y＆＆ch＜'B'＆＆!y)的值是（ ）。
【选项】
A.0
B.语法错误
C.1
D."假"
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已知int x=10,y=20,z=30;以下语句执行后x,y,z的值是。
if(x＞y)
z=x;x=y;y=z; ( )。
【选项】
A.10,20,30
B.20,30,30
C.20,30,10
D.20,30,20
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
当a=1,b=3,c=5,d=4时，执行完下面一段程序后x的值是（ ）。
if(a＜b)
if(c＜d) x=1;
else
if(a＜c)
if(b＜d) x=2;
else x=3;
else x=6;
else x=3
【选项】
A.1
B.2
C.3
D.6
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有函数关系如下，能正确表示该关系的程序段是（ ）。
【选项】
A.y=x+1; if(x＞=0) if(x= =0) y=x; else y=x-1;
B. y=x-1; if(x!=0) if (x＞0) y=x+1; else y=x;
C. if (x＜=0) if (x＜0) y=x-1; else y=x; else y=x+1
D. y=x; if(x＜=0) if (x＜0) y=x-1; else y=x+1;
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下能对一维数组a进行正确初始化的语句是。（ ）。
【选项】
A. int a[10]=(0,0,0);
B. int a[10]={};
C. int a[2]={0,1,2};
D. int a[10]={10*1};
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：int a[3][4]={0};则下面正确的叙述是。（ ）。
【选项】
A.只有元素a[0][0]可以得到初值0
B.此说明语句不正确
C.数组中各元素都可以得到初值，但其值不一定为0
D.数组中每个元素均可得到初值0
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有语句组typedef int AR[5]；AR a；则以下叙述中正确的是（ ）。
【选项】
A. a是一个新类型
B. a是一个整型变量
C. a是一个整型数组
D. a是一个指针变量
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已有如下定义：
struct node
{int data;
struct node *next;
}*p,*q;
并已建立了如图所示的单向链表，p,q分别指向图中所示的结点，将q所指的结点插入到链表末尾组成单向链表，以下不能实现该功能的程序段是（ ）
【选项】
A.(*p).next=q; (*q).next=NULL;
B.q-＞next=p-＞next;p-＞next=q;
C.q-＞next=NULL;p-＞next=q;
D.p-＞next=q;q-＞next=p-＞next;
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有如下定义：struct sk {int a; float b; }data; int *p; 若要使p指向data中的a域，正确的赋值语句是（ ）。
【选项】
A. p=&a;
B. p=data.a;
C. p=&data.a;
D.*p=data.a
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的运行结果是。
main()
{int i,j,a=0;
for(i=0;i＜2;i++)
{for(j=0;j＜4;j++)
{if(j%2) break;
a++;
}
a++;
}
printf("%d\n",a);
}
【选项】
A. 4
B. 5
C. 6
D.7
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
if语句的基本形式是：if(表达式)语句，以下关于“表达式”值的叙述中正确的是（ ）。
【选项】
A.必须是逻辑值
B.必须是整数值
C.必须是正数
D.可以是任意合法的数值
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若i和k都是int类型变量，有以下for语句
for(i=0,k=-1;k=1;k++) printf("*****\n");
下面关于语句执行情况的叙述中正确的是
【选项】
A.循环体执行两次
B.循环体执行一次
C.循环体一次也不执行
D.构
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下定义：int a; long b; double x,y; 则以下选项中正确的表达式是__________
【选项】
A.a%(int)(x-y)
B.a = x != y;
C.(a*y)%b
D.y = x + y = x
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序(说明：字符0的ASCII码值为48)
#include＜stdio.h＞
main()
{ char c1,c2;
scanf("%d",&c1);
c2=c1+9;
printf("%c%c\n",c1,c2);} 若程序运行时从键盘输入48＜回车＞，则输出结果为__________
【选项】
A.09
B.10
C.0 9
D.1 0
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义：double a=22; int i=0，k=18;，则不符合C语言规定的赋值语句是__________
【选项】
A.a=a++,i++;
B.i=(a+k)＜=(i+k) ;
C.i=a％11;
D.i=!a;
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下数组声明语句中正确的是____________
【选项】
A.int n,a[n];
B.int a[];
C.int a[2][3]={{1},{2},{3}};
D. int a[][3]={{1},{2},{3}};
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义：int *p[3];，则以下叙述中正确的是_________
【选项】
A.定义了一个基类型为int的指针变量p，该变量具有3个指针
B.定义了一个指针数组p，该数组含有3个元素，每个元素都是基类型为int的指针
C.定义了一个名为*p的整型数组，该数组含有3个int类型元素
D.定义了一个可指向一维数组的指针变量p，所指一维数组应具有3个int类型元素
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中正确的是________。
【选项】
A.全局变量的作用域一定比局部变量的作用域范围大
B.静态（static）类别变量的生存期贯穿于整个程序的运行期间
C.函数的形参都属于全局变量
D.未在定义语句中赋初值的auto变量和static变量的初值都是随机值
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
putchar ( )函数可以向终端输出一个____________
【选项】
A.整型变量表达式值
B.实型变量值
C.字符串
D.字符常量或字符型变量值
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】设a,b为字符型变量，执行“scanf("a=%c,b=%c", &a , &b); ”后，使变量a的值为字母A，变量b的值为字母B，从键盘上正确的输入是_ 。
【选项】
A.AB
B.'A' , 'B'
C.A,B
D.a=A,b=B
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有声明“char a[5]={'A','B','C','D','E'}, *p=a, i ;”，则以下语句中不能正确输出a数组全部元素值的是________。
【选项】
A.for(i=0; i＜5; i++) printf( "%c ", a[i]);
B.for(i=0; i＜5; i++) printf( "%c ", *(a+i));
C.for(i=0; i＜5; i++) printf( "%c ", *p++);
D.for(i=0; i＜5; i++) printf( "%c ", *a++);
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中正确的是________。
【选项】
A.函数可以有参数也可以没有参数
B.函数既可嵌套定义又可递归调用
C.函数须有返回值，否则不能调用
D.主函数必须书写在子函数之前
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C语言中，形式参数不可以设置为_________类型。
【选项】
A.auto
B.register
C.register 或 auto
D. static
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义语句 int x[ ]={2, 4, 6, 8, 10}; int *p=＆x[4]; 则不能正确引用数组x的合法元素的表达式是_________。
【选项】
A.*(p--)
B.*(--p)
C.*(p++)
D.*(++p)
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
对基类型相同的指针变量不能进行的运算是____________。
【选项】
A.+
B.＞
C.=
D.==
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
printf函数中用到格式符%5s,其中数字5表示输出的字符串占用5列。如果字符串长度大于5,则输出按方式 （ ）；如果字符串长度小于5,则输出按方式 （ ）。
【选项】
A.从左起输出该字符串,右补空格
B.按原字符串长从左向右全部输出
C.右对齐输出该字符串,左补空格
D.输出错误信息
【答案】
B;C
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
下列关于“ switch(表达式) "语句说法正确的有（）。
【选项】
A. switch语句是多分支语句
B. switch后的(表达式) 的类型应为整数类型
C.switch语句中允许有一个default子句,也可以没有
D. switch语句中的每个case子句的常量表达式的值必须互不相同
E. switch语句中的每个case子句后面必须有break语句
【答案】
A;B;C;D
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言程序中，只有一种使用注释语句的方法。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一条变量定义语句中，当同时定义多个变量时，各变量之间只能使用逗号分开。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
return语句只有保留字，没有其他成分。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
break语句带有语句体。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一维数组的定义语句中，给数组赋初值的部分是用一对花括号括起来的数据序列。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
用于释放动态存储空间的函数为free，使用它需要带有一个参数。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在结构类型的定义中，其中的数据成员可以是本身类型的直接对象。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言中，打开一个数据文件的系统函数为fopen()，它带有两个字符串参数，用来给定文件名和打开方式。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
下面四个选项中,均是不合法的整型常量的选项是（ ）。
【选项】
A.--0f1 -0xffff 0011
B.-0Xcdf 017 12,456
C.-018 999 5e2
D.-0x48eg -068 03f
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设变量a是整型,f是实型,i是双精度型,则表达式10+'a'+i*f值的数据类型为（ ）。
【选项】
A. int
B. float
C. double
D.不确定
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下程序的输出结果是 （ ）。
printf("\n*s1=%15s*","chinabeijing");
printf("\n*s2=%-5s*","chi");
【选项】
A.*s1=chinabeijing□□□* *s2=**chi*
B.*s1=chinabeijing□□□* *s2=chi□□*
C.*s1=□□chinabeijing* *s2=□□chi*
D.*s1=□□□chinabeijing* *s2=chi□□*
【答案】
D
【解析】
数据左齐，右补空格。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
执行以下语句后a的值为，b的值为（ ）。
int a,b,c;
a=b=c=1;
++a||++b&&++c;
【选项】
A.0
B.1
C.2
D.错误
【答案】
C
【解析】
c语言在计算表达式时采用短路算法。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
为了避免在嵌套的条件语句if-else中产生二义性,C语言规定：else子句总是与配对。（ ）。
【选项】
A.缩排位置相同的if
B.其之前最近的没有else配对的if
C.其之后最近的if
D.同一行上的if
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面对C语言字符数组的描述中错误的是。( )。
【选项】
A.字符数组可以存放字符串
B.字符数组的字符串可以整体输入、输出
C.可以在赋值语句中通过赋值运算符对字符数组整体赋值
D.不可以用关系运算符对字符数组中的字符串进行比较
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的运行结果是。
#include＜stdio.h＞
main()
{char str[]="SSSWLIA",c;
int k;
for(k=2;(c=str[k])!='\0';k++)
{switch(c)
{case 'I':++k;break;
case 'L':continue;
default:putchar(c);continue;
}
putchar('*');
}
}（ ）。
【选项】
A. SSW*
B. SW*
C. SW*A
D. SW
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
当#include后面的文件名用＜＞括起时，寻找被包含文件的方式是（ ）。
【选项】
A.仅仅搜索当前目录
B.仅仅搜索当前目录
C.直接按系统设定的标准方式搜索目录
D.先在源程序所在目录搜索，再按系统设定的标准方式搜索
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有：int a[6]={4，5，6，7，8，9}，*p=a， *q=p; 则对数组元素的错误引用是（ ）。
【选项】
A. a[4]
B.*(p+4)
C.*q++
D.*a++
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若fp是指向某文件的指针，且已读到该文件的末尾，则C语言函数feof(fp)的返回值是（ ）。
【选项】
A.EOF
B.1
C.非零值
D.NULL
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的功能是把316表示为两个加数的和，使两个加数分别能被13和11整除。请选择填空（ ）。
#include ＜stdio.h＞
main()
{int i=0,j,k;
do
{i++;k=316-13*i;}while();
j=k/11;
printf("316=13*%d+11*%d",i,j);
}
【选项】
A.k/11
B. k%11
C.k/11==0
D. k%11==0
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的功能是将从键盘输入的偶数写成两个素数之和。请选择填空（ ）。
#include ＜stdio.h＞
#include ＜math.h＞
main()
{int a,b,c,d;
scanf("%d",&a);
for(b=3,b＜=a/2;b+=2)
{for(c=2;c＜=sqrt(b);c++) if(b%c==0) break;
if(c＞sqrt(b)) d=;else continue;
for(c=2;c＜=sqrt(d);c++) if(d%c==0) break;
if(c＞sqrt(d)) printf("%d=%d+%d\n",a,b,d);
}
}
【选项】
A. a+b
B. a-b
C. a*b
D. a/b
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的运行结果是（ ）。
#include＜stdio.h＞
main()
{int i;
for(i=1;i＜=5;i++)
{if(i%2) printf("*");
else continue;
printf("#");
}
printf("$\n");
}
【选项】
A.*#*#*#$
B.#*#*#*$
C.*#*#$
D.#*#*$
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序段
char name[20];
int num;
scanf("name=%s num=%d",name,&num);
当执行上述程序段，并从键盘输入：name=Lili num=1001＜回车＞后，name的值为
【选项】
A.Lili
B.name=Lili
C.Lili num=
D.name=Lili num=1001
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义int (*pt)[3]；，则下列说法正确的是( )。
【选项】
A.定义了基类型为int的三个指针变量
B.定义了基类型为int的具有三个元素的指针数组pt
C.定义了一个名为*pt、具有三个元素的整型数组
D.定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下语句
typedef struct S
{ int g; char h; } T ;
以下叙述中正确的是
【选项】
A.可用S定义结构体类型
B.可用T定义结构体变量
C.S是struct类型的变量
D.T是struct S类型的变量
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中错误的是
【选项】
A.C语言编写的函数源程序，其文件名后缀可以是.C
B.C语言编写的函数都可以作为一个独立的源程序文件
C.C语言编写的每个函数都可以进行独立的编译并执行
D.一个C语言程序只能有一个主函数
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下选项中关于C语言常量的叙述错误的是__________
【选项】
A.所谓常量，是指在程序运行过程中，其值不能被改变的量
B.常量分为整型常量、实型常量、字符常量和字符串常量
C.常量可分为数值型常量和非数值型常量
D.经常被使用的变量可以定义成常量
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下选项中，能用作用户标识符的是_____________。
【选项】
A.void
B.8_8
C._0_
D.unsigned
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】表达式：(int)((double)9/2)-(9)%2的值是_____________。
【选项】
A.0
B.3
C.4
D.5
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C语言中，char型数据在内存中的存储形式是_____________
【选项】
A.补码
B.反码
C.原码
D.ASCII码
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下语句：int b; char c[10]; ，则正确的输入语句是____________
【选项】
A.scanf(“%d%s”,&b,&c);
B. scanf(“%d%s”,&b,c);
C.scanf(“%d%s”,b,c);
D. scanf(“%d%s”,b,&c);
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下函数的类型是_________。
fun(float x)
{float y;
y=3*x-5.5;
return y;}
【选项】
A.int
B.不确定
C.void
D.float
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
把字符串"hello"赋给数组b的语句有（）。
【选项】
A.char b[10]={'h','e','l','l','o'};
B. char b[10];b="hello";
C.char b[10];strcpy(b,"hello");
D.char b[ ]="hello";
E.char b[4]={'h','e','l','l','o'};
【答案】
A;C;D
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在for循环语句的头部，for后面括号内共有2个表达式位置。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在定义指针变量的语句中，对指针变量可以赋初值。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言程序中，主函数也可以成为递归函数。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言字符集中，包含有全部26个英文大写字母和对应的小写字母。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
进行动态存储分配的calloc()函数带有一个参数。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在结构类型的定义中，结构类型名在关键字struct和定义体之间。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
若用数组名作为函数调用的实参，传递给形参的是（ ）。
【选项】
A.数组的首地址
B.数组第一个元素的值
C.数组中全部元素的值
D.数组元素的个数
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已有如下定义和输入语句，若要求a1,a2,c1,c2的值分别为10，20，A和B，当从第一列开始输入数据时，正确的数据输入方式是（ ）。
int a1,a2;char c1,c2;
scanf("%d%c%d%c",&a1,&c1,&a2,&c2);
【选项】
A.10A□20B＜CR＞
B.10□A□20□B＜CR＞
C.10□A20B＜CR＞
D.10A20□B＜CR＞
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：int a[][3]={1,2,3,4,5,6,7};则a数组第一维的大小是。（ ）。
【选项】
A.2
B.3
C.4
D.无法确定
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
建立函数的目的之一,以下正确的说法是（ ）。
【选项】
A.提高程序的执行效率
B.提高程序的可读性
C.减少程序的篇幅
D.减少程序文件所占内存
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中正确的是（ ）。
【选项】
A.在程序的一行上可以出现多个有效的预处理命令行
B.使用带参的宏时，参数的类型应与宏定义时的一致
C.宏替换不占用运行时间，只占用编译时间
D.以下定义中C R是称为宏名的标识符#define C R 045
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
当#include后面的文件名用""括起时,寻找被包含文件的方式是（ ）。
【选项】
A.直接按照系统设定的标准方式搜索目录
B.先在源程序所在目录搜索,再按照系统设定的标准方式搜索
C.仅仅搜索源程序所在目录
D.仅仅搜索当前目录
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设p1和p2是指向同一个int型一维数组的指针变量，k为int型变量，则不能正确执行的语句是（ ）。
【选项】
A. k=*p1+*p2;
B. p2=k;
C. p1=p2;
D. k=*p1 * (*p2);
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列程序的输出结果为（ ）。
main()
{ struct data
{ int year, month, day;
}today;
union
{ long i; int k; char ch;
}mix;
printf("%d,", sizeof(struct date));
printf("%d\n", sizeof(mix));
}
【选项】
A. 6,2
B. 6,4
C. 8,4
D.8,6
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言中的文件类型划分为（ ）。
【选项】
A.索引文件和文本文件两种
B. ASCII文件和二进制文件两种
C.只有文本文件一种
D.只有二进制文件一种
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下能正确计算10！的程序段是（ ）。
【选项】
A. do {i=1;s=1; s=s*i; i++; }while(i＜=10);
B. do{i=1;s=0; s=s*i; i++; }while(i＜=10);
C. i=1;s=1; do{s=s*i; i++; }while(i＜=10);
D. i=1;s=0; do{s=s*i; i++; }while(i＜=10);
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的运行结果是（ ）。
#include＜stdio.h＞
main()
{int a,b;
for(a=1,b=1;a＜=100;a++)
{if(b＞=20) break;
if(b%3==1){b+=3;continue;}
b-=5;
}
printf("%d\n",a);
}
【选项】
A. 7
B. 8
C. 9
D. 10
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下选项中不能用作C程序合法常量的是
【选项】
A.1.234
B.'123 '
C.123
D."\x7G"
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序
#include＜stdio.h＞
#define S(x) 4*x*x+1
main()
{ int k=5,j=2;
printf("%d\n",S(k+j));
}程序运行后的输出结果是（ ）。
【选项】
A.197
B.143
C.33
D.28
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：double a,*p=＆a;以下叙述中错误的是
【选项】
A.定义语句中的*号只是一个说明符
B.定义语句中的*号是一个地址运算符
C.定义语句中的p只能存放double类型变量的地址
D.定义语句中，*p=&a把变量a的地址作为初值赋给指针变量p
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：int a=3,b=2,c=1;，以下选项中错误的赋值表达式是__________
【选项】
A.a=(b=4)=3;
B.a=b=c+1;
C.a=(b=4)+c;
D.a=1+(b=c=4);
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】若要定义一个具有5个元素的整型数组，以下错误的定义语句是____________。
【选项】
A.int a[ 5 ] = { 0 } ;
B.int b[ ] = { 0,0,0,0,0 } ;
C.int c[ 2+3 ] ;
D.int i = 5 , d{ i };
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下关于return语句的叙述中正确的是______________。
【选项】
A.一个自定义函数中必须有一条return语句
B.一个自定义函数中可以根据不同情况设置多条return语句
C.定义成void类型的函数中可以有带返回值的return语句
D.没有retum语句的自定义函数在执行结束时不能返回到调用处
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列运算符中优先级最高的是____________
【选项】
A.＜
B.&&
C.+
D.!=
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C语言中，引用数组元素时，其数组下标的数据类型允许是________
【选项】
A.整型常量
B.整型表达式
C.整型常量或整型表达式
D.任何类型的表达式
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
算术运算符、赋值运算符和关系运算符的运算优先级按从高到低的顺序依次为_________
【选项】
A.算术运算、赋值运算、关系运算
B.关系运算、赋值运算、算术运算
C.算术运算、关系运算、赋值运算
D.关系运算、算术运算、赋值运算
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
函数返回值的类型应由 决定。
【选项】
A.return中的表达式类型
B.调用该函数的主调函数类型
C.定义函数所指定的类型
D.实参类型
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】为表示关系a≥b≥c，应使用的C语言表达式是 _ 。
【选项】
A.(a＞=b＞=c)
B.(a＞=b)AND(b＞=c)
C.(a＞=b)&&(b＞=c)
D.(a＞=b)&(b＞=c)
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下选项中错误的是_________。
【选项】
A.char a1[10]; a1="math";
B.char a2[ ]={'m','a','t','h'};
C.char a3[10]="math";
D.char *a4; a4="math";
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
下列语句正确初始化的是（）。
【选项】
A. char str[ ]="abcd";
B. char str[4]="abcd";
C.char str[4]={'a','b','c','d'};
D. char str[4]={97,98,99,100};
E. char str[]={97,98,99,100};
【答案】
A;C;D;E
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】多选题
【题干】
已定义c为字符型变量,则下列语句中错误的有（）。
【选项】
A. c=‘a’;
B. c="97";
C. c=97;
D. c="a";
E. c=780;
【答案】
B;D;E
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
假定a是一个一维数组，则进行a++运算是不允许的。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
当循环次数确定时，while循环语句能够转换为for循环语句。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
假定一个数据对象为int*类型，则指向该对象的指针类型为int**。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
设变量n为float,m为int类型,则以下能实现将n中的数值保留小数点后两位,第三位进行四舍五入的表达式是（ ）。
【选项】
A. n=(n*100+0.5)/100.0
B. m=n*100+0.5,n=m/100.0
C. n=n*100+0.5/100.0
D. n=(n/100+0.5)*100.0
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面有关for循环的正确描述是（ ）。
【选项】
A.for循环只能用于循环次数已经确定的情况
B.for循环是先执行循环体语句,后判断表达式
C.在for循环中,不能用break语句跳出循环体
D. for循环的循环体可以包括多条语句,但必须用花括号括起来
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列选项中，能够满足“若字符串s1等于字符串s2，则执行ST ”要求的是
【选项】
A.if ( strcmp( s2 , s1 ) ==0 ) ST ;
B.if ( s1 == s2 ) ST ;
C.if ( strcpy ( s1 , s2 ) == 1) ST ;
D.if ( s1 – s2 == 0 ) ST ;
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述正确的是
【选项】
A.C语言程序是由过程和函数组成的
B.C语言函数可以嵌套调用，例如：fun(fun(x))
C.C语言函数不可以单独编译
D.C语言中除了main函数，其他函数不可作为单独文件形式存在
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C语言中，if语句后的一对圆括号中，用以决定分支的流程的表达式____________
【选项】
A.只能用逻辑表达式
B.只能用关系表达式
C.只能用逻辑表达式或关系表达式
D.可用任意表达式
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在以下给出的表达式中,与do-while(E)语句中的（E）不等价的表达式是____________
【选项】
A.(!E==0)
B.(E＞0||E＜0)
C.(E==0)
D.(E!=0)
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：int a=2, *p=＆a, *q=p;，则以下非法的赋值语句是 （ ）。
【选项】
A. p=q;
B. *p=*q;
C. a=*q;
D. q=a
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
数字字符0的ASCII码值为48，以下程序运行后的输出结果是______
main()
{char a='1',b='2';
printf("%c,",b++);
printf("%d\n",b-a);
}
【选项】
A. 3,2
B. 50,2
C. 2,2
D.2,50
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
写出“m被n整除”的C语言表达式____________
【选项】
A.m%n=0
B.m/n=0
C.m%n= =0
D.m/n= =0
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列程序段的输出结果是__________
int i,x[3][3]={9,8,7,6,5,4,3,2,1},*p=&x[1][1];
for(i=0;i＜4;i+=2) printf("%d",*(p+i));
【选项】
A.5 2
B.5 1
C.5 3
D.9 7
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已定义ch为字符型变量，以下赋值语句中错误的是_________
【选项】
A. ch=’\’;
B. ch=62+3
C. ch=’\43’
D. ch=’\xaa’;
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下关于C语言语句的叙述中，正确的是________。
【选项】
A.所有语句都包含关键字
B.所有语句都必须在一行内书写完毕
C.所有语句都可以出现在源程序中的任何位置
D.复合语句由{}括住，且在复合语句中也可以定义变量
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下程序运行后的输出结果是_ 。
#include＜stdio.h＞
main()
{int a=1,b;
for(b=1;b＜=10;b++)
{if(a＞=8) break;
if(a%2==1){ a+=5;continue;}
a-=3;}
printf("%d\n",b);}
【选项】
A.3
B.5
C.6
D.4
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下是一个自定义函数的头部，其中正确的是________。
【选项】
A.int fun(int x[ ] , y)
B.int fun(int x[ ], int x)
C. int fun(int x[ ], int y)
D. int fun(char x[ ][ ],int y)
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
从函数定义角度来看，可以分为（）。
【选项】
A.库函数
B.有参函数
C.用户定义函数
D.无参函数
E.空函数
【答案】
A;C
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
表达式x=x+y表示成复合赋值表达式为x+=y。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
对于标识为static属性的变量，若没有对它进行初始化，则默认的初值为1。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在if语句中,必须带有else子句,不能省略它。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
sizeof(float)是（ ）。
【选项】
A.一个双精度型表达式
B.一个整型表达式
C.一种函数调用
D.一个不合法的表达式
【答案】
B
【解析】
算术表达式的类型由表达式计算结果的类型决定
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下能对二维数组a进行正确初始化的语句是。（ ）。
【选项】
A.Int a[2][]={{1,0,1}} {5,2,3}};
B. Int a[][3]={{1,2,3},{4,5,6}};
C.Int a[2][4]={{1,2,3},{4,5},{6}};
D. Int a[][3]={{1,0,1}{},{1,1}};
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序段的运行结果是。 char c[5]={'a','b','\0','c','\0'};
printf("%s",c);
（ ）。
【选项】
A.'a''b'
B. ab
C. ab c
D. ab▄（▄表示空格）
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序段的运行结果是。
char c[]="\t\v\\\0will\n";
printf("%d",strlen(c));
（ ）。
【选项】
A.3
B.6
C.9
D.14
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有下面程序段,上机运行,将。 char a[3],b[]="China";
a=b;
printf("%s",a);
（ ）。
【选项】
A.输出China
B.输出Chi
C.输出Ch
D.编译出错
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言允许函数值类型缺省定义，此时该函数值隐含的类型是（ ）。
【选项】
A. float型
B. int型
C. long型
D. double型
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下正确的描述是（ ）。
【选项】
A.函数的定义可以嵌套,但函数的调用不可以嵌套
B.函数的定义不可以嵌套,但函数的调用可以嵌套
C.函数的定义和函数的调用均不可嵌套
D.函数的定义和函数的调用均可以嵌套
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下定义，则正确的赋值语句为（ ）
struct complex
{ float real;
float image;
};
struct value
{ int no;
struct complex com;
}val1;
【选项】
A. com.real=1;
B.val1.complex.real=1;
C. val1.com.real=1;
D. val1.real=1;
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的功能是将从键盘输入的一对数，由小到大排序输出。当输入一对相等数时结束循环，请选择填空。
#include ＜stdio.h＞
main()
{int a,b,t;
scanf("%d%d",&a,&b);
while()
{if (a＞b)
{t=a;a=b;b=t;}
printf("%d,%d\n",a,b);
scanf("%d%d",&a,&b);
}
}
（ ）。
【选项】
A.!a=b
B. a!=b
C. a==b
D. a=b
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下描述正确的是（ ）。
【选项】
A. goto语句只能用于退出多层循环。
B. switch语句中不能出现continue语句。
C. 只能用continue语句来中止本次循环。
D.在循环中break语句不能独立出现。数
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下程序运行后的输出结果是__________
# include ＜ stdio.h ＞
main ( )
{ int a = 200 , b = 010 ;
printf ( " %d %d \n" , a , b ) ;}
【选项】
A.200 8
B.200 9
C.200 10
D.200 11
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下关于C语言的叙述中正确的是__________
【选项】
A.C语言中的注释不可以夹在变量名或关键字的中间
B.C语言中的变量可以在使用之前的任何位置进行定义
C.在C语言算术表达式的书写中，运算符两侧的运算数类型必须一致
D.C语言的数值常量中夹带空格不影响常量值的正确表示
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】有以下定义语句，编译时会出现编译错误的是_____________。
【选项】
A.char a=’a’;
B.char a=’\n’;
C.char a=’aa’;
D.char a=’\x2d’;
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下选项中与if(a= =1)a=b；else a++；语句功能不同的switch语句是______________。
【选项】
A.switch(a);{case1:a=b;break;default : a++;}
B.switch(a==l),{case 0:a=b;break;case l:a++;}
C.switch(a);{default:a++;break;ase l:a=b; }
D.switch(a==l);{case l:a=b;break;case 0:a++;}
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面叙述中正确的是__________
【选项】
A.带参数的宏定义中参数是没有类型的
B.宏展开将占用程序的运行时间
C.宏定义命令是C语言中的一种特殊语句
D.使用#include命令包含的头文件必须以“.h”为后缀
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
不能把字符串"Hello!"赋给数组b的语句是______
【选项】
A.char b[10]={ 'H', 'e', 'l', 'l', 'o', '! ', '\0'};
B.char b[10]; b="Hello! ";
C.char b[10]; strcpy(b, "Hello! ");
D.char b[10]= "Hello! ";
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有如下定义：struct T{int n; double x;}d,*p;，下列语句中正确的是__________
【选项】
A. d-＞n=10;
B. p=&d;
C. p=&d.n;
D. d-＞x=10;
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有数组A和B的声明“static char A[ ]="ABCDEF"，B[ ]={'A','B','C','D','E','F'}; ”，则数组A和数组B的长度分别是____________
【选项】
A.7，6
B.6，7
C.6，6
D.7，7
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
对下面三条语句（其中s1和s2为内嵌语句），正确的论断是________。
【选项】
A.三者相互等价
B.1和2等价，但与三不等价
C.三者互不等价
D.1和3等价，但与2不等价
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】多选题
【题干】
以下叙述中正确的是（）。
【选项】
A.一个C源程序可由一个或多个函数组成
B.一个C源程序必须包含一个main()函数
C.C源程序的基本组成单位是函数
D.在C源程序中,注释说明只能位于一条语句的最后
E.C源程序的扩展名为.c
【答案】
A;B;C;E
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
若要在程序文件中使用标准输入和输出函数，则需要引入的系统头文件为stdio.h。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
表达式x=x+y表示成复合赋值表达式为x=+y。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在结构成员访问运算符中，点运算符和箭头运算符的左边均为结构指针变量。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在定义一个变量时，不能给它赋初值。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一维数组的定义语句中，数组名后带有一对圆括号。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在结构成员访问运算符中，点运算符(.)为双目运算符。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
C语言中的标识符只能由字母、数字和下划线三种字符组成，且第一个字符（ ）。
【选项】
A.必须为字母
B.必须为下划线
C.必须为字母或下划线
D.可以是字母、数字和下划线中的任一种字符
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
putchar函数可以向终端输出一个（ ）。
【选项】
A.整型变量表达式
B.实型变量值
C.字符串
D.字符或字符型变量值
【答案】
D
【解析】
putchar函数的作用是输出一个字符,可以是常量或变量。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设形参和实参都为int类型变量，以下正确的说法是（ ）。
【选项】
A.实参和与其对应的形参占用独立的存储单元
B.实参和与其对应的形参共占用一个存储单元
C.只有当实参和与其对应的形参同名时才共占用一个存储单元
D.形参是虚拟的,不占用存储单元
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的运行结果是（ ）。
#include＜stdio.h＞
main()
{int i;
for(i=1;i＜=5;i++)
switch(i%5)
{case 0:printf("*");break;
case 1:printf("#");break;
default:printf("\n");break;
case 2:printf("&");
}
}
【选项】
A.#&&*
B.#&
C.#
D.#&
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
if((?))printf("x=%d,y=%d,z=%d\n",x,y,z);
}
}
【选项】
A.i/result==1
B. i=result
C. i!=result
D. i==result
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下C语言用户标识符中，不合法的是
【选项】
A. _1
B. AaBc
C. a_b
D. a—b
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
s1和s2已正确定义并分别指向两个字符串。若要求：当s1所指串大于s2所指串时，执行语句S；则以下选项中正确的是__________
【选项】
A.if(s1＞s2)S;
B.if(strcmp(s1,s2))S;
C. if(strcmp(s2,s1)＞0)S;
D. if(strcmp(s1,s2)＞0)S;
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有结构体类型定义“typedef struct test{int x, y[2];}TEST ; ”，则以下声明中正确的是_________。
【选项】
A.struct TEST x;
B.struct x;
C.test x;
D.TEST x;
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】判断题
【题干】
假定二维数组的定义语句为“double a[M][N];”，则每个数组元素的列下标取值范围在0~N-1之间。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
判断char型变量ch是否为大写字母的正确表达式为。（ ）。
【选项】
A.'A'＜=ch＜='Z'
B.(ch＞='A')&(ch＜='Z')
C.(ch＞='A')&&(ch＜='Z')
D.('A'＜=ch)AND('Z'＞=ch)
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下程序的输出结果是（ ）。
main()
{int x=2,y=-1,z=2;
if(x＜y)
if(y＜0) z=0;
else z+=1;
printf("%d\n",z);
}
【选项】
A.3
B.2
C.1
D.0
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明：int a[3][4];则对a数组元素的非法引用是（ ）。
【选项】
A. a[0][2*1]
B. a[1][3]
C. a[4-2][0]
D. a[0][4]
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列条件编译中xxx可表示为（ ）。
#xxx 标识符
程序段1
#else
程序段2
#endif
【选项】
A. define或include
B. ifdef或include
C. ifdef或ifndef或define
D. ifdef或ifndef或if
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
如果要以只读方式打开一个文本文件，应使用的打开方式是（ ）。
【选项】
A.r+
B.w
C.r
D.rb
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言中while和do while循环的主要区别是（ ）。
【选项】
A. do-while的循环至少无条件执行一次。
B. while循环控制条件比do-while的循环控制条件严格。
C. do-while允许从外部转入到循环体内。
D. do-while的循环体不能是复合语句。
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
a的值为5，表达式 a + = a - = a = 9的值是（ ）。
【选项】
A.9
B.–9
C.18
D.0
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：int year=2009,*p=＆year;，以下不能使变量year中的值增至2010的语句是（ ）。
【选项】
A.*p+=1;
B.( *p)++;
C.++(*p);
D.*p++;
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义：int a,b;，通过语句scanf("%d,%d",＆a,＆b);，能把整数3赋给变量a，5赋给变量b的输入数据是__________
【选项】
A.3 5
B.3，5
C.3;5
D.35
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在函数调用中，如果函数funA调用了函数funB，函数funB又调用了函数funA，则______
【选项】
A. 称为函数的直接递归调用
B. 称为函数的间接递归调用
C. 称为函数的循环调用
D. C语言中不允许这样的递归调用
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
标准库函数fputs(p1,p2)的功能是________。
【选项】
A. 从p1指向的文件中读一个字符串存入p2指向的内存空间
B. 从p2指向的文件中读一个字符串存入p1指向的内存空间
C. 从p1指向的内存空间中读一个字符串存入p2指向的文件
D. 从p2指向的内存空间中读一个字符串存入p1指向的文件
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】判断题
【题干】
在for循环语句的头部，for后面括号内的各表达式之间使用空格隔开。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
字符串允许为空，并且其长度为0。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一个函数定义中，参数表中的参数类型可以为void类型。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
以下叙述正确的是（ ）。
【选项】
A.在C程序中,main函数必须位于程序的最前面
B.在C程序的每一行只能写一条语句
C. C语言本身没有输入输出语句
D.在对一个C程序进行编译的过程中,可发现注释中的拼写错误
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C语言中,要求运算数必须是整型(数)的运算符是 （ ）。
【选项】
A./
B.++
C.!=
D.%
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已有程序段和输入数据的形式，程序中输入语句的正确形式应当为（ ）。
main()
{ int a;float f;
printf("Input number:");
(输入语句)
printf("\nf=%f,a=%d\n",f,a);
}
Input number:4.5□□2＜CR＞
【选项】
A.scanf("%d,%f",&a,&f);
B.scanf("%f,%d",&f,&a);
C.scnaf("%d%f",&a,&f);
D.scanf("%f%d",&f,&a);
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式是（ ）。
【选项】
A.地址传递
B.单向值传递
C.由实参传给形参，再由形参传回实参
D.由用户指定传递方式
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言规定,函数返回值的类型是由所决定（ ）。
【选项】
A. return语句中的表达式类型
B.调用该函数时的主调函数类型
C.调用该函数是系统临时指定
D.在定义该函数时所指定的函数类型
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
如果在一个复合语句中定义了一个变量,则有关该变量正确的说法是。（ ）。
【选项】
A.只在该复合语句中有效
B.只在该函数中有效
C.在本程序范围内均有效
D.为非法变量
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下程序的正确运行结果是（ ）。
#include＜stdio.h＞
void num()
{extern int x,y;
int a=15,b=10;
x=a-b;
y=a+b;
}
int x,y;
main()
{int a=7,b=5;
x=a+b;
y=a-b;
num();
printf("%d,%d\n",x,y);
}
【选项】
A.12,2
B.12,25
C.12,25
D.5,2
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下说明和语句：int a[10]，*p1， *p2； p1=a； p2=＆a[5]；则p2-p1的值为 （ ）。
【选项】
A.5
B.6
C.10
D.没有指针与指针的减法
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
循环体语句执行一次（ ）。
【选项】
A. E= =0
B. E!=1
C. E!=0
D. E= =1
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下选项中正确的语句组是________________。
【选项】
A.char s[];s="BOOK!";
B.char *s;s={"BOOK!"};
C.char s[10];s="BOOK!";
D.char *s;s="BOOK!";
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C程序中调用函数时，主调函数中的实参和被调函数中的形参____________
【选项】
A.个数、次序必须相同，但数据类型可以不考虑。
B.个数、次序必须相同，对应参数的数据类型应相同或赋值相容。
C.个数、次序和数据类型均可以不相同。
D.对应参数数据类型应相同，但个数和次序可以不考虑。
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
函数调用“strcat(strcpy(str1,str2),str3)”的功能是________。
【选项】
A.将字符串str1复制到字符串str2中后再连接到字符串str3之后
B.将字符串str1连接到字符串str2之后再复制到字符串str3之后
C.将字符串str2复制到字符串str1中后再将字符串str3连接到字符串str1之后
D.将字符串str2连接到字符串str1之后再将字符串str1复制到字符串str3中
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有声明“long fun(int *x, int n, long *s); int a[4]={1,2,3,4}; long b, c;”，则以下函数调用形式中正确的是 （ ）。
【选项】
A.c=fun(a,4,b);
B.c=fun(a[ ],4,&b);
C.c=fun(a[4],4,b);
D.c=fun(a,4,&b);
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】判断题
【题干】
在for循环语句的头部，for后面括号内的各表达式之间使用逗号分开。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一维数组的定义语句中，给数组赋初值的部分是用一对圆括号括起来的数据序列。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在函数定义中，若存在着调用自身函数的函数调用表达式，则称此函数为非递归函数。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
当向字符文件输出一个换行符时，实际将输出的是回车和换行这两个字符。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
当需要在程序文件中引入系统头文件时，不需要使用#include命令。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
常数3.126f是双精度浮点数。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一条变量定义语句中，只能定义同一类型的变量。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
do-while循环语句是以分号结束的语句。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一维数组的定义语句中，可以给数组中每个元素赋初值。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
一个二维字符数组a[10][20]中存储每个字符串的最大长度为20。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
假定a是一个一维数组，则数组名a的值和＆a[0]的值相等。
【答案】
T
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
定义结构类型的同时能够定义它的变量。
【答案】
T
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一个链表的结点结构中，存在着一个指针域，但不一定指向自身结点类型。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在一维数组的定义语句中，数组名后带有一对圆括号。
【答案】
F
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【题型】判断题
【题干】
在C语言中，在定义一个字符数组时，不能利用一个字符串进行初始化。
【答案】
F
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【题型】单选题
【题干】
有定义：int a[10],n, *p1=a,*p2=＆a[9]; 则正确且有意义的赋值语句为 （ ）。
【选项】
A.n=p2-p1;
B.n=p2*p1;
C.n=p2+p1;
D.n=p1/p2;
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有定义：int a=1,b=2,c=3;,以下语句中执行效果与其它三个不同的是 （ ）。
【选项】
A.if (a＞b) c=a,a=b,b=c;
B.if (a＞b){c=a,a=b,b=c;}
C.if(a＞b) c=a;a=b;b=c;
D.if(a＞b){c=a;a=b;b=c;}
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
一个C程序的执行是从（ ）。
【选项】
A.本程序的main函数开始,到main函数结束
B.本程序文件的第一个函数开始,到本程序文件的最后一个函数结束
C.本程序的main函数开始,到本程序文件的最后一个函数结束
D.本程序文件的第一个函数开始,到本程序main函数结束
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述不正确的是（ ）。
【选项】
A.一个C源程序可由一个或多个函数组成
B.一个C源程序必须包含一个main函数
C.C程序的基本组成单位是函数
D.在C程序中,注释说明只能位于一条语句的后面
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若x、i、j和k都是int型变量,则计算下面表达式后,x的值为 x=(i=4,j=16,k=32)（ ） 。
【选项】
A.4
B.16
C.32
D.52
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面正确的字符常量是（ ）。
【选项】
A."c"
B.'\\''
C.'W'
D.""
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若二维数组a有m列，则计算任一元素a[i][j]在数组中位置的公式为（假设a[0][0]位于数组的第一个位置上）。（ ）。
【选项】
A. i*m+j
B. j*m+i
C. i*m+j-1
D. i*m+j+1
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下定义和语句：
struct student
{int age；int num；};
struct student stu[3]={{1001,20},{1002,19},{1003,21}};
main()
{struct student *p；
p=stu; ...
}
则以下不正确的引用是（ ）
【选项】
A.(p++)-＞num
B. p++
C.(*p).num
D. p=&stu.age
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若磁盘上已存在某个文本文件，其全路径文件名为c:\c\data.txt，下列语句中不能打开文件的是（ ）。
【选项】
A.FILE *in；in=fopen("c:\c\data.txt"，"r")；
B.FILE *in；in=fopen("c:\\c\\data.txt"，"r")；
C.FILE *in；in=fopen("c:\\c\\data.txt"，"a+")；
D.FILE*in；in=fopen("c:\\c\\data.txt"，"r+")；
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
C语言标准库函数fread(fd,buffer,n)的功能是（ ）。
【选项】
A.从文件fd中读取长度不超过n个字节的数据送入buffer指向的内存区域
B.从文件fd中读取长度不超过n-1个字节的数据送入buffer指向的内存区域
C.从文件fd中读取长度不超过n个字符送入buffer指向的内存区域
D.从文件fd中读取长度不超过n-1个字符送入buffer指向的内存区域
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下描述中正确的是（ ）。
【选项】
A.由于do-while循环中循环体语句只能是一条可执行语句，所以循环体内不能使用复合语句。
B. do-while循环由do开始,用while结束，在while(表达式)后面不能写分号。
C.在do-while循环体中，一定要有能使while后面表达式的值变为零("假")的操作。
D. do-while循环中，根据情况可以省略while。
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序
# include ＜ stdio.h ＞
main ( )
{ int y = 10 ;
while ( y-- ) ;
printf ( " y= %d\n " , y ) ;
}
程序执行后的结果是
【选项】
A.y = 0
B.y = -1
C.y = 1
D.while构成无限循环
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中错误的是__________
【选项】
A.C程序在运行过程中所有计算都以二进制方式进行
B.C语言在运行过程中所有计算都以十进制方式进行
C.所有C程序都需要编译链接无误后才能运行
D.C程序中整型变量只能存放整数，实型变量只能存放浮点数
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义语句：int x=12,y=8,z;，在其后执行语句z=0.9+x/y；，则z的值为__________
【选项】
A.1．9
B.1
C.2
D.2．4
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列条件语句中，输出结果与其他语句不同的是__________
【选项】
A.if(a)printf("%d\n",x); else printf("%d\n",y);
B.if(a==0)printf("%d\n",y); else printf("%d\n",x);
C.if(a!=0)printf("%d\n",x); else printf("%d\n",y);
D.if(a==0)printf("%d\n",x); else printf("%d\n",y);
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】若有以下定义 int x[10], *pt=x;则对x数组元素的正确引用是____________。
【选项】
A.*&x[10]
B.*(x+3)
C.*(pt+10)
D.pt+3
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】以下不能将s所指字符串正确复制到t所指存储空间的是______________。
【选项】
A.while ( *t = *s ) { t++ ; s++ ; }
B.for ( i = 0 ; t[ i ] = s[ i ] ; i++ ) ;
C.do { *t++ = *s++ ;} while ( *s ) ;
D.for ( i = 0 ,j = 0 ; t[ i ++ ] = s[ j ++ ] ;) ;
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
正确的C语言标识符是__________
【选项】
A.buy_2
B.2_buy
C.?_buy
D.buy?
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有说明语句：int a, b, c, *d=＆c；，则能正确从键盘读入三个整数分别赋给变量a、b、c的语句是__________
【选项】
A. scanf("%d%d%d", &a, &b, d);
B. scanf("%d%d%d", a, b, d);
C. scanf("%d%d%d", &a, &b, &d);
D. scanf("%d%d%d", a, b,*d)
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已知：char s[4]= "cha"; char *p; 执行语句p=s; printf("%c",*p+1);后，其输出为__________
【选项】
A. c
B. b
C. h
D. d
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面函数的类型是_________
ff(float x)
{printf(“%d\n”,x*x);}
【选项】
A.与形参x的类型相同
B.void类型
C.int类型
D.无法确定
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列数据中属于“字符串常量”的是_____________
【选项】
A.Tom
B."Tom"
C.'tom'
D.'T'
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
int a=1,b=2,c=3,d=4,m=2,n=2,e; 则执行语句e =(m=a＞b)＆＆(n=c＞d);后，m、n的值分别为________
【选项】
A.2,2
B.2,0
C.0,2
D.0,0
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列说法中错误的是________。
【选项】
A.构成数组的所有元素的数据类型必须相同
B.一维数组元素的下标从1开始
C.引用数组元素时下标越界不报错，但下标越界的元素的值不确定
D.数组元素的下标可以是整型表达式
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下关于运算符优先顺序的描述中正确的是 （ ）。
【选项】
A.关系运算符＜算术运算符＜赋值运算符＜逻辑运算符
B.逻辑运算符＜关系运算符＜算术运算符＜赋值运算符
C.赋值运算符＜逻辑运算符＜关系运算符＜算术运算符
D.算术运算符＜关系运算符＜赋值运算符＜逻辑运算符
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下不能将s所指字符串正确复制到t所指存储空间的是
【选项】
A.while ( *t = *s ) { t++ ; s++ ; }
B.for ( i = 0 ; t[ i ] = s[ i ] ; i++ ) ;
C.do { *t++ = *s++ ;} while ( *s ) ;
D.for ( i = 0 ,j = 0 ; t[ i ++ ] = s[ j ++ ] ;) ;
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下选项中能表达合法常量的是__________
【选项】
A.整数：1,200
B.实数：1.5E2.0
C.字符斜杠：’\’
D.字符串：”\007”
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列定义数组的语句中，正确的是__________
【选项】
A.int N = 10 ;int x[ N ] ;
B.#define N 10,int x[ N ] ;
C.int x[ 0..10 ] ;
D.int x[ ] ;
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有以下程序，其中k的初值为八进制数
#include ＜stdio. h＞
main ( )
{ int k=011;
printf ("%d\n", k++);
}程序运行后的输出结果是_____________。
【选项】
A.12
B.11
C.10
D.9
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下关于语句的说法中，正确的是____________
【选项】
A.do-while 语句的循环体至少会被执行1次
B.while语句的循环体至少会被执行1次
C.for语句的循环体至少会被执行1次
D.break语句只能出现在循环语句中
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
a=3,b=4，执行“printf("%d,%d",(a,b),(b,a));”的输出是________。
【选项】
A.3, 4
B.4, 3
C.3, 3
D.4, 4
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若x,y均定义为int型，z定义为double型，以下不合法的scanf函数调用语句是（ ）。
【选项】
A.scanf("%d%lx,%le",&x,&y,&z);
B.scanf("%2d*%d%lf",&x,&y,&z);
C.scanf("%x%*d%o",&x,&y;
D.scanf("%x%o%6.2f",&x,&y,&z);
【答案】
D
【解析】
首先读第一个十进制数赋给变量x,读第二个长十六进制数赋给变量y(此时有自动赋值转换),再读入格式规定的第二和第三个数据间的间隔符号逗号，最后读入第三个double型数据赋给变量z。B)首先读入2个宽度的十进制数赋给变量x,再读入格式规定的第一和第二数据间的间隔符号星号，然后读入第二个十进制整数赋给变量y，然后读入第三个double型数据赋给变量z。C)读入第一个十六进制数赋给变量x,然后虚读一个十进制数不赋给任何变量，最后读入一个八进制数赋给变量y。D)％6.2f不符合格式规定，即不能规定读入数据的小数点后的数字位数。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面程序的功能是求算式xyz+yzz=532中x,y,z的值（其中xyz和yzz分别表示一个三位数），请选择填空。
#include＜stdio.h＞
main()
{int x,y,z,i,result=532;
for(x=1;x＜10;x++)
for(y=1;y＜10;y++)
for((?);z＜10;z++) {i=100*x+10*y+z+100*y+10*z+z;
【选项】
A.z=x
B.z=1
C. z=0
D. z=y
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有定义：int a=7; float x=2.5,y=4.7;则表达式x+a%3*(int)(x+y)%2/4的值是( )。
【选项】
A.2.500000
B.2.750000
C.3.500000
D.0.000000
【答案】
A
【解析】
计算时要注意其结合性和优先级。
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有下列程序段，则scanf函数调用语句中对结构体变量成员的不正确引用为（ ）。
struct student
{ char name[20];
int age;
char sex;
}stu[5], *p;
p=stu;
【选项】
A.scanf("%s",stu[0].name);
B.scanf("%d",p-＞age;
C.scanf("%c",&(p-＞sex));
D.scanf("%d",&stu[0].age);
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下列语句组中，正确的是
【选项】
A.char *s;s="china";
B.char s[7] ;s="Olympic";
C.char *s;s={};
D.char s[7] ;s={"Olympic"};
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
已有定义语句int *p；以下能动态分配一个整型存储单元，并把该单元的首地址正确赋值给指针变量p的语句是（ ）。
【选项】
A.*p=(int *)malloc(sizeof(int));
B. p=(int *)malloc(sizeof(int));
C. p=* malloc(sizeof(int));
D. free(p);
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下是if语句的基本形式
if(表达式) 语句其中“表达式”______________。
【选项】
A.必须是逻辑表达式
B.必须是关系表达式
C.必须是逻辑表达式或关系表达式
D.可以是任何合法的表达式
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面函数调用语句含有实参的个数为 fun((exp1,exp2),(exp3,exp4,exp5));
（ ）。
【选项】
A.1
B.2
C.4
D.5
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下函数binary的作用是应用折半查找法从存有10个整数的a数组中对关键字m进行查找，若找到，返回其下标值；反之，返回-1。请选择填空（ ）。
int binary(int a[],int m)
{int low=0,high=9,mid;
while(low＜=high)
{mid=(low+high)/2;
if(m＜a[mid]) 【1】;
【选项】
A. high=mid-1
B. high=mid+1
C. low=mid-1
D. low=mid+1
【答案】
A
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若有以下说明和语句：int a[10]， *p1， *p2；p1=a；p2=＆a[5]；则以下不正确的表达式是（ ）。
【选项】
A. p1=p2
B. p1=p2
C. p2-p1
D. a=p2-3
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
以下叙述中不正确的是（ ）。
【选项】
A.预处理命令都必须以#开始
B.在C程序中凡是以#开始的语句行都是预处理命令行
C.C程序在执行过程中对预处理命令行进行处理
D.以下是正确的宏定义 #define IBM_PC
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
有一堆零件（100到200之间），如果分成4个零件一组则多出2个零件；若分成7个零件一组，则多3个零件；若分成9个零件一组，则多出5个零件。下面程序是求这堆零件总数，请选择填空( )。
#include ＜stdio.h＞
main()
{int i;
for(i=100;i＜200;i++)
if((i-2)%4==0)
if(!((i-3)%7))
if()
printf("%d",i);
}
【选项】
A. i%9=5
B. i%9!=5
C.(i-5)%9!=0
D. i%9==5
【答案】
D
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
main()
{int x=1,y=2;
printf("x=%d y=%d *sum*=%d\n",x,y,x+y);
printf("10 Squared is :%d\n",10*10);
}
【答案】
x=1 y=2 *sum*=3 10 Squared is :100;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若a和b均为int型变量，则以下语句的功能是_________。
a+=b;b=a-b;a-=b;
【答案】
交换a、b变量的值;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若int a=6,b=4,c=2;表达式!(a-b)+c-1＆＆b+c/2的值是_________。
【答案】
1;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若a=2,b=4,则表达式!(x=a)||(y=b)＆＆0的值是_________。
【答案】
0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是_________。
main()
{if (2*2==5＜2*2==4)
printf("T");
else
printf("F");
}
【答案】
F;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序实现输出x,y,z三个数中的最大者。请分析程序填空。
main()
{int x=4,y=6,z=7;;
int_________;
if(_________) u=x;
else u=y;
if (_________) v=u;
else v=z;
printf("v=%d",v);
}
【答案】
u,v;x＞y;u＞z;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
输入一个字符，如果它是大写字母，则把它变成小写字母，如果它是一个小写字母，则把它变成大写字母，其它字符不变。请分析程序填空。
main()
{char ch;
scanf("%c",&ch);
if(_________) ch=ch+32;
else if(ch＞='a'&&ch＜='z') _________;
printf("%c",ch);
}
【答案】
ch＞='A'＆＆ch＜='Z';ch=ch-32;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】下面程序根据以下函数关系，对输入的每个x值，计算出y值。请分析程序填空。
#include ＜math.h＞
main()
{int x,a;
float y;
scanf("%d %d",&x,&a);
if(_________) y=0;
else if(_________) y=sqrt(a*a-x*x);
else y=x;
printf("%f",y);
}
【答案】
x==-a||x==a;x＞-a＆＆x＜a;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是计算一元二次方程ax2+bx+c=0的根，请分析程序填空。
#include ＜math.h＞
main()
{float a,b,c,t,disc,twoa,term1,term2;
printf("Enter a,b,c:");
scanf("%f %f %f",&a,&b,&c);
if(_________)
if(_________) printf("no answer due to input error.\n");
else printf("the single root is %f\n",-c/b);
else
{disc=b*b-4*a*c;
twoa=2*a;
term1=-b/twoa;
t=abs(disc);
term2=sqrt(t)/twoa;
if(_________)
printf("complex root\nreal part=%f imag part=%f\n",term1,term2);
else
printf("real roots\nroot1=%froot2=%f\n",term1+term2,term1-term2);
}
}
【答案】
a==0 fabs(a)＜1e-4;b==0;disc＜0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
某服装店经营套服，也单件出售。若买的不少于50套每套80元；不足50套的每套90元；只买上衣每件60元；只买裤子每条45元。以下程序的功能是读入所买上衣c和裤子t的件数，计算应付款m。请分析程序填空。
main()
{int c,t,m;
printf("input the number of coat and trousers your want buy:\n");
scanf("%d %d",&c,&t);
if(_________)
if(c＞=50) m=c*80;
else m=c*90;
else
if(_________)
if(t＞=50) m=t*80+(c-t)*60;
else m=t*90+(c-t)*60;
else
if(_________) m=c*80+(t-c)*45;
else m=c*90+(t-c)*45;
printf("cost=%d\n",m);
}
【答案】
t==c;c＞t;c＞=50;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】根据以下函数关系，对输入的每个x值，计算出相应的y值。请分析程序填空
main()
{int x,c;
float y;
scanf("%d",&x);
if(_________) c=-1;
else c=_________;
switch(c)
{case –1:y=0;break;
case 0:y=x;break;
case 1:y=10;reak;
case 2:case 3:y=-0.5*x+20;break;
default:y=-2;
}
if(_________) printf("y=%f",y);
else printf("error\n");
}
【答案】
x＜0;x/10;y!=-2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是判断输入的年份是否是闰年。请分析程序填空。
main()
{int y,f;
scanf("%d",&y);
if(y%400==0) f=1;
else if(_________) f=1;
else _________;
if (f) printf("%d is",y);
else printf("%d is not",y);
printf(" a leap year.\n");
}
【答案】
year%4== 0＆＆year%100!=0;f=0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
假设奖金税率如下(a代表奖金，r代表税率)
a＜500 r=0%
500≤a＜1000 r=5%
1000≤a＜2000 r=8%
2000≤a＜3000 r=10%
3000≤a r=15%
以下程序对输入的一个奖金数，求税率和应交税款以及实得奖金数(扣除奖金税后)。请分析程序填空。
main()
{float a,r,t,b;
int c;
scanf("%f",&a);
if(a＞=3000) c=6;
else c=_________;
switch(c)
{case 0:r=0;break;
case 1:r=0.05;break;
case 2:case 3: _________;break;
case 4:case 5:r=0.1;break;
case 6:r=0.15;break;
}
t=a*r;
b=a-t;
printf("r=%f,t=%f,b=%f",r,t,b);
}
【答案】
a/500;r=0.08;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有定义:double x[3][5];则x数组中行下标的下限为_________，列下标的上限为_________。
【答案】
0;4;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有以下输入（数之间有空格），则下面程序的运行结果是_________。
7 16 5 4 6 7 9 8 3 2 4 6 12 2 -1＜CR＞
main()
{int b[51],x,i,j=0,n=0;
scanf("%d",&x);
while(x＞-1){b[++n]=x;scanf("%d",&x);}
for(i=1;i＜=n;i++)
if(b[i]%2==0) b[++j]=b[i];
for(i=1;i＜=j;i++) printf("%3d ",b[i]);
}
【答案】
16 4 6 8 2 4 6 12 2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序将二维数组a的行和列元素互换后存到另一个二维数组b中。请分析程序填空。
main()
{int a[2][3]={{1,2,3},{4,5,6}}, int b[3][2],i,j;
printf("array a:\n");
for(i=0;i＜=1;i++)
{for(j=0; _________;j++)
{printf("%5d",a[i][j]);
_________;
}
printf("\n");
}
printf("array b:\n");
for(i=0; _________;i++)
{for(j=0;j＜=1;j++)
printf("%5d",b[i][j]);
printf("\n");
}
}
【答案】
j＜=2;b[j][i]=a[i][j];i＜=2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序以每行4个数的形式输出a数组，请分析程序填空_________。
#define N 20
main()
{int a[N],i;
for(i=0;i＜N;i++) scanf("%d",____);
for(i=0;i＜N;i++)
{if(____) (____);
printf("%3d",a[i]);
}
}
【答案】
＆a[i] i%4==0 printf("\n");
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序可求出矩阵两条对角线上的元素之和。请分析程序填空。
main()
{int a[3][3]={1,3,6,7,9,11,14,15,17},sum1=0,sum2=0,i,j;
for(i=0;i＜3;i++)
for(j=0;j＜3;j++)
if(i==j) sum1+=a[i][j];
for(i=0;i＜3;i++)
for(_________;_________;j--)
if(i+j==2) sum2+=a[i][j]; printf("sum1=%d,sum2=%d\n",sum1,sum2);
}
【答案】
j=2;j＞=0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_________。
main()
{int a[5][5],i,j,n=1;
for(i=0;i＜5;i++) for(j=0;j＜5;j++)
a[i][j]=n++;
printf("The result is:\n");
for(i=0;i＜5;i++) {for(j=0;j＜=i;j++) printf("%4d",a[i][j]);
printf("\n");
}
}
【答案】
1,67,11,11,13,16,17 18,19,21,22,23,24,25;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序可求出所有的水仙花数。(水仙花数是三位正数，其各位数字的立方和等于该正数，如：407=4*4*4+0*0*0+7*7*7)
main()
{int x,y,z,a[8],m,i=0;
printf("The special numbers are :\n");
for (_________;m++)
{x=m/100;
y=_________;
z=m%10;
if (m= =x*x*x+y*y*y+z*z*z)
{_________;i++;}
}
for (x=0;x＜i;x++)
printf(%6d",a[x]);
}
【答案】
m=100;m＜1000;m/10%10;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是生成并打印某数列的前20项,该数列第1,2项分别为0和1,以后每个奇数编号的项是前两项之和,偶数编号的项是前两项差的绝对值。生成的20个数存在一维数组x中,并按每行4项的形式输出。
main()
{ int x[21],i,j;
x[0]=0;x[2]=1;
i=3;
do
{x[i]= _________;
x[i+1]= _________;
i=_________;
} while (i＜=20);
for (i=1;i＜=20;i++)
{printf("%5d",x[i]);
if (i%4= =0)
printf("\n");
}
}
【答案】
x[i-2]+x[i-1];x[i]-x[i-1];i+2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_________。
main()
{int i,j,a[2][3]={{2,4,6},{8,10,12}};
printf("The original array is:\n");
for(i=0;i＜2;i++)
{for(j=0;j＜3;j++)
printf("%4d",a[i][j]);
printf("\n");
}
printf("\nThe result is:\n");
for(i=0;i＜3;i++)
{for(j=0;j＜2;j++)
printf("%4d",a[j][i]);
printf("\n");
}
}
【答案】
The original array is: 2,4,6,8 10 12 The result is:2 8,4,10,6,12;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
设数组a包括10个整型元素，下面程序的功能是求出a中各相邻两个元素的和，并将这些和存在数组b中，按每行3个元素的形式输出。请分析程序填空。
void main()
{int a[10],b[10],i;
for(i=0;i＜10;i++)
scanf("%d",&a[i]);
for(_________;i＜10;i++)
_________;
for(i=1;i＜10;i++)
{printf("%3d",b[i]);
if(_________==0) printf("\n");
}
}
【答案】
i=1;b[i]=a[i-1]+a[i];i%3;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序用插入法对数组a进行降序排序。请分析程序填空。
main()
{int a[5]={4,7,8,2,5};
int i,j,m;
for(i=1;i＜5;i++)
{m=a[i];
j=_________;
while(j＞=0&&m＞a[j])
{_________;
j--;
}
_________=m;
}
for(i=0;i＜5;i++)
printf("%3d",a[i]);
printf("\n");
}
【答案】
i-1;a[j+1]=a[j];a[j+1];
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序用“两路合并法”把两个已按升序排列的数组合并成一个升序数组。请分析程序填空。
main()
{int a[3]={5,9,19};
int b[5]={12,24,26,37,48};
int c[10],i=0,j=0,k=0;
while(i＜3&&j＜5)
if(_________)
{c[k]=b[j];k++;j++;}
else
{c[k]=a[i];k++;i++;}
while(_________)
{c[k]=a[i];i++;k++;}
while(_________)
{c[k]=b[j];k++;j++;}
for(i=0;i＜k;i++)
printf("%3d",c[i]);
}
【答案】
a[i]＞b[j];i＜3;j＜5;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_________。
#include＜stdio.h＞
#define LEN 4
main()
{int j,c;
char n[2][LEN+1]={"8980","9198"};
for(j=LEN-1;j＞=0;j--)
{c=n[0][j]+n[1][j]-2*'0';
n[0][j]=c%10+'0';
}
for(j=0;j＜=1;j++) puts(n[j]);
}
【答案】
7078 9198;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
当运行以下程序时，从键盘输入AabD＜CR＞，则运行结果是_________。
#include＜stdio.h＞
main()
{char s[80];
int i;
gets(s);
while(s[i]!='\0')
{if(s[i]＜='z'&&s[i]＞='a')
s[i]='z'+'a'-s[i];
i++;
}
puts(s);
}
【答案】
AzyD;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_________。
#include＜stdio.h＞
main()
{char s[]="ABCCDA",c;
int k;
for(k=1;(c=s[k])!='\0';k++)
{switch(c)
{case 'A':putchar('%');continue;
case 'B':++k;break;
default:putchar('*');
case 'C':putchar('&');continue;
}
putchar('#');
}
}
【答案】
#＆*＆%;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若输入的值是-125，以下程序的执行结果是_________。
#include＜math.h＞
main()
{int n;
scanf("%d",&n);
printf("%d=",n);
if(n＜0) printf("-");
n=abs(n);
fun(n);
}
fun(int n)
{int k,r;
for(k=2;k＜=sqrt(n);k++)
{r=n%k;
while(r==0)
{printf("%d",k);
n=n/k;
if(n＞1)printf("*");
r=n%k;
}
}
if(n!=1) printf("%d\n",n);
}
【答案】
-125=-5*5*5;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是_________。
main()
{int x=2,y=3,z=0;
printf("(1)x=%d y=%d z=%d\n",x,y,z);
add(x,y,z);
printf("(3)x=%d y=%d z=%d\n",x,y,z);
}
add(int x,int y,int z)
{z=x+y; x=x*x; y=y*y;
printf("(2)x=%d y=%d z=%d\n",x,y,z);
}
【答案】
(1)x=2 y=3 z=0,(2)x=4 y=9 z=5,(3)x=2 y=3 z=0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是_________。
#include＜stdio.h＞
f(int n)
{int i,j,k;
i=n/100;j=n/10-i*10;k=n%10;
if (i*100+j*10+k==i*i*i+j*j*j+k*k*k) return n;
else return 0;
}
main()
{int n,k;
printf("Output");
for(n=100;n＜1000;n++)
{k=f(n);
if(k!=0)
printf("%d ",k);
}
printf("\n");
}
【答案】
输出所有的水仙花数;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是用二分法求方程2x3-4x2+3x-6=0的根，并要求绝对误差不超过0.001。请填空_________。
#include＜stdio.h＞
float f(float x)
{return (2*x*x*x-4*x*x+3*x-6);}
main()
{float m=-100,n=90,r;
r=(m+n)/2;
while(f(r)*f(n)!=0)
{if(【1】) m=r;
else n=r;
if(【2】) break;
r=(m+n)/2;
}
printf("方程的解是%3f\n",r);
}
【答案】
f(r)*f(n)＜0或f(r)*f(m)＞0,n-m＜0.001;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若输入一个整数10，以下程序的运行结果是_________。
int sub(int a)
{int c;
c=a%2;
return c;
}
main()
{int a,e[10],c,i=0;
printf("Input a number:");
scanf("%d",&a);
while(a!=0)
{c=sub(a);
a=a/2;
e[i]=c;
i++;
}
for(;i＞0;i--) printf("%d",e[i-1]);
}
【答案】
1010;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是输出如下图形。请填空
*
***
*****
*******
*****
***
*
#include ＜stdio.h＞
void a(int i)
{int j,k;
for(j=0;j＜=7-i;j++) printf("");
for(k=0;k＜_________。;k++) printf("*");
printf("\n");
}
main()
{int i;
for(i=0;i＜3;i++) _________。;
for(i=3;i＞=0;i--) _________。;
}
【答案】
2*i+1;a[i];a[i];
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数pi的功能是:根据以下公式，返回满足精度(0.0005)要求的π值，请填空
π/2=1+1/3+1/3*2/5+1/3*2/5*3/7+1/3*2/5*3/7*4/9+…
#include ＜conio.h＞
#include＜math.h＞
#include＜stdio.h＞
double pi(double eps)
{double s,t;
int n;
for(_________;t＞eps;n++)
{s+=t;
t=n*t/(2*n+1);
}
return (_________);
}
main()
{double x;
printf("\nPlease enter a precision:");
scanf("%lf",&x);
printf("\neps=%lf,π=%lf",x,pi(x));
}
【答案】
s=0,t=1,n=1;2*s;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是_________。
main()
{int i=5;
printf("%d\n",sub(i));
}
sub(int n)
{int a;
if(n==1) return 1;
a=n+sub(n-1);
return a;
}
【答案】
15;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是_________，运行结果是_________。
long fib(int g)
{switch(g)
{case 0: return 0;
case 1: case 2: return 1;
}
return(fib(g-1)+fib(g-2));
}
main()
{ long k;
k=fib(7);
printf("k=%d\n",k);
}
【答案】
计算斐波那契数列第7项的值;k=13;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是_________。
#include ＜stdio.h＞
f(int a[])
{int i=0;
while(a[i]＜=10)
{printf("%3d",a[i]);
i++;
}
}
main()
{int a[]={1,5,10,9,11,7};
f(a+1);
}
【答案】
5 10 9;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下search函数的功能是利用顺序查找法从数组的10个元素中对关键字m进行查找。顺序查找法的思路是：从第一个元素开始，从前向后依次与关键字比较，直到找到此元素或找到数组尾部时结束。若找到，返回此元素的下标；若未找到，则返回-1。请填空。
#include ＜stdio.h＞
int search(int a[10],int m)
{int i;
for(i=0;i＜=9;i++) if(_________) return (i);
return -1;
}
main()
{int a[10],m,i,no;
…
no=search(_________);
if(_________) printf("\nOK FOUND!",no);
else printf("\nSorry Not Found!");
}
【答案】
a[i]==m;a,m;no＞=0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数del的作用是删除有序数组a中的指定元素x。已有调用语句n=del(a,n,x);其中实参n为删除数组元素的个数，赋值号左边的n为删除后数组元素的个数。请填空。
del(int a[],int n,int x)
{int p,i;
p=0;
while (x＞=a[p]&&p＜n)
_________;
for(i=p-1;i＜n;i++)
_________;
n=n-1;
return n;
}
【答案】
p++;a[i]=a[i+1];
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的运行结果是_________，其算法是_________。
main()
{int a[5]={9,6,8,3,-1},i,j,t,p;
sort(a);
for(i=0;i＜=4;i++)
printf("%3d",a[i]);
}
sort(int a[])
{int i,j,t,p;
for(j=0;j＜4;j++)
{p=j;
for(i=j;i＜=4;i++)
if(a[i]＜a[p]) p=i;
t=a[p];a[p]=a[j];a[j]=t;
}
}
【答案】
-1 3 6 8 9;选择法排序;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序可计算10名学生1门课成绩的平均分，请填空。
float average(float array[])
{int i;float aver,sum=array[0];
for(i=1; _________;i++)
sum+=_________;
aver=sum/10;
return aver;
}
main()
{float score[10],aver;
int i;
printf("\ninput 10 scores:");
for(i=0;i＜10;i++) scanf("%f",&score[i]);
aver=_________;
printf("\naverage score is %5.2f\n",aver);
}
【答案】
i＜10;array[i];average(score);
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数yahui能够按以下形式构成一个杨辉三角形，请填空。
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
………..
#define N 11
yahui(int [][N])
{int i,j;
for(i=1;i＜N;i++)
{a[i][1]=1;a[i][i]=1;}
for(_________;i＜N;i++)
for(j=2; _________;j++)
a[i][j]= _________+a[i-1][j];
}
【答案】
i=3;j＜i;a[i-1][j-1];
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
main( )
{int a=20,b=10,c; c=a/b;
# ifdef DEBUG
printf(“a=%d,b=%d,”,a,b);
#endif
printf(“c=%d\n,”,c);
}
【答案】
c=2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
# include ＜stdio.h＞
# define PR(a) printf (”a=%d”, (int)(a))
# define PRINT(a) PR(a); putchar(‘\n’);
main( )
{ float x=3.1415,y=1.823; PRINT(2*x); PRINT(3*y*y);
}
【答案】
a=6,a=9;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
# include ＜stdio.h＞
# define PR(a) printf (”a=%d”, (int)(a))
# define PRINT(a) PR(a); putchar(‘\n’);
# define PRINT2(a,b) PR(a), PRINT(b)
# define PRINT3(a,b,c) PR(a), PRINT2(b,c)
main( )
{ float x=3.1415,y=1.823,z=0.923;
PRINT3(x,2*y,3*z)
}
【答案】
a=3 a=3 a=2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
# define A 3
# define B(a) ((A+1)*a)
main( )
{ int x; x=3*(A+B(7)); printf (”x=%4d\n”, x);
}
【答案】
x= 93;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
# define POWER(x) ((x)*(x))
main( )
{ int i=1; while(i＜=4) printf(“%d”, POWER(i++));
}
【答案】
2 12;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
#define DEBUG
main( )
{int a=14,b=15,c; c=a/b;
# ifdef DEBUG
printf(“a=%d,b=%d,”,a,b);
#endif
printf(“c=%d\n,”,c);
}a=14,b=15,c=0
【答案】
a=14,b=15,c=0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_________。
main( )
{int b=5;
#define b 2
#define f(x) b*(x)
int y=3;
printf(“%d,”, f(y+1));
#undef b
printf(“%d,”, f(y+1));
#define b 3
printf(“%d\n”, f(y+1));
}
【答案】
8,20,12;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
本程序为一个函数check（s），它检查给定字符串s是否满足下列条件：
①、从字符串首字符起，在顺序检查s中字符的过程中，遇到的右括号‘）’的个数在任何时候均不超过所遇到的左括号‘（’的个数；
②、左括号‘（’的个数与右括号‘）’的个数相同。
若字符串s同时满足上述条件①和②，函数返回非0值，否则返回0值。
〖程序】
int check(_________ s)
{ int lp,rp;
lp=0; rp=0;
while (_________){
if (*s==’(‘ ) lp++;
else if (*s==’)’ ) {
rp++;
if (_________) return 0;
}
_________;
}
return _________:1;
}
【答案】
char *;*s;s++;lp＜rp;lp!=rp?0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
本程序将键盘输入和文件file1.dat中的数据按由小到大排序后，存入file2.dat中。file1.dat中已有由小到大的整型数据，键盘输入的10个数据存入数组a中。
#include "stdio.h"
#_____ N 10
void sort (int b[],int n) /*sort()的功能是由小大对数组b排序*/
{ int i,j,k,temp;
for (i=0;i＜n-1;i++)
{ k=i;
for(j=i+1;j＜n;j++)
if (b[k]＞b[j]) ______;
if (k!=i)
{temp=b[i];
b[i]=b[k];
b[k]=temp;
}
}
}
main()
{FILE *fpr,*fpw;
int a[N],i,data;
for (i=0;i＜N;i++) scanf("%d",&a[i]);
sort(a,N);
if ((fpr=fopen("file1.dat","r"))==NULL)
{printf("Can not open file1.dat.\n");
exit(1);
}
if ((fpw=fopen("file2.dat",______))==NULL)
{printf("Can not open file2.dat.\n");
exit(2);
}
i=0;
while (!feof(fpr))
{ fscanf(fpr,"%d",&data);
______ (a[i]＜=data&&i＜N)
fprintf(fpw,"%d ",a[i++]);
fprintf(fpw,"%d ",data);
}
while (i＜N) fprintf(fpw,"%d ",a[i++]);
fclose(fpr);
_____;
}
【答案】
Define;k=j;”w”;while;fclose(fpw);
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是用公式π2/6≈1/12+1/22+1/32+...+1/n2求π的近似值，直到最后一项的值小于10-6为止，请分析程序填空。
#include＜math.h＞
#include＜stdio.h＞
main()
{long i=1;
_________pi=0;
while(i*i＞=1e6)
{pi=_________;i++;}
pi=sqrt(6.0*pi);
printf("pi=%10.6f\n",pi);
}
【答案】
double;pi+1/i/i;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是用“辗转相除法”求两个正整数的最大公约数。请分析程序填空。
#include＜stdio.h＞
main()
{int r,m,n;
scanf("%d%d",&m,&n);
if(m＜n) _________;
r=m%n;
while(r){m=n;n=r;r=_________;}
printf("%d\n",n);
}
【答案】
r=m,m=n,n=r;m%n;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面的程序是用do while语句求1至1000之间满足“用3除余2；用5除余3；用7除余2"的数，且一行只打印五个数。请分析程序填空。
#include＜stdio.h＞
main()
{int i=1,j=0;
do
{if(_________)
{printf("%4d",i);
j=j+1;
if(_________) printf("\n");
}
i=i+1;
}while(i＜1000);
}
【答案】
i%3==2＆＆i%5==3＆＆i%7==2;j%5==0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_________。
#include＜stdio.h＞
main()
{int a,s,n,count;
a=2;s=0;n=1;count=1;
while(count＜=7) {n=n*a;s=s+n;++count;}
printf("s=%d\n",s);
}
【答案】
s=254;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序段是找出整数的所有因子,请分析程序填空_________。
scanf("%d",&x);
for (i=1;; i++)
if (x%i==0) printf("%3d",i);
【答案】
i＜=x;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
鸡兔同笼，头30，脚90，下面程序段计算鸡兔各有多少只。请分析程序填空。
for(x=1;x＜=30;x++ )
{y=30-x;
if(_________) printf("%d,%d",x,y);
}
【答案】
2*x+4*y==90;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是计算1-3+5-7+...-99+101的值，请分析程序填空。
#include＜stdio.h＞
main()
{int i,t=1,s=0;
for(i=1;i＜=101;i+=2)
{_________;s=s+t; _________;}
printf("%d\n",s);
}
【答案】
t=t*i;t=-t/i;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序是用梯形法求sin(x)*cos(x)的定积分。求定积分的公式为：
s=h/2(f(a)+f(b))+h∑f(xi) (i=1~n-1)
其中xi=a+ih,h=(b-a)/n。设a=0,b=1.2为积分上下限，积分区间分隔数n=100，请分析程序填空。
#include＜stdio.h＞
#include＜math.h＞
main()
{int i,n;double h,s,a,b;
printf("Input a,b:");
scanf("%lf%lf",_________);
n=100;h=_________;
s=0.5*(sin(a)*cos(a)+sin(b)*cos(b));
for(i=1;i＜=n-1;i++) s+=_________;
s*=h;
printf("s=%10.4lf\n",s);
}
【答案】
＆a,＆b;(b-a)/n;sin(a+i*h)*cos(a+i*h);
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是根据公式e=1+1/1!+1/2!+...1/n!求e的近似值，精度要求为10-6。请分析程序填空。
#include＜stdio.h＞
main()
{int i;double e,new;
_________;new=1.0;
for(i=1; _________;i++)
{new/=(double)i; e+=new;}
printf("e=%lf\n",e);
}
【答案】
e=1;new＞1e-6;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的功能是求1000以内的所有完全数。说明：一个数如果恰好等于它的因子之和（除自身外），则称该数为完全数。例如：6＝1+2+3。
#include＜stdio.h＞
main()
{int a,i,m;
for(a=1;a＜=1000;a++)
{for(_________;i＜=a/2;i++)
if(!(a%i)) _________;
if(m==a) printf("%4d",a);
}
}
【答案】
i=1,m=0;=m+i;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
请编程序，根据以下函数关系，对输入的每个x值，计算出相应的y值。
【答案】
main()
{float x,y;
printf("Input x:");
scanf("%f",&x);
y=-1;
if(x＜0) y=0;
else if(x＜=10) y=x;
else if(x＜=20) y=10;
else if(x＜40) y=0.5*x+20
else y=-1;
if (y==-1) printf("error");
else printf("y=%f\n",y);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
编程实现以下功能：读入两个运算数(data1和data2)及一个运算符(op),计算表达式data1 op data2的值，其中op可为+,-,*,/(用switch语句实现)。
【答案】
T#include＜stdio.h＞
#include＜stdlib.h＞
main()
{float data1,data2,result;
char op;
printf("Type in your expression:");
scanf("%f %c %f",&data1,&op,&data2);
switch(op)
{case '+':result=data1+data2;break;
case '-':result=data1-data2;break;
case '*':result=data1*data2;break;
case '/':if(data2==0){printf("\nDivision by zero!");exit(1);}
result=data1/data2;break;
}
printf("This is %6.2f %c %6.2f=%6.2f\n",data1,op,data2,result);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
编一程序，对于给定的一个百分制成绩，输出相应的五分值成绩。设90分以上为'A',80-89分为'B',70－79分为'C',60-69分为'D',60分以下为'E'(用switch语句实现)。
【答案】
main()
{int score=-1,temp;
char grade;
while(score＞=0&&score＜=100)
{ printf("Enter score:");
scanf("%d",&score);
}
temp=score/10;
switch(temp)
{case 0:case 1:case 2:case 3:case 4:case 5:grade='E';break;
case 6:grade='D';break;
case 7:grade='C';break;
case 8:grade='B';break;
case 9:case 10:grade='A';
}
printf("score=%d,grade=%c\n",score,grade);
}
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
从键盘输入若干个整数，其值在0至4范围内，用-1作为输入结束的标志。统计每个整数的个数。
【答案】
void main()
{int i,s[5],x
printf("Input some numbers(between 0 to 4):");
scanf("%d",&x);
while(x!=-1)
{if (x＞=0&&x＜=4) s[x]++;}
for(i=0;i＜=4;i++)
printf("%d: %d\n",i,s[i]);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
试编程打印用户指定的n阶顺时针螺旋方阵(n＜10)。
【答案】
main()
{int a[10][10],i,j,k=0,m,n;
printf("Enter n(n＜10):\n");
scanf("%d",&n);
if(n%2==0)
m=n/2;
else
m=n/2+1;
for(i=0;i＜m;i++)
{for(j=i;j＜n-i;j++)
{k++;a[i][j]=k;}
for(j=i+1;j＜n-i;j++)
{k++;a[j][n-i-1]=k;}
for(j=n-i-2;j＞=i;j--)
{k++;a[n-i-1][j]=k;}
for(j=n-i-2;j＞=i+1;j--)
{k++;a[j][i]=k;}
}
for(i=0;i＜n;i++)
{for(j=0;j＜n;j++)
printf("%5d",a[i][j]);
printf("\n");
}
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数；然后按顺序每五个数求出一个平均值，放在另一个数组中并输出。试编程。
【答案】
#define SIZE 30
main()
{float b[SIZE/5],sum;
int a[SIZE],i,k;
for(k=2,i=0;i＜SIZE;i++,k+=2)
a[i]=k;
sum=0;
for(k=0,i=0;i＜SIZE;i++)
{sum=sum+a[i];
if((i+1)%5==0)
{b[k++]=sum/5;
sum=0;
}
}
printf("The result is:\n");
for(i=0;i＜SIZE/5;i++) printf("%2f ",b[i]);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
从键盘输入一个整数，用折半查找法找出该数在10个有序整型数组a中的位置。若该数不在a中，则打印出相应信息。试编程。
【答案】
main()
{int a[10]={1,3,5,7,9,11,13,15,17,19},top,bot,mid,m;
printf("Enter a integer:");
scanf("%d",&m);
top=0;bot=9; /*字符型bot=strlen(a)-1*/
while(top＜=bot)
{mid=(top+bot)/2;
if(a[mid]==m) break;
else if(a[mid]＞m) top=mid+1;
else bot=mid-1;
}
if(top＜=bot) printf("Found! position is %d.\n",mid);
else printf("Not found %d.\n",m);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
从键盘输入两个字符串a和b，要求不用库函数strcat把串b的前五个字符连接到串a中；如果b的长度小于5，则把b的所有元素都连接到a中。试编程。
【答案】
#include ＜string.h＞
main()
{char a[80],b[80];
int i=0,j;
printf("Input two strings:\n");
gets(a);gets(b);
while(a[i]) i++;
for(j=0;j＜5&&b[j];j++)
a[i++]=b[j];
a[i]='\0';
puts(a);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
从键盘输入一个字符串a，并在串中的最大元素后边插入另外输入的字符串b。
【答案】
#include ＜string.h＞
main()
{char a[80],b[]="ab",max;
int i=1,j;
printf("Input a string:\n");
gets(a);
puts(a);
max=a[0];
while(a[i])
{if(a[i]＞max)
{max=a[i];j=i;}
i++;
}
for(i=strlen(a)+strlen(b)-1;i＞j;i--)
a[i]=a[i-strlen(b)];
j=0;i++;
while(b[j])
{a[i]=b[j];
i++;j++;
}
puts(a);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
已有变量定义和函数调用语句：int a=1,b=-5,c;c=fun(a,b);fun函数的作用是计算两个数之差的绝对值，并将差值返回调用函数，请编写fun函数。
【答案】
fun(int x,int y)
{if(x＞y) return x-y;
return y-x;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
已有变量定义和函数调用语句：int x=57; isprime(x);函数isprime()用来判断一个整型数a是否为素数，若是素数，函数返回1，否则返回0。请编写isprime函数。
【答案】
int isprime(int a)
{int k;
if(a==1) return 0;
for(k=2;k＜=a/2;k++)
if(a%k==0) return 0;
return 1;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
有一个数组，内放10个学生的英语成绩，写一个函数，求出平均分，并且打印出高于平均分的英语成绩。
【答案】
main( )
{
float grade[10],i,aver;
for(i=0;i＜10;i++)
scanf(“%f”,grade[i]);
aver=fensu(grade,10)
for(i=0;i＜10;i++)
if(grade[i]＞aver) printf(“%f”,grade[i]);
}
fensu(float a[10],int n)
{ float sum=0,pj;
for(i=0;i＜n;i++)
sum=sum+a[i];
pj=sum/n;
return(pj);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
编写一个函数计算任一输入的整数的各位数字之和。主函数包括输入输出和调用该函数。
【答案】
#include ＜stdio.h＞
func(int num)
{int s=0;
num=abs(num);
do
{s+=num%10;
num/=10;
}while(num);
}
main( )
{int n;
printf(“输入一个整数:”);
scanf(“%d”,&n);
printf(“结果:%d”,func(n));
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
【答案】
#include "stdio.h"
main()
{int i=5;
void palin(int n);
printf("\40:");
palin(i);
printf("\n");}
void palin(int n)
{char next;
if(n＜=1)
{next=getchar();
printf("\n\0:");
putchar(next); }
else
{next=getchar();
palin(n-1);
putchar(next); }
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
输入10个学生的成绩，分别用函数实现：(1)求平均成绩；(2)按分数高低进行排序并输出。
【答案】
#include "stdio.h"
main( )
{float average(float b[]);
void sort(float b[]);
float a[10],j,aver;
for(j=0;j＜10;j++)
scanf(“%f”,&a[j]);
aver=average(a);
printf(“aver=%f\n”,aver);
sort(a);
for(j=0;j＜10;j++)
printf(“%.2f ”,a[j]);
}
float average(float b[ ])
{int j; float sum=0,aver;
for(j=0;j＜10;j++)
sum=sum+b[i];
aver=sum/10.0;
return(aver);
}
void sort(float b[ ])
{int i,j,max,k;
for(i=0;i＜10;i++)
{max=b[i]; k=i;
for(j=i+1;j＜10;j++)
if(max＜b[j]) {max=b[j]; k=j;}
b[k]=b[i];
b [i]=max;}
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
若有一4*4二维数组，试编程完成如下功能：(1)求4*4列数组的对角线元素值之和。(2)将二维数组元素行列互换后存入另一数组，并将此数组输出。
【答案】
main( )
{int a[4][4],i,j,sum;
for(i=0;i＜4;i++)
for(j=0;j＜4;j++)
scanf(“%d”,&a[i][j]);
sum=he(a);
huan(a);
printf(“sum=%d”,sum);
}
he(int b[ ][ ])
{ int i,j,sum=0;
for(i=0;i＜4;i++)
for(j=0;j＜4;j++)
if(i= =j) sum=sum+b[i][j];
else if(i+j= =3) sum=sum+b[i][j];
return(sum);
}
huan(int b[][])
{int c[4][4], i,j;
for(i=0;i＜4;i++)
for(j=0;j＜4;j++)
c[j][i]=b[i][j];
for(i=0;i＜4;i++)
{for(j=0;j＜4;j++)
printf(“%d”,c[i][j]);
printf(“\n”);
}
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
有两个字符串，各有10个字符，编程完成如下功能：(1)分别找出两个字符串中最大的字符元素；(2)将两字符串对应位置元素逐个比较，并统计输出两个字符串对应元素大于、小于和等于的次数。
【答案】
main( )
{ void tongji(char c[ ],char d[ ]);
char zuida(char c[ ]);
char a[10],b[10],max1,max2;
int i;
for(i=0;i＜10;i++)
scanf(“%c”,&a[i]);
for(i=0;i＜10;i++)
scanf(“%c”,&b[i]);
max1=zuida(a);
max2=zuida(b);
printf(“max1=%c,max2=%c”,max1,max2);
tongji(a,b);
}
char zuida(char c[ ])
{int i; char max=c[0];
for(i=1;i＜10;i++)
if(max＜c[i]) max=c[i];
return(max);
}
void tongji(char c[ ],char d[ ])
{int i,da=0,deng=0,xiao=0;
for(i=0;i＜10;i++)
if(c[i]＞d[i]) da++;
else if(c[i]= =d[i]) deng++;
else xiao++;
printf(“da=%d,deng=%d,xiao=%d”,da,deng,xiao);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include＜stdio.h＞
void main()
{
static int a[] = {1,2,3,4,5};
int x, y, *p;
p = &a[0];
x = *(p+2);
y = *p++;
printf("%d%d%d\n", *p, x, y);
}
【答案】
231
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include＜stdio.h＞
void f(int *p);
void main()
{ int a[5]={1,2,3,4,5}, *r=a;
f(r); printf("%d\n ",*r);
}
void f(int *p)
{ p=p+3;
printf("%d",*p);
}
【答案】
41
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include＜stdio.h＞
void fun(int *a,int n)
{ int i,j,k,t;
for(i=0;i＜n-1;i++)
{ k=i;
for(j=i;j＜n;j++)
if(a[j]＞a[k]) k=j;
t=a[i]; a[i]=a[k]; a[k]=t;
}
}
void main()
{ int aa[10]={1,2,3,4,5,6,7},i;
fun(aa,7);
for(i=0;i＜7; i++)
printf("%d",aa[i]);
printf("\n");
}
【答案】
7654321
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include ＜stdio.h＞
void fun(char *c,int d)
{ *c=*c+1; d=d+1;
printf("%c, %c,", *c, d);
}
main()
{ char a='A', b='a';
fun(&b,a); printf("%c,%c\n",a,b);
}
【答案】
b,B,A,b
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include＜stdio.h＞
#include＜stdlib.h＞
void main()
{ int *a, *b, *c;
a=b=c=(int *)malloc(sizeof(int));
*a=1; *b=2; *c=3;
a=b;
printf("%d%d%d \n", *a, *b, *c);
}
【答案】
333
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include ＜stdio.h＞
void main( )
{
int s[6][6],j,k;
for(j=0;j＜6;j++)
for(k=0;k＜6;k++)
*(*(s+j)+k)=j-k;
for(j=0;j＜6;j++)
{
for(k=0;k＜6;k++)
printf(“%4d”,*(*(s+j)+k));
printf(“\n”);
}
}
【答案】
0 -1 -2 -3 -4 -5
1 0 -1 -2 -3 -4
2 1 0 -1 -2 -3
3 2 1 0 -1 -2
4 3 2 1 0 -1
5 4 3 2 1 0
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include ＜stdio.h＞
int find(int *a, int n, int x)
{ int *p=a+n;
p--;
while(*p!=x && p＞=a) p--;
return p-a;
}
void main( )
{ static int a[]={1,2,3,4,5,6,0,8};
int k=20;
printf("%4d",find(a, 8, k));
}
【答案】
-1
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
输入三个整数，按由小到大的顺序输出。
【答案】
#include＜stdio.h＞
void main()
{ int a,b,c,*p1,*p2,*p3,t;
scanf("%d,%d,%d",&a,&b,&c);
p1=&a; p2=&b; p3=&c;
if(*p1＞*p2)
{ t=p1; p1=p2; p2=t;}
if(*p1＞*p3)
{ t=p1; p1=p3; p3=t;}
if(*p2＞*p3)
{ t=p2; p2=p3; p3=t;}
printf("%d,%d,%d\n",*p1,*p2,*p3);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
输入三个字符串，按由小到大的顺序输出。
【答案】
#define N 3
#define M 20
#include ＜stdio.h＞
#include ＜string.h＞
void main()
{
char str[N][M],temp[M];
int i,j,k;
for(i=0;i＜N;i++)
gets(str[i]);
for(i=0;i＜N-1;i++){
k=i;
for(j=i+1;j＜N;j++)
if(strcmp(str[k],str[j])＞0) k=j;
if(k!=i){
strcpy(temp,str[i]);
strcpy(str[i],str[k]);
strcpy(str[k],temp);
}
}
for(i=0;i＜N;i++)
puts(str[i]);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
输入10个整数，将其中最小的数与第一个数对换，把最大的数与最后一个数对换。写三个函数；①输入10个数；②进行处理；③输出10个数。
【答案】
#include ＜stdio.h＞
int f(int x[],int n)
{
int *p0,*p1,i,j,t,y;
i=j=x[0];p0=p1=x;
for(y=0;y＜n;y++)
{ if(x[y]＞i)
{i=x[y];p0=&x[y];}
else if(x[y]＜j) {j=x[y];p1=&x[y];}
}
t=*p0;*p0=x[n-1];x[n-1]=t;
t=*p1;*p1=x[0];x[0]=t;
return 1;
}
int main(int argc, char *argv[]) {
int a[10],u,*r;
for(u=0;u＜10;u++) scanf("%d",&a[u]);
f(a,10);
for(u=0,r=a;u＜10;u++,r++) printf(" %d",a[u]);
printf("\n");
return 0;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
有n个整数，使前面各数顺序向后移m个位置，最后m个数变成前面m个数。写一函数：实现以上功能，在主函数中输入n个数和输出调整后的n个数。
【答案】
#include ＜stdio.h＞
#define N 10
void shift(float *p, int x)
{
float a[N],*q,*o;int i;
o=a;q=p;
for(i=0;i＜x;i++) *(o+i)=*(q+N-x+i);
for(p=p+N-1;p＞=q;p--) *p=*(p-x);
for(i=0;i＜x;i++) *(q+i)=*(o+i);
return;
}
int main(int argc, char *argv[]) {
float shuzhu[N],*u,*v;
int h,i;u=v=shuzhu;
scanf("%d",&h);
for(;u＜v+N;u++) scanf("%f",u);
shift(v,h);
for(u=v;u＜v+N;u++) printf("%.2f ",*u);
printf("\n");
return 0;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
有n人围成一圈，顺序排号。从第1个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来的第几号的那位。
【答案】
#include ＜stdio.h＞
#define N 10
void shift(float *p, int x)
{
float a[N],*q,*o;int i;
o=a;q=p;
for(i=0;i＜x;i++) *(o+i)=*(q+N-x+i);
for(p=p+N-1;p＞=q;p--) *p=*(p-x);
for(i=0;i＜x;i++) *(q+i)=*(o+i);
return;
}
int main(int argc, char *argv[]) {
int i,j,k,a[N+1],*p;
for(i=0,p=a;p＜=a+N;i++,p++) *p=i;
p=a+1;k=N;
for(i=0,j=1;k!=1;j++)
{
if(p＞(a+N)) p=a+1;
if(*p!=0) i++;
if((i-3)==0) {*p=0;i=0;k--;}
p++;
}
for(i=1;i＜=N;i++)
if(a[i]!=0)
printf("The last number is %d\n",a[i]);
return 0;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
写一函数，求一个字符串的长度。在主函数中输入字符串，并输出其长度。
【答案】
#include ＜stdio.h＞
#define N 20
int length(char *s)
{
int len=0;
while(*s++) len++;
return len;
}
int main(int argc, char *argv[]) {
char str[N+1];
printf("请输入一个字符串\n");
scanf("%s",str);
printf("\n%s\n",str);
printf("该字符串长度为%d\n",length(str));
return 0;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
有一字符串，包含n个字符。写一函数，将此字符串中从第m个字符开始的全部字符复制成为另一个字符串。
【答案】
#include"stdio.h"
#define N 10
void main()
{char a[N+1],b[N+1],*p,*q;
int m;
printf("请输入一个字符串\n");
gets(a);
printf("请输入一个正整数\n");
scanf("%d",&m);
p=a+m; q=b;
strcpy(q,p);
puts(q);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
#include ＜stdio.h＞
struct STU
{ char num[10]; float score[3]; }
main()
{ struct STU s[3]={{"10101",90,95,85},
{"10102",95,80,75},
{"10103",100,95,90}},*p=s+2;
int i; float sum=0;
for(i=0;i＜3;i++)
sum=sum+p-＞score[i];
printf("%6.2f\n",sum);
}
【答案】
285.00
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
#include ＜stdio.h＞
struct st{
int x;
int *y;}*p;
int s[]={5,6,7,8};
struct st a[]={{10,&s[0]},{20,&s[1]},{30,&s[2]},{40,&s[3]}};
int main(){
p=a;
printf("%d,",p-＞x);
printf("%d,",(++p)-＞x);
printf("%d,",*(++p)-＞y);
printf("%d\n",++(*(++p)-＞y));
return 0;
}
【答案】
10,20,7,9
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
struct stype
{ int i;
struct stype *next;
}a[]={{1},{3},{5},{7}},*p=a;
main(){
int j;
for (j=1;j＜4;j++,p++) p-＞next=&a[j]; /*建立链表如下*/
printf("%d, ",a[0].next-＞i);
printf("%d,",++(*a[1].next).i);
printf("%d\n",a[2].i);
}
【答案】
3,6,6
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
struct student
{ long num;
float score;
struct student *next;
} s[]={{1,80},{2,88},{3,77},{4,97}},*p=s;
void print (struct student *head)
{ struct student *p;
p = head;
if (head != NULL)
do { printf ("%ld%5.1f\n", p-＞num, p-＞score);
p = p-＞next;
}while (p != NULL);
}
main(){
int j;
for (j=1;j＜4;j++,p++) p-＞next=&s[j];
p-＞next= NULL;
p=s;
print(p);
}
【答案】
1 80.0
2 88.0
3 77.0
4 97.0
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
#include ＜stdio.h＞
#define LEN sizeof (struct student)
struct student
{
long num;
float score;
struct student *next;
};
int n;
struct student *creat( ) /*此creat函数带回一个链表起始地址 */
{
struct student *head, *p1, *p2;
int n=0;
p1 = p2 = (struct student *)malloc(LEN); /*开辟一个新单元*/
scanf ("%ld %f", &p1-＞num, &p1-＞score);
head = NULL;
while(p1-＞num!= 0)
{
n++;
if(n == 1)
(1) ;
else
(2) ;
p2 = p1;
p1 =(3) ;
scanf ("%ld %f", &p1-＞num, &p1-＞score);
}
p2-＞next =(4) ;
return (head);
}
int main(){
struct student *head,*p;
p=head=creat();
while(p){
printf("%ld %f\n",p-＞num,p-＞score);
(5) ;
}
return 0;
}
【答案】
head=p1 (2)p2-＞next=p1 (3) (struct student *)malloc(LEN)
(4) NULL (5) p=p-＞next
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
定义一个结构体变量（包括年、月、日）。计算该日在本年中是第几天，注意闰年问题。
【答案】
#include ＜stdio.h＞
struct{
int year;
int month;
int day;
}date;
main()
{
int days;
printf("Input year,month,day:");
scanf("%d,%d,%d",&date.year,&date.month,&date.day);
switch(date.month)
{ case 1: days=date.day; break;
case 2: days=date.day+31; break;
case 3: days=date.day+59; break;
case 4: days=date.day+90; break;
case 5: days=date.day+120; break;
case 6: days=date.day+151; break;
case 7: days=date.day+181; break;
case 8: days=date.day+212; break;
case 9: days=date.day+243; break;
case 10: days=date.day+273; break;
case 11: days=date.day+304; break;
case 12: days=date.day+334; break;
}
if((date.year%4==0&&date.year%100!=0||date.year%400==0)&&date.month＞=3)days+=1;
printf("\n%d/%d is the %dth day in %d.",date.month,date.day,days,date.year);
}
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
写一个函数days,实现上面的计算。由主函数将年、月、日传递给days 函数，计算后将日数传回主函数。
【答案】
#include ＜stdio.h＞
struct newdate{
int year;
int month;
int day;
};
int ndays(struct newdate date){
int days=0;
switch(date.month)
{ case 1: days=date.day; break;
case 2: days=date.day+31; break;
case 3: days=date.day+59; break;
case 4: days=date.day+90; break;
case 5: days=date.day+120; break;
case 6: days=date.day+151; break;
case 7: days=date.day+181; break;
case 8: days=date.day+212; break;
case 9: days=date.day+243; break;
case 10: days=date.day+273; break;
case 11: days=date.day+304; break;
case 12: days=date.day+334; break;
}
if((date.year%4==0&&date.year%100!=0||date.year%400==0)&&date.month＞=3)days+=1;
return days;
}
main()
{
struct newdate date;
printf("Input year,month,day:");
scanf("%d,%d,%d",&date.year,&date.month,&date.day);
printf("\n%d/%d is the %dth day in %d.",date.month,date.day,ndays(date),date.year);
}
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
编写一个输入函数input和一个打印函数print，输入和打印一组学生信息，每个学生信息包括学号num、name和3门课程成绩sore[3]。用主函数调用输入函数和输出函数输入和输出这些学生信息。
【答案】
#include ＜stdio.h＞
#define N 10
struct student
{
char num[6];
char name[8];
int score[4];
}stu[N];
void input(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("input scores of student %d:\n",i+1);
printf("NO.:");
scanf("%s",stu[i].num);
printf("name: ");
scanf("%s", stu[i].name);
for(j=0;j＜3;j++){
printf("score%d:",j+1);
scanf("%d", &stu[i].score[j]);
}
}
printf("\n");
}
void print(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("%5s%10s",stu[i].num,stu[i].name);
for(j=0;j＜3;j++)
printf("%9d",stu[i].score[j]);
printf("\n");
}
}
int main(int argc, char *argv[]) {
input(stu);
print(stu);
return 0;
}
【解析】
【难度】2
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
在上题基础上求出每位学生的3门课程的总成绩，并以总成绩排名，输出每位学生的信息：学号、姓名、3门课的成绩、总成绩和排名。
【答案】
#include ＜stdio.h＞
#define N 20
struct student
{
char num[6];
char name[8];
int score[4];
int no;
}stu[N];
void input(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("input scores of student %d:\n",i+1);
printf("NO.:");
scanf("%s",stu[i].num);
printf("name: ");
scanf("%s", stu[i].name);
stu[i].score[3]=0;
for(j=0;j＜3;j++){
printf("score%d:",j+1);
scanf("%d", &stu[i].score[j]);
stu[i].score[3]+=stu[i].score[j];
}
}
printf("\n");
}
void sort(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
stu[i].no=1;
for(j=0;j＜N;j++)
if(stu[j].score[3]＞stu[i].score[3]) stu[i].no++;
}
}
void print(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("%5s%10s",stu[i].num,stu[i].name);
for(j=0;j＜4;j++)
printf("%9d",stu[i].score[j]);
printf("%4d\n",stu[i].no);
}
}
int main(int argc, char *argv[]) {
input(stu);
sort(stu);
print(stu);
return 0;
}
【解析】
【难度】2
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
13个人围成一圈，从第1个人开始顺序报号1、2、3。凡报到“3”者退出圈子。找出最后留在圈子中的人原来的序号。
【答案】
#include ＜stdio.h＞
#define N 13
struct person
{
int number;
int nextp;
}link[N+1];
int main(int argc, char *argv[]) {
int i,count,h;
for(i=1;i＜=N;i++){
if(i==N) link[i].nextp=1;
else link[i].nextp=i+1;
link[i].number=i;
}
printf("\n");
count=0;
h=N;
printf("sequence that person leave the circle:\n");
while(count＜N-1){
i=0;
while(i!=3) {
h=link[h].nextp;
if(link[h].number) i++;
}
printf("%4d",link[h].number);
link[h].number=0;
count++;
}
printf("\nThe last one is");
for(i=1;i＜=N;i++)
if(link[i].number)
printf("%3d",link[i].number);
return 0;
}
【解析】
【难度】2
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
建立一个链表，每个结点包括：学号、姓名、性别、年龄。输入一个年龄，如果链表中的结点所包含的年龄等于此年龄，则将此结点删去。
【答案】
#include ＜stdio.h＞
#define LEN sizeof(struct student)
struct student{
char num[6];
char name[8];
char sex[2];
int age;
struct student *next;
}stu[10];
int main(int argc, char *argv[]) {
struct student *p,*pt,*head;
int i,length,iage,flag=1;
int find=0;
while(flag==1){
printf("input length of list（＜10）:");
scanf("%d",&length);
if(length＜10) flag=0;
}
for(i=0;i＜length;i++){
p=(struct student *)malloc(LEN);
if(i==0) head=pt=p;
else pt-＞next=p;
pt=p;
printf("NO:");
scanf("%s",p-＞num);
printf("name:");
scanf("%s",p-＞name);
printf("sex:");
scanf("%s",p-＞sex);
printf("age:");
scanf("%s",p-＞age);
}
p-＞next=NULL;
p=head;
printf("\n NO. name sex age\n");
while(p!=NULL){
printf("%4s%8s%6s%6d\n",p-＞num, p-＞name, p-＞sex, p-＞age);
p=p-＞next;
}
printf("input age:");
scanf("%d",&iage);
pt=head;
p=pt;
if(pt-＞age==iage){
p=pt-＞next;
head=pt=p;
find=1;
}
else pt=pt-＞next;
while(pt!=NULL){
if(pt-＞age==iage){
p-＞next=pt-＞next;
find=1;
}
else p=pt;
pt=pt-＞next;
}
if(!find) printf("Not found%d.",iage);
p=head;
printf("\n NO.name sex age\n");
while(p!=NULL) {
printf("%4s%8s",p-＞num,p-＞name);
printf("%6s%6d",p-＞sex,p-＞age);
p=p-＞next;
}
return 0;
}
【解析】
【难度】2
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
将文本文件A拷贝到文件B中。
【答案】
解：
#include＜stdio.h＞
main()
{
FILE *fp1, *fp2;
int i,j;
if ((fp1=fopen("A","r"))==NULL){
printf("can not open file A.");
exit(0);
}
if ((fp2=fopen("B","W"))==NULL){
printf("can not open file B.");
exit(0);
}
while(!feof(fp1)) fputc(fgetc(fp1),fp2);
fclose(fp1);
fclose(fp2);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
从键盘输入一个字符串，将其中的小写字母全部转换成大写字母，然后输出到一个磁盘文件“test”中保存。输入的字符串以“！”结束。
【答案】
解：
#include ＜stdio.h＞
#include ＜string.h＞
main()
{
FILE *fp;
char str[100];
int i=0;
if((fp=fopen("test","wt"))==NULL){
printf("Can not open the file\n");
exit(0);
}
printf("input a string:\n");
gets(str);
printf("%s\n",str);
while(str[i]!='!') {
if (str[i]＞='a'&&str[i]＜='z')
str[i]=str[i]-'a'+'A';
fprintf(fp,"%c",str[i]);
i++;
}
fclose(fp);
fp=fopen("test","rt");
fgets(str,strlen(str),fp);
printf("%s\n",str);
fclose(fp);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
有30名学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学号、姓名、三门课成绩），计算每名学生的总成绩，并以总成绩排名，然后将学生信息（包括学号、姓名、三门课成绩、总成绩和排名）存放在磁盘文件stud中。
【答案】
#include ＜stdio.h＞
#define N 30
struct student
{
char num[6];
char name[8];
int score[4];
int no;
}stu[N];
void input(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("input scores of student %d:\n",i+1);
printf("NO.:");
scanf("%s",stu[i].num);
printf("name: ");
scanf("%s", stu[i].name);
stu[i].score[3]=0;
for(j=0;j＜3;j++){
printf("score%d:",j+1);
scanf("%d", &stu[i].score[j]);
stu[i].score[3]+=stu[i].score[j];
}
}
printf("\n");
}
void sort(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
stu[i].no=1;
for(j=0;j＜N;j++)
if(stu[j].score[3]＞stu[i].score[3]) stu[i].no++;
}
}
void print(struct student stu[])
{
int i,j;
for(i=0;i＜N;i++){
printf("%5s%10s",stu[i].num,stu[i].name);
for(j=0;j＜4;j++)
printf("%9d",stu[i].score[j]);
printf("%4d\n",stu[i].no);
}
}
void save(struct student stu[])
{
FILE *fp;
int i,j;
if((fp=fopen("student","wt"))==NULL){
printf("Can not open the file\n");
exit(0);
}
for(i=0;i＜N;i++){
printf("%5s%10s",stu[i].num,stu[i].name);
fprintf(fp,"%5s%10s",stu[i].num,stu[i].name);
for(j=0;j＜4;j++){
printf("%9d",stu[i].score[j]);
fprintf(fp,"%9d",stu[i].score[j]);
}
printf("%4d\n",stu[i].no);
fprintf(fp,"%4d\n",stu[i].no);
}
fclose(fp);
}
int main(int argc, char *argv[]) {
input(stu);
sort(stu);
print(stu);
save(stu);
return 0;
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】简答题
【题干】
有一磁盘文件employee内存放职工的数据。每个职工的数据包括：职工姓名、职工号、性别、年龄、住址、工资、健康状况、文化程度。要求将职工名和工资的信息单独抽出来另建一个简明的职工工资文件。
【答案】
#include＜stdio.h＞
#include ＜string.h＞
struct employee
{
char num[6];
char name[10];
char sex[2];
int age;
char addr[20];
int salary;
char health[8];
char class[10];
}em[10];
struct emp
{
char name[10];
int salary;
}em_case[10];
main()
{
FILE *fp1, *fp2;
int i,j;
if ((fp1=fopen("employee","r"))==NULL){
printf("can not open the file.");
exit(0);
}
printf("\n NO. name sex age addr salary health class\n");
for(i=0;fread(&em[i],sizeof(struct employee),1,fp1)!=0;i++) {
printf("\n%4s%8s%4s%6s%10s%6s%10s%8s",em[i].num,em[i].name,em[i].sex, em[i].age, em[i].addr, em[i].salary, em[i].health, em[i].class);
strcpy(em_case[i].name, em[i].name);
em_case[i].salary=em[i].salary;
}
printf("\n\n*****************************************");
if((fp2=fopen("emp_salary","wb"))==NULL)
{
printf("can not open the file.");
exit(0);
}
for(j=0;j＜i;j++){
if(fwrite(&em_case[j],sizeof(struct emp),1,fp2)!=1)
printf("error!");
printf("\n %12s%10d",em_case[j].name,em_case[j].salary);
}
printf("\n*******************************************");
fclose(fp1);
fclose(fp2);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
编写程序，找出1至99之间的全部同构数。同构数是这样一组数：它出现在平方数的右边。例如，5是25右边的数，25是625右边的数，5和25就是同构数。
【答案】
main()
{int i;
for(i=1;i＜100;i++)
if(i*i%10==i||i*i%100==i) printf("%3d",i);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
每个苹果0.8元，第一天买2个苹果，第二天开始买前一天的2倍，直至购买的苹果个数达到不超过100的最大值。编写程序求每天平均花多少钱。
【答案】
main()
{int day=0,buy=2;
float sum=0,ave;
do
{sum=sum+0.8*buy;
day++;buy=buy*2;
}while(buy＜=100);
ave=sum/day;
printf("average=%f\n",ave);
}
【解析】
【难度】3
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
在C程序中,注释说明只能位于一条语句的后面（ ）。
【选项】
A.必须在最开始
B.必须在系统调用的库函数的后面
C.可以任意
D.必须在最后
【答案】
C
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
下面四个选项中,均是合法的浮点数的选项是（ ）。
【选项】
A.+1e+1 5e-9.4 03e2
B.-.60 12e-4 -8e5
C.123e 1.2e-.4 +2e-1
D.-e3 .8e-4 5.e-0
【答案】
B
【解析】
【难度】1
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设a=5,b=6,c=7,d=8,m=2,n=2, 则执行(m=a＞b) ＆＆ (n=c＞d)后n的值为______
【选项】
A.1
B.2
C.3
D.4
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若说明：int a[2][3]; 则对a数组元素的正确引用是____________
【选项】
A. a(1,2)
B. a[1,3]
C. a[1＞2][!1]
D. a[2][0]
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
如果要限制一个变量只能为本文件所使用，必须通过____________来实现
【选项】
A.外部变量说明
B.静态局部变量
C.静态外部变量
D.局部变量说明
【答案】
C
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
3＞2＞1的值为________
【选项】
A.0
B.1
C.2
D.3
【答案】
A
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
若x是int型变量，以下程序段的输出结果是________。
for(x=3;x＜6;x++)
printf((x%2)?(“**%d”):(“##%d\n”),x);
【选项】
A.**3 ##4
B.##3 **4
C.##3 **4##5
D.**3##4 **5
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】假定已有声明“char a[30], *p=a;”，则下列语句中能将字符串"This is a C program. "正确地保存到数组a中的语句是________。
【选项】
A.a[30]= " This is a C program. " ;
B.a= "This is a C program. " ;
C.p= "This is a C program. " ;
D.strcpy(p, "This is a C program. ");
【答案】
D
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】单选题
【题干】
设有以下定义：int a[2][3], (*p)[3]; p=a; 则对a数组元素的非法引用是____________。
【选项】
A.*(a[0]+2)
B.*(p+1)[2]
C.p[0][0]
D.*(p[1]+2)
【答案】
B
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
C源程序的基本单位是_________。
【答案】
函数;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
一个C源程序中至少应包括一个_________。
【答案】
main()函数;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
在C语言中，输入操作是由库函数_________完成的，输出操作是由库函数_________完成的。
【答案】
scanf;printf;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
在C语言中（以16位PC机为例），一个float型数据在内存中所占的字节数为_________；一个double型数据在内存中所占的字节数为_________。
【答案】
4;8;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
在C语言中（以16位PC机为例），一个char型数据在内存中所占的字节数为_________；一个int型数据在内存中所占的字节数为_________。
【答案】
1;2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若a是int 型变量，且a的初值为6，则计算表达式a+=a-=a*a后a的值为_________。
【答案】
－60;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有以下定义，int m=5,y=2;则计算表达式y+=y-=m*=y后y的值是_________。
【答案】
－16;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若a是int型变量，则计算表达式a=25/3%3后a的值为_________。
【答案】
2;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若x和n均是int型变量，且x和n的初值均为5，则计算表达式x+=n++后x的值为_________，n的值为_________。
【答案】
10;6;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有定义:int b=7;float a=2.5,c=4.7;则表达式a+(int)(b/3*(int)(a+c)/2)%4的值为_________。
【答案】
5.5;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若double x=3.0,y=2.0;则表达式pow(y,fabs(x))的值为_________。
【答案】
8.0;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
C语言中的标识符只能由三种字符组成，它们是_________、_________和_________。
【答案】
字符;数字;下划线;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
假设m是一个三位数，从左到右用a、b、c表示各位的数字，则从左到右各个数字是bac的三位数表达式是_________。
【答案】
m/10%10*100+m/100*10+m%10;
【解析】
数字各个位的分离可以先整除再取余，也可以先取余再整除
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若x为int型变量，则执行以下语句后x的值为_________。
x=7;
x+=x-=x+x;
【答案】
-14;
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
main()
{ unsigned char a=8,c;
c=a＞＞3;
printf("%d\n",c);
}程序运行后的输出结果是_____
【答案】
1;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
main()
{int x=0,y=0;
if(!x) y++;
else if(x==0)
if (x) y+=2;
else y+=3;
printf("%d\n",y);
}程序运行后的输出结果是_____
【答案】
1;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序运行后的输出结果是_____
#include＜stdio.h＞
main()
{ int a;
a=(int)((double)(3/2)+0.5+(int)1.99*2);
printf("%d\n",a);
}
【答案】
3;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜stdio.h＞
main ( )
{ int i, j,m=1;
for (i=1; i＜3; i++)
{ for (j=3;j＞0;j--)
{ if(i*j＞3) break;
m*=i*j;
}
}
printf ("m=%d\n", m);
}程序运行后的输出结果是_____
【答案】
m=6;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜stdio.h＞
main ( )
{ int a[3] [3]={{1,2,3},{4,5,6},{7,8,9}};
int b[3]={0},i;
for(i=0;i＜3;i++) b[i]=a[i][2]+a[2][i];
for (i=0; i＜3; i++) printf ("%d", b [i] );
printf ("\n");
}程序运行后的输出结果是_____
【答案】
10,14,18;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜ stdio.h ＞
#include ＜ string.h ＞
main ( )
{ char x[ ] = "STRING";
x[0]= '0';
printf ( " %d %d\n " , sizeof ( x ) , strlen ( x )) ;
}程序运行后的输出结果是_____
【答案】
7, 6;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
struct ord
{ int x,y;}dt[2]={1,2,3,4};
main()
{struct ord *p=dt;
printf("%d,",++(p-＞x)); printf("%d\n",++(p-＞y));
}程序运行后的输出结果是_____
【答案】
2，3;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜ stdio.h ＞
int fun ( )
{ static int x = 2 ;
x += 1 ; return x ;
}
main ( )
{ int i , s = 1 ;
for ( i = 1 ; i ＜= 3 ; i++ ) s += fun ( ) ;
printf ( " %d\n " , s ) ;
}程序运行后的输出结果是_____
【答案】
13;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
# include ＜ stdio.h ＞
void fun ( int x )
{ if ( x / 2 ＞ 0 ) fun ( x / 2 ) ;
printf ( " %d " , x ) ;}
main ( )
{ fun ( 7 ) ; printf ( "\n" ) ; }程序运行后的输出结果是_____
【答案】
1,3,7;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序（函数fun只对下标为偶数的元素进行操作）
#include＜stdio.h＞
void fun ( int *a ,int n )
{ int i , j , k , t ;
for ( i=0 ; i＜n-1; i+=2 )
{ k=i ;
for ( j=i; j＜n ; j+= 2 ) if ( a[ j ] ＞ a [ k ] ) k = j ;
t = a [ i ] ; a [ i ] = a[ k ] ; a[ k ] = t ;
}
}
main ( )
{ int aa[10] = { 1,2,3,4,5,6,7 } , i ;
fun(aa,7);
for( i = 0 ; i ＜ 7 ; i++ ) printf ( " %d, ",aa[ i ] );
printf( "\n" ) ;
}程序运行后的输出结果是_____
【答案】
7，2，5，4，3，6，1;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下fun函数的功能是：找出具有N个元素的一维数组中的最小值，并作为函数值返回。（设N已定义）
int fun ( int x[ N ] )
{ int i , k = 0 ;
for ( i = 0 ; i ＜ N ; i ++ )
if ( x[ i ] ＜ x[ k ] ) k =_____;
return x [ k ] ;
}
【答案】
i;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
己知a所指的数组中有N个元素。函数fun的功能是，将下标k(k＞0)开始的后续元素全部向前移动一个位置。请填空。
#define N 10
void fun(int a[ ],int k)
{ int i;
for(i=k;i＜N;i++) a[ _____ ]=a[i];
}
【答案】
i-1;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：借助指针变量找出数组元素中最大值所在的位置并输出该最大值。请在输出语句中填写代表最大值的输出项。
#include＜stdio.h＞
main ( )
{ int a[ 10 ] , *p , *s ;
for ( p = a ; p - a ＜ 10 ; p ++ ) scanf ( " %d " , p ) ;
for ( p = a , s = a ; p - a ＜ 10 ; p ++ ) if ( *p ＞ * s ) s = p ;
printf ( "max = %d\n ", _____ );
}
【答案】
*s;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序用以删除字符串中所有的*
#include ＜stdio.h＞
main ( )
{ char s[100]; int i,j;
gets(s);
for(i=j=0;s[i] !='\0'; _____ )
if(s[i] !='*') {s[j]=s[i] ; _____ ; }
s[j]= '\0' ;
printf ("%s\n", s);
}
【答案】
i++;j++;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
设有函数fun的功能为计算字符串的长度（等同于strlen函数的功能）
int fun ( char *a )
{int i;
for(i=0;*(a+i)!='\0';i++) ; return _____；
}
【答案】
i;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下函数的功能是：通过键盘输入数据，为数组中的所有元素赋值。
#define N 10
void fun(int x[ ] )
{ int i=0;
while(i＜=N)
scanf("%d", _____);}
在程序中下划线处应填入的是
【答案】
x+(i++);
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数fun实现将输入的字符串逆序存放，程序的输出结果为654321
#include＜stdio.h＞
#include＜string.h＞
void fun(char *w, int m){char s, _____ ;
p1=w;p2=w+m-1;while(p1＜p2){s=*p1;*p1=*p2; _____ ;p1++;p2--;}
}
main( )
{char a[]="123456";
fun(a,strlen(a));puts(a);
}
【答案】
*p1,*p2;*p2=s;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：将值为三位正整数的变量x中的数值按照个位、十位、百位的顺序拆分并输出
#include ＜stdio.h＞
main ( )
{int x=256;printf ( "个位%d ", _____ );
printf ( "十位%d",x/10 %10 );printf ( "百位%d", _____ );
}
【答案】
x%10;x/100;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能为交换变量x、y的数据值
#include＜stdio.h＞
main()
{ int x=10,y=20,t=0;
t=x;x=y; _____ ；
printf("%d %d\n",x,y);
}
【答案】
y=t;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序，函数fun的功能为将字符串的最后一个字符移到字符串最前面，
例，输入：abcdef＜回车＞，输出：fabcde
#include ＜stdio.h＞
#include ＜string.h＞
void fun (char *str)
{ char temp; int n,i;
n=strlen (str); //字符串长度
temp= _____ ; //结束标记前的最后一个字符
for (i=n-1; i＞0; i--) str[i] =str[i-1]; //字符串中所有字符均后移一位
str [0] =temp; //原字符串中最后一个字符放在字符串首位
}
main ( )
{ char s[50];scanf ("%s", s); fun(_____ ); printf ("%s\n", s); }
【答案】
str[n-1];s;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数fun的功能是：用起泡(冒泡)的方式将N个元素的一维数组中的最大值放在数值的最后一个位置上。（设N已定义）
void fun ( int x[ N ] )
{ int i , t ;
for ( i = 0 ; i ＜ N ; i ++ )
if ( _____ ) {t=x[i];x[i]=x[i+1];x[i+1]=t;}
}
【答案】
x[i]＞x[i+1];
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
int fun (int x,int y)
{ if (x!=y) return ((x+y)/2);
else return (x);
}
main()
{ int a=4,b=5,c=6;
printf("%d\n",fun(2*a,fun(b,c)));
}
程序运行后的输出结果是_____
【答案】
6;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
# include ＜ stdio.h ＞
main ( )
{ int a = 1, b = 0 ;
if (!a) b++ ;
else if (a == 0) if (a) b += 2 ;
else b += 3 ;
printf (“%d\n” , b) ;
}
程序运行后的输出结果是_____
【答案】
0;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
main()
{int s;
scanf("%d",&s);
while(s＞0)
{ switch(s)
{case 1:printf("%d",s+5);
case 2:printf("%d",s+4); break;
case 3:printf("%d",s+3);
default:printf("%d",s+1);break;
}
scanf("%d",&s);
}
}
运行时，若输入1 2 3 4 5 0＜回车＞，则输出结果是_____
【答案】
6566456;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
# include ＜stdio.h＞
main ( )
{ int a = 1, b = 2;
while ( a ＜ 6 ) { b+=a; a+=2; b %=10 ; }
printf ( " %d , %d \n " , a , b ) ;
}程序运行后的输出是__________
【答案】
7，1;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜stdio.h＞
main ( )
{ int m, n;
scanf("%d%d", &m, &n);
while (m!=n)
{ while (m＞n) m=m-n;
while (m＜n) n=n-m;
}
printf ("%d\n",m);
}
程序运行后，当输入14 63 ＜回车＞时，输出结果是_____
【答案】
7;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include＜stdio.h＞
int fun()
{ static int x=1;
x*=2;
return x;
}
main()
{ int i,s=1;
for(i=1;i＜=3;i++) s*=fun();
printf("%d\n",s);
}程序运行后的输出结果是_____
【答案】
64;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜stdio.h＞
main ( )
{int a[5]={1,2,3,4,5}, b[5]={0,2,1,3,0},i,s=0;
for(i=0;i＜5;i++) s=s+a[b[i] ];
printf ("%d\n", s);
}程序运行后的输出结果是__________
【答案】
11;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序
#include ＜stdio.h＞
main ( )
{ int a=1, b=2;
for(;a＜8;a++) {b+=a; a+=2; }
printf ("%d, %d\n", a,b) ;
} 程序运行后的输出结果是_____
【答案】
10，14;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序，要求当输入how are you? I am fine＜回车＞ 时，输出结果是how
are you?I am fine
#include＜stdio.h＞
main()
{ char a[30],b[30];_____ ("%s",a);_____;
printf("%s\n %s\n",a,b);
}
【答案】
scanf;gets(b);
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序(说明：字母A的ASCII码值是65)
#include＜stdio.h＞
void fun(char *s)
{while(*s)
{if(*s%2) printf("%c",*s);
s++;}
}
main()
{ char a[]="BYTE";
fun(a); printf("\n");
}
程序运行后的输出结果是_____
【答案】
YE;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：借助指针变量找出数组元素中的最大值及其元素的下标值。请填空。
#include ＜stdio.h＞
main ( )
{ int a[10 ] ,*p,*s;
for(p=a;p-a＜10 ;p++) scanf("%d",p);for (p=a, s=a; p-a＜10 ; p++) if (*p＞*s) s=_____ ;
printf ("index=%d\n'', s-a) ;
}
【答案】
p;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序用以删除字符串中所有的空格，请填空。
#include ＜stdio.h＞
main ( )
{ char s[100]={"Our teacher teach C language!"}; int i,j;
for(i=j=0;s[i] !='\0';i++ )
if(s[i] !=' ') {s[j]=s[i] ;j++; }s[j]=_____;
printf ("%s\n", s);
}
【答案】
’\0’;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序,程序运行后的输出结果是 “BBB” 。请填空。
#include＜stdio.h＞
main()
{char ch [3][5]={"AAAA","BBB","CC"};printf ("%s\n", _____ );
}
【答案】
ch[1];
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下函数,功能是统计x和y所指字符串中最前面连续相同的字符个数。请填空。
int fun(char *x,char *y)
{int n=0;while(( _____ )&&*x!='\0'){x++;y++;n++;}
return n;
)
【答案】
*x==*y;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序, 程序运行后的输出结果是 8 。请填空。
#include＜stdio.h＞
main()
{int a=2,b;b=_____;printf("%d\n",b);
}
【答案】
a＜＜2;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下fun函数的功能是在N行M列的整型二维数组中，选出一个最大值作为函数值返回，请填空。（设M，N已定义）
int fun ( int a[ N ][ M ] )
{ int i , j row = 0 , col = 0 ;
for ( i = 0 ; i ＜ N ; i ++ )
for ( j = 0 ; j ＜ M ; j ++ ) if (_____ ＞ a[ row ][ col ] ) { row = i ; col = j ; } return （_____）;
}
【答案】
a[i][j];a[row][col];
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序功能是，顺序输出26个英文字符，要求奇数位英文字符输出成大写，偶数位输出成小写，AbCdEf……
#include＜stdio.h＞
main()
{char b,c; int i;
b='a'; c='A';
for(i=0;i＜26;i++) {if(i%2) putchar(_____); else putchar(_____);}
printf("\n");
}
【答案】
i+b;i+c;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序, 运行后的输出结果是 “ABCDIJK”（strcat函数用以连接两个字符串）。请填空。
#include ＜stdio.h＞
#include ＜string.h＞
main ( )
{ char a[ 20 ] = "ABCD\0EFG\0" , b[ ] = "IJK" ; strcat ( a,b ) ; printf ( " % s\n " , _____) ;
}
【答案】
a;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
有以下程序,程序运行后的输出结果是 123569 。请填空。
#include ＜stdio.h＞
main ( )
{ int i,j,a[ ] [3]={1,2,3,4,5,6,7,8,9};
for (i=0; i＜3; i++)
for _____;j＜3;j++) printf ("%d", a [i] [j]);
printf ("\n");
}
【答案】
j=i;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序调用fun函数把x中的值插入到a数组下标为k的数组元素中。主函数中，n存放a数组中数据的个数。请填空。
#include＜stdio.h＞
void fun(int s[],int *n,int k,int x)
{int i; for(i=*n-1;i＞=k;i--) s[_____]=s[i];
s[k]=x; *n=*n+_____ ;
}
main()
{int a[20]={1,2,3,4,5,6,7,8,9,10,11},i,x=0,k=6,n=11;
fun(a,&n,k,x);
for(i=0;i＜n;i++)printf("%4d",a[i]);printf("\n"); }
【答案】
i+1;1;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是_____。
main()
{int a[10]={9,2,5,3,1,4,8,7,6,0};
int min,i,x,j;
for(j=0;j＜9;j++)
{min=j;
for(i=j+1;i＜=9;i++)
if(a[min]＞a[i]) min=i;
x=a[j];a[j]=a[min];a[min]=x;
}
for(j=0;j＜=9;j++)
printf("%3d",a[j]);
}
【答案】
0 1 2 3 4 5 6 7 8 9;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是_____。
fun(int x)
{static b=7;
return (b+++x);
}
main()
{int x=5;
printf("%d",fun(x));
printf("%d",fun(x));
}
【答案】
1213;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
#include ＜stdio.h＞
int f(int t[ ],int n);
main ( )
{int a[4]={1,2,3,4},s;
s=f(a,4); printf ("%d\n", s);
}
int f(int t[ ], int n)
{ if(n＞0) return t[n-1]+f(t,n-1);
else return 0;
}
【答案】
10;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是_____。
#include ＜stdio.h＞
void fun (char *c,int d)
{ *c=*c+1; d=d+1;
printf("%c,%c,",*c,d) ;
}
main ( )
{ char b='a',a='A';
fun(&b,a) ; printf("%c,%c\n",b,a) ;
}
【答案】
b,B,b,A;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
#include＜stdio.h＞
main()
{
int m=1,n=2,*p=&m,*q=&n,*r;
r=p;p=q;q=r;
printf(“%d,%d,%d,%d \n”,m,n,*p,*q);
}
【答案】
1,2,2,1;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
#include ＜stdio.h＞
#define SUB(a) (a)-(a)
main ( )
{ int a=2,b=3,c=5,d;
d=SUB (a+b) *c;
printf (" %d\n", d) ;
}
【答案】
-20;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
int a=0;
void fun(int b)
{ int a=10;
a+=b ;
printf("%d",a) ;
}
main()
{ int c=20;
fun(c);
a+=c;
printf("%d\n",a);
}
【答案】
3020;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
#include ＜ stdio.h ＞
main ( )
{ char s[ ] = "rstuv" ;
printf ( "%c\n" , *s+2 ) ;
}
【答案】
t;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
#include＜stdio.h＞
main( )
{ int a=1, b=0 ;
if (!a) b++;
else if (a==0)
if (a) b+=2;
else b += 3 ;
printf ("%d\n" , b) ;
}
【答案】
0;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序运行后的输出结果是________。
main()
{int i,k;
for(i=0;i＜4;i++,i++)
for(k=1;k＜3;k++)
printf("*");
}
【答案】
****;
【解析】
【难度】1
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
用while循环求1到100的整数之和。
#include＜stdio.h＞
void main()
{int i,s;
s=0;i=1; _____
{s+=i;
i++ ; }
printf("s=%d\n",s);
}
【答案】
while(i＜=100);
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
判断一个字符串是否为回文串，举例来说“abc”不是一个回文串，“abcba”是一个回文串。
main()
{char a[20];
gets(a);
if(fun(a)) printf("是回文串");
else printf("不是回文串");
}
fun(char a[])
{int j=strlen(a)-1,i=0;
for(;i＜j;i++,j--) if(a[i]!=a[j]) _____ ;
if(i＜j) return 0;
else return 1;
}
【答案】
break;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序填空：用二分法求下列方程在(-10,10)区间的根：2x3-4x2+3x-6=0
（提示：二分法算法思想：设函数在某一区间内为单调函数，而且有一个实根。
1）取区间两端点x1和x2，判断区间[x1,x2]有无一个实根；若f(x1)×f(x2)＜0,则[x1,x2]之间必有一实根。取[x1,x2]的中点x, 即x=(x1+x2)/2 ；
2）区间的取舍：判段f(x)*f(x2)是否同号，若f(x)*f(x2)＜0则：x1=x，即舍去[x1,x]区间，否则，x2=x，即舍去[x,x2]区间；
3）再根据新的x1、x2求出中点x，重复上述步骤。当fabs(x1-x2)小于某一给定的数时，x为近似根。）
#include＜math.h＞
#include＜stdio.h＞
void main( )
{float x1=-10,x2=10,eps=1e-5,f1,f2,f0,x;
f1=2.0*x1*x1*x1-4.0*x1*x1+3*x1-6;
f2=2.0*x2*x2*x2-4.0*x2*x2+3*x2-6; if(f1*f2＜0_)
while(fabs(x2-x1)＞=eps) {_____;
f0=2.0*x*x*x-4.0*x*x+3*x-6; if(f1*f0＜0) {x2=x;_____} else{_____; f1=f0;}
}
printf("2x^3-4x^2+3x-6=0,Its root=%12.6f\n",x);}
【答案】
x=(x1+x2)/2;f2=f0;x1=x;
【解析】
【难度】1
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
函数fun的功能是将一个字符串中的空格删除掉。
fun(char a[])
{int i,j=0;
for(i=0;a[i];i++) if(a[i]!=' ') _____; //判断是否为空格
a[j]='\0';
}
main()
{char a[20];
gets(a);fun(_____);
puts(a);}
【答案】
a[j++]=a[i];a;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】用牛顿迭代法求方程：4x3-3x2+2x-7=0在1.5附近的根。要求前后两次求出的根的差的绝对值小于10-5。#include_____
#include ＜stdio.h＞
void main()
{ float x,x0,f,f1;
x=1.5; do{x0=x_;
f=((4*x0-3)*x0+2)*x0-7;
f1=(12*x0-6)*x0+2; x=_____ } while(fabs_____＞=1e-5);
printf("root=%f\n",x);}
【答案】
math.h;x0-f/f1;(x-x0)或(x0-x);
【解析】
【难度】1
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
冒泡法将数值元素按从小到大顺序排列。
main()
{int a[10]={6,9,5,3,8,7,1,2,0,4};
int x,i,j;
for(j=0;j＜9 ;j++)
for(i=0;i＜9-j;i++)
if(a[i]＞a[i+1]) {_____}
}
【答案】
x= a[i],a[i]= a[i+1],a[i+1]=x;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
二分法查找键盘输入的数据是否存在于数组中，如果存在，输出在数值中相同值的位置；如果不存在，则在屏幕输出not found。
int mid;
int fun(int x,int a[]) //l表示左端位置，r表示右端位置，mid表示折半的中间点位置//
{int l=0,r=9;
for(;l＜=r;)
{mid=(l+r)/2;
if (x==a[mid]) return mid;
else if(x＞a[mid]) l=mid+1; else _____ ;
}
return -1;
}
main()
{int a[10]={2,4,6,8,10,12,14,16,18,20};
int x;
printf("输入待查找的数据:");
scanf("%d",&x); if(fun(x,a)==-1) printf("_______");
else printf("在数组的第%d个位置上",mid+1);
}
【答案】
r=mid-1;not found;
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序段的运行结果_____
#include ”stdio.h”
void main()
{
char ch1=’a’,ch2=’A’;
switch (ch1)
{ case ’a’:
switch (ch2)
{case ’A’: printf(”good!\n”); break;
case ’B’: printf(”bad!\n”); break;
}
case ’b’: printf(”joke\n”);
}
}
【答案】
good！,joke;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序运行结果是_____
#include＜stdio.h＞
void main()
{
int a[3][3]={1,2,3,4,5,6,7,8,9},i,s1=0,s2=1;
for(i=0;i＜=2;i++)
{ s1=s1+ a[i][i];
s2=s2*a[i][i];};
printf("s1=%d,s2=%d",s1,s2);
}
【答案】
s1=15 ,s2=45;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序运行的结果是_____
#include＜stdio.h＞
void main()
{ int a,b;
for(a=1,b=1;a＜=100;a++)
{ if(b＞=20) break;
if(b%3==1)
{ b+=3;
continue;
}
b-=5;
}
printf("%d\n",a);
}
【答案】
8;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序运行后的输出结果是_____
#include ”stdio.h”
void main()
{
int x=10, y=20, t=0;
if (x==y) t=x; x=y; y=t;
printf(”%d,%d\n”,x,y);
}
【答案】
20，0;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序从键盘输入：5647，输出结果是_____
#include＜stdio.h＞
void convert(int n)
{
int i;
if((i=n/10)!=0)
convert(i);
putchar(n%10+’0’);
}
void main()
{
int number;
scanf("%d",&number);
if(number＜0)
{ putchar(‘-’);
number= -number;
}
convert(number);
}
【答案】
5647;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
输入I am a student.时，下面程序运行结果是_____
#include＜stdio.h＞
void main()
{
int i,c,num=0,word=0;
char string[81];
gets(string);
for(i=0;c=string[i];i++)
if(c==’ ’)
word=0;
else if(word==0)
{word=1;
num++;}
printf("%d",num);
}
【答案】
4;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_____
#include＜stdio.h＞
void swap(int *a, int *b)
{
int *t;
t=a;
a=b
b=t;
}
void main()
{
int x=3, y=5, *p=&x, *q=&y;
swap(p,q);
printf("%d %d\n", *p, *q);
}
【答案】
3 5;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_____
#include＜stdio.h＞
#define N 10
#define s(x) x*x
#define f(x) (x*x)
void main()
{
int i1,i2;
i1=1000/s(N);
i2=1000/f(N);
printf("%d,%d\n",i1,i2);
}
【答案】
1000，10;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序的运行结果是_____
#include＜stdio.h＞
void main()
{ int fun(int a);
int a=2,i;
for(i=0;i＜3;i++)
printf("%2d",fun(a));
}
int fun(int a)
{int b=1;
static int c=1;
b++;
c++;
return(a+b+c);
}
【答案】
6 7 8;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_____
#include＜stdio.h＞
void main()
{char a[]="programming", b[]="language";
char *p1,*p2;
int i;
p1=a;
p2=b;
for(i=0;i＜7;i++)
if(*(p1+i)==*(p2+i))
printf("%c",*(p1+i));
}
【答案】
ga;
【解析】
【难度】2
【分数】3.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是:将字符数组a中下标值为偶数的元素从小到大排列,其它元素不变。请填空。
#include ＜stdio.h＞
#include ＜string.h＞
main()
{
char a[]="clanguage",t;
int i, j, k;
k=strlen(a);
for(i=0; i＜=k-2; i+=2) for(j=i+2; j＜=k;_____)
if(_____)
{ t=a[i]; a[i]=a[j]; a[j]=t; }
puts(a);
printf("\n");
}
【答案】
j+=2;a[i]＞a[j];
【解析】
【难度】3
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面程序根据对x的输入，求1到x的累加和。
#include＜stdio.h＞
float fun(int n)
{
int i;
float c; _____ ;
for(i=1;i＜=n;i++)
c+=i;
return(c) ;
}
void main()
{
int x;scanf("%d",_____);
printf("%f\n",fun(x));
}
【答案】
c=0;＆x;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
下面函数的功能是：求x的y次方，请填空。
double fun( double x, int y)
{
int i;
double z;for(i=1, z=x; i＜y;i++) z=z*_____;
return(z);
}
【答案】
x;
【解析】
【难度】1
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】程序填空：用迭代法求的值。求平方根的迭代公式为：，要求前后二次求出的x的差的绝对值小于10-6。
#include ＜math.h＞
#include ＜stdio.h＞
void main()
{int a; float xn0, xn1;
scanf("%d",&a);
xn0=a;
xn1=(xn0+a/xn0)/2; while(fabs(xn0-xn1) _____)
{xn0= xn1; xn1=_____;}
printf("%d sqrt %8.4f ", a, xn1);
}
【答案】
＞=1e-6;(xn0+a/xn0)/2;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序将数组a中的数据按逆序存放。请填空。
#include "stdio.h"
#define M 10
main()
{
int a[M], m, n, temp;
for( m=0; m＜M; m++) scanf ("%d", a+m);
m=0;
n=M-1;
while(m＜n)
{
temp=*(a+m); _____;
*(_____)=temp;
m++;
n--;}
for (m=0;m＜M;m++) printf("%3d", *(a+m));
}
【答案】
*(a+m)=*(a+n);a+n;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
将已知字符串中的空格删去。
#include ＜stdio.h＞
void main( ){_____="Our teacher teachs C language";
int j, k;
2for(j=k=0;s[j]!='\0';j++)
if(s[j]!= ' ')
s[k++]=s[j]; _____;
printf("%s",s);
}
【答案】
char s[];s[k]=’\0’;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
任意读入10个字符串，然后按从小到大的顺序输出。
#include ＜string.h＞
#include ＜stdio.h＞
main()
{char c[10][80], t[80];
int i, j;
for(i=0;i＜10;i++)
gets(*(c+i));
for(j=1;j＜=9;j++)
for(i=0;i＜10-j;i++)
if(_____)
{strcpy(t, c[i]);
strcpy(c[i], c[i+1]);
strcpy(c[i+1], t);}
for(i=0;i＜10;i++) _____(*(c+i));
}
【答案】
strcmp(c[i],c[i+1])＞0;puts;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
某高三毕业班有三名同学（Guo、Liu、Hu）获得全国数学竞赛二等奖，现只有一个南京大学的保送名额，必须通过投票选举出得票最高的同学保送南大。假设全班共有50名同学全部参加了投票，每人推举一名候选人，选票全部有效。以下程序输出三名候选人的得票数。
#include＜stdio.h＞
#include "string.h"
#define N 50
struct HXR
{char name[10];
int dps;
};
void main()
{struct HXR stu[3]={{"Guo",0},{"Liu",0},{"Hu",0}};
int i,j;
char name[10];
for(i=0;i＜N;i++) /*本循环完成唱票*/ {_____;
for(j=0;j＜3;j++) if(strcmp(name,stu[j].name)==0)_____;}
printf("姓名 得票数:\n");
for(i=0;i＜3;i++)
printf("%-5s%-3d\n",stu[i].name,stu[i].dps);
}
【答案】
scanf("%s",name);stu[j].dps++;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】在C语言中，当关系表达式中的关系成立时，关系表达式的值为_____。
【答案】
1;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】在C语言中，_____语句的功能是提前结束本次循环体的执行过程而直接进入下一次循环。
【答案】
continue;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】数学式 “-b+” 对应的C语言表达式是_____。
【答案】
-b+sqrt(b*b-4*a*c);
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】在程序中需要调用strcpy函数时必须包含头文件_____
【答案】
string.h;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】定义int i=1; 执行语句"while(i++＜5)";后,i的值为_____。
【答案】
6;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】已知有声明和语句“int a;scanf(＂a=%d＂,&a);”，欲从键盘上输入数据使a中的值为3，则正确的输入应是_____
【答案】
a=3;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
假定指针变量p指向对象的值为16，p+1指向对象的值为35，则*p++的值_____
【答案】
16;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】若用数组名作为实参，则传递给形参的是 _____
【答案】
数组首地址;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】若有定义：int a[2][3]={2,4,6,8,10,12}; 则*(a[1]+2)的值是 _____
【答案】
12;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】若有声明"int a=0,b=1,c=2;",执行语句"if(a＞0&&++b＞0)c++;else c--;"后,变量b、c的值为_____。
【答案】
1 1;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序运行时输出到屏幕的结果为_____
#include＜stdio.h＞
void swap(int a,int b)
{int t;
if (a＞b) t=a,a=b,b=t;
}
main()
{int x=13,y=11,z=12;
if(x＞y) swap(x,y);
if(x＞z) swap(x,z);
if(y＞z) swap(y,z);
printf("%d,%d,%d\n",x,y,z);
}
【答案】
13,11,12;
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序的输出结果是 _____
main()
{int a[4][4]={{1,2,3,4},{5,6,7,8},{11,12,13,14},{15,16,17,18}};
int i=0,j=0,s=0;
while(i++＜4)
{if(i==2||i==4) continue;
j=0;
do{s+=a[i][j]; j++;}while(j＜4);
}
printf("%d\n",s);
}
【答案】
92;
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序的输出结果是 _____
#include＜stdio.h＞
main()
{int a=1,b=2;
a+=b;
b=a-b;
a-=b;
printf("%d,%d\n",a,b);
}
【答案】
2,1;
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序运行时输出到屏幕的结果中第一行是 _____，第二行是 _____ 。
#include＜stdio.h＞
int fun(int x)
{ static int y=2;
int z=0;
y-=x;
z+=y;
return z;
}
main()
{ int x;
for(x=1;x＜3;x++)
printf("%d\n",fun(x));
}
【答案】
1;-1;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】下面程序的运行结果为：_____，其中函数abc的功能是：_____
#include "stdio.h"
int abc(int u,int v);
main()
{ int a=24,b=16,c;
c=abc(a,b);
printf("%d\n",c);}
int abc(int u,int v)
{ int w;
while(v)
{ w=u%v;u=v;v=w;}
return u;}
【答案】
8;求整数u和v的最大公约数;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】下面程序的运行结果第二行是_____；第三行是 _____。
#include ＜stdio.h＞
int k=1;
main()
{ int i=4;
fun(i);
printf("%d,%d\n", i, k);}
fun(int m)
{ m+=k;
k+=m;
{ char k='B';
printf("%d\n", k-'A');}
printf("%d,%d\n", m, k);}
【答案】
5,6;4,6;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】以下程序运行时输出到屏幕的结果第一行是 _____，第二行是 _____。
#include＜stdio.h＞
void fun(char *p1,char *p2);
main()
{int i; char a[]="54321";
puts(a+2);
fun(a,a+4);
puts(a);
}
void fun(char *p1,char *p2)
{char t;
while(p1＜p2)
{t=*p1;*p1=*p2;*p2=t;
p1++,p2--;
}
}
【答案】
321;12345;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】下面程序的运行结果为：_____。
#include＜stdio.h＞
main( )
{ int w=3;
fun(w);
printf("\n");}
fun(int k)
{ if(k＞0)
fun(k-1);
printf("%d",k);
}
【答案】
0123;
【解析】
【难度】2
【分数】2.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
输出任意读入的一个十进制整数的二进制形式代码。
#include＜stdio.h＞
#define N 20
main()
{int x , i , j , a[N];
char fh='+';
scanf("%d", &x);
if(x＜0)
{x=-x ; fh='-';}
printf("%c", fh);
i=0;
do
{a[i]=x%2;
_____;
i++;
}while(_____);
for(j=_____; j＞=0; j--)
printf("%1d",a[j]);
printf("\n");
}
【答案】
x=x/2;x!=0;i-1或- -i;
【解析】
【难度】3
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序由终端键盘输入一个文件名，然后把输入的字符依次存放到该文件中，用#号作为结束输入的标志。
#include＜stdio.h＞
main()
{_____
char ch,fname[10];
printf("Enter the name of file\n");
gets(fname);
if((fp=_____)==NULL)
{printf("Open error!\n"); exit(0);}
printf("Enter data:\n");
while((ch=getchar())!='#') fputc(ch,fp);
fclose(fp);
}
【答案】
FILE *fp;fopen(fname,”w”);
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：用折半查找法判断任意读入的整数是否在有序数组中。
#include＜stdio.h＞
#define n 11
main()
{int x,low,mid,high,find;
static int a[]={2,5,11,18,24,35,42,50,58,86,92};
scanf("%d",&x);
low=0;
_____;
find=0;
while((low＜=high)&&!find)
{mid=(low+high)/2;
if(x==a[mid])
_____;
else
if(_____)
low=mid+1;
else
_____;}
if(find)
printf("It's successful:a[%d]=%d\n", mid, x);
else
printf("It's fail to find %d", x);
}
【答案】
high=n-1或high=11-1 high=10;find=1;x＞a[mid];high=mid-1;
【解析】
【难度】3
【分数】8.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序中函数fun的功能是：根据下列公式计算并返回s的值（n0）。
#include＜stdio.h＞
float fun(int n)
{float s=0.0,w,f=-1.0;int i;
for(i=0;i＜=n;i++) {f=_____;
w=f/(2*i+1);_____;
}
return s;
}
main()
{int n=5; float s;s=_____ ;
printf("%f\n",s);
}
【答案】
-f;s+=w;fun(n)或fun(5);
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
设某班级有学生30名，学期末统计每位学生各课程成绩总分后，将前10名学生的学号、姓名、总分张榜公布，以下程序输出张榜清单。
#include＜stdio.h＞
#define N 30
main()
{struct STU
{long num;
char name[20];
int score; };
struct STU a[N],t;
int i , j , k;
for(i=0;i＜N;i++) scanf ("%ld%s%d", &a[i].num ,_____ , &a[i].score);
for(i=0;i＜N-1;i++)
{k=i; for(j=i+1; _____;j++) if(_____) k=j;
if(i!=k)
{t=a[i];
a[i]=a[k];
a[k]=t;
}}
printf("Number Name Score\n");
for(i=0;i＜10;i++)
printf("%-10ld%-10s%-8d\n",a[i].num , a[i].name , a[i].score);}
【答案】
a[i].name;j＜N;a[j].score＞a[k].score;
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】用牛顿迭代法求方程2x3-4x2+3x-6=0在1.5附近的根。【算法提示】：牛顿迭代法又称牛顿切线法：先任意设定一个与真实的根接近的值x0作为第一个近似根，由x0求出f(x0)，过(x0,f(x0))点做f(x)的切线，交x轴于x1，把它作为第二次近似根，再由x1求出f(x1)，再过(x1,f(x1))点做f(x)的切线，交x轴于x2，再求出f(x2)，再作切线……如此继续下去，，直到足够小时（）为止。则认为为方程的近似值。
牛顿迭代公式：
#include＜stdio.h＞
_____
main()
{float x1,x,f,f1;
x=1.5;
do{ _____;
f=2.0*x*x*x-4.0*x*x+3*x-6;
f1=6.0*x*x-8.0*x+3; x=_____;}
while(fabs(x-x1)＞=1e-6);
printf("2x^3-4x^2+3x-6=0,Its root is%f\n",x);
}
【答案】
#include＜math.h＞;x1=x;x1-f/f1;
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
牛顿切线法又称________________________，可以用来对一元非线性方程求根。
【答案】
牛顿迭代法;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
设有声明“int a=3,b=4; float x=4.5,y=3.5;”，则表达式“(float)(a+b)/2+(int)x%(int)y”的值是________。
【答案】
4.5;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
已知有函数定义“int fun(){return(3,4);}”，则调用fun后的函数返回值是________。
【答案】
4;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
可以改变局部变量的生存期、但不能改变它的作用域的存储类别是________。
【答案】
static;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
执行以下程序，输入689后，k的值是_________。
#include ＜stdio.h＞
main()
{int x, k;
scanf("%d",&x);
k=x＞0?1:x＜0?-1:0;
printf("%d,%d\n", x , k);}
【答案】
1;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
在一个C语言源程序中，必不可少的是_________函数。
【答案】
主 或 main;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有声明“int a=15,b=20,c=25,e; ”，则执行语句“e=a＞b?--c:++c; ”后变量e的值是________。
【答案】
26;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
变量名________与关键字同名（填写“可以/不可以”）。
【答案】
不可以;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
若有声明“char a[]= "ABCD"; char *p=a;”，执行语句“printf("%s",＆p[2]);”后输出结果是________。
【答案】
CD;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
程序段“int x=3; do{printf("%d ", x--);}while(!x);”的输出结果是________。
【答案】
3;
【解析】
【难度】1
【分数】1.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
当输入65时，以下程序的输出结果是_____；若将最后一个“break”去掉，再输入65时，
以下程序的输出结果是_____。
#include ＜stdio.h＞
main()
{int fs;
do
{printf("Input 0＜=fs＜=100\n");
scanf("%d",&fs);
}while(fs＜0||fs＞100);
switch(fs/10)
{case 10:
case 9: printf("A"); break;
case 8: printf("B"); break;
case 7: printf("C"); break;
case 6: printf("D"); break;
default: printf("E");
}
}
【答案】
D;DE;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序运行后的输出结果是_____；若将程序中的“||”改成“&&”，则程序的
输出结果是_____。
#include ＜stdio.h＞
main()
{int x,a,b;
a=b=8;
x=a++||++b;
printf("x=%d,a=%d,b=%d\n",x,a,b);
}
【答案】
x=1,a=9,b=8;x=1,a=9,b=9;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
运行下列程序，输入字符串"Albert"后，输出结果是_____，本程序的功能是_____。
#include ＜stdio.h＞
main()
{char a[100];
int n;
gets(a);
n=0;
while(a[n]!= '\0')n++;
printf("%d\n",n);
}
【答案】
6;计算字符串的串长;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的输出结果是_____；将“static”去掉，再运行程序，最终变量f的值为_____。
#include ＜stdio.h＞
#define N 5
long JC( );
main()
{int i;
long f;
for(i=1;i＜=N;i++)
f=JC(i);
printf("%d!=%ld\n",N,f);
}
long JC(int n)
{static long jc=1;
jc=jc*n;
return jc;
}
【答案】
5!=120;5;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
运行下列程序后，第一行的输出结果是_____，最后一行的输出结果是_____。
#include ＜stdio.h＞
#define N 5
main()
{int a[N][N],i,j;
for(i=0;i＜N;i++)
for(j=0;j＜N;j++)
a[i][j]=i+j+1;
for(i=0;i＜N;i++)
{for(j=0;j＜N;j++)
printf("%3d",a[i][j]);
printf("\n"); }
}
【答案】
1 2 3 4 5;5 6 7 8 9;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序执行时，若输入6，则输出结果是_____；程序中函数的调用方式称为_____调用。
#include ＜stdio.h＞
void tran(int n)
{ if (n/2!=0) tran(n/2);
printf("%d",n%2);
}
main()
{int x;
scanf("%d",&x);
if(x＜0){printf("-"); x=-x;}
tran(x);
printf("\n");
}
【答案】
110;递归;
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：输出1000以内的所有素数，并将输出结果保存到D盘TEST文件夹中的
SS.out文件中。
#include ＜stdio.h＞
_____
main()
{int x, k, flag , n=0;
FILE *fp;
fp=_____;
for(x=2;x＜=1000;x++)
{_____;
for(k=2;k＜=sqrt(x);k++)
if(x%k==0) {flag=0; _____;}
if(flag==1)
{if(n%10==0) {printf("\n"); fprintf(fp,"\n");}
n++;
printf("%5d",x);
fprintf(fp,"%5d",x); }
}
fclose(fp);
}
【答案】
#include ＜math.h＞;fopen("D:\\TEST\\SS.out","w");flag=1;break;
【解析】
【难度】3
【分数】8.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：调用子函数求得任意读入的5个字符串中的最大串。
#include ＜string.h＞
#include ＜stdio.h＞
#define N 20
main()
{void MAX( );
char a[5][N];
int i;
extern char *px;
for(i=0;i＜5;i++)
gets(a[i]);
MAX(a,5);
puts(px);
}
_____;
void MAX(p,n)
_____
int n;
{int i;
px=p[0];
for(i=1;i＜n;i++)
if(strcmp(p[i],px)＞0) _____
}
【答案】
char *px;char (*p)[N];px=p[i];
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：求a数组中前4个元素之和及后6个元素之和。
#include＜stdio.h＞
int fsum(int *array, int n)
{int i,s;
s=0;
for(i=0; _____; i++)
s+=array[i];
_____;
}
main()
{int a[15]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int sumh,sumt;
sumh=fsum(a,4);
sumt=_____;
printf("%d , %d\n",sumh,sumt);
}
【答案】
i＜n;return(s);fsum(＆a[9],6);
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序对某公司销售一组的年终奖金分配表进行两项处理：（1）计算年终奖总额，并填入表格相应位置；（2）调用子函数，将表格除最后一行以外，按奖金额从高到低排序。最后，输出处理后的表格内容。
#include ＜stdio.h＞
struct NZJ
{char name[20];
long prize;
};
void PX(struct NZJ *p, int n)
{int i,j;
struct NZJ t;
for(j=1;j＜=n-1;j++)
for(i=0;i＜=n-1-j;i++)
if(_____)
{t=p[i];p[i]=p[i+1];p[i+1]=t;}
}
main()
{struct NZJ a[6]={"ZS",18000,"ZL",35000,"DY",30000,"WW",20000,"LS",26000,"TOTAL"};
long s;
int i;
_____
s=0;
for(i=0;i＜5;i++)
s=s+a[i].prize;
_____
printf("***Name******Prize***\n");
for(i=0;i＜6;i++)
printf("%6s%12ld\n", a[i].name, a[i].prize);
}
【答案】
p[i].prize＜p[i+1].prize 或 (*(p+i)).prize＜(*(p+i+1)).prize;PX(a,5);a[i].prize=s;
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】填空题
【题干】
以下程序的功能是：判断任意读入的正整数是否为回文数（所谓回文数，是指其各位数字左右对称的整数。例如，1221、12321都是回文数）。
#include＜stdio.h＞
#define N 100
main()
{long x,y; int i,m,n,a[N];
do{printf("Input x＞0:\n");
scanf("%ld",&x);
}while(x＜=0);
y=x; i=0;
do{a[i]=_____;
x=x/10;
i++;}while(x!=0);
m=0;
n=i-1;
while(_____&&a[m]==a[n])
{m++; n--;}
if(_____)
printf(" %ld shi huiwenshu!\n",y);
else
printf(" %ld bushi huiwenshu.\n",y);
}
【答案】
x%10;m＜n;m＞=n;
【解析】
【难度】2
【分数】6.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
编程实现将华氏温度转换成摄氏温度。转换公式为：c=5/9 * (f-32)，其中f代表华氏温度，c代表摄氏温度
【答案】
#include＜stdio.h＞
int main()
{
float c,f;
scanf("%f", &f);
c=5.0/9.0*(f-32.0);
printf("%.1f\n", c);
return 0;
}
【解析】
【难度】2
【分数】0.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
完善函数，函数fun的功能为：判断一个数是否是素数，是则返回1，否则返回0。
int fun(int x)
{ }
【答案】
int fun(int x)
{int i;
for(i=0;i＜x;i++)
if(x%i==0) return 0;
return 1;
}
【解析】
【难度】1
【分数】10.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
完善函数，函数fun的功能为判断一个字符串是否为回文串，若是则返回1，如不是回文串则返回0。
int fun(char str[ ])
{ }
【答案】
int fun(char str[ ])
{int i,j;
for(i=0;str[i];i++);
i=i-1;
for(j=0;j＜i;j++)
if(str[i]!=str[j]) break;
if(j＞=i) return 1;
else return 0;
}
【解析】
【难度】1
【分数】10.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】完善函数, 函数fun的功能为：用迭代法求a的平方根,并作为函数值返回。求平方根的迭代公式为：，要求前后二次求出的x的差的绝对值小于10-6。
float fun(float a)
{ }
【答案】
float fun(float a)
{float x0,x1;
x0=a/2;
x1=(x0+a/x0)/2;
do {x0=x1;
x1=(x0+a/x0)/2;
}while(fabs(x0-x1)＞=1e-6);
return(x1);
}
【解析】
【难度】1
【分数】10.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
完善函数, 函数fun的功能为：用起泡法对数组a[ ]中的n个数排序（由小到大）。
void fun(int a[ ],int n)
{ }
【答案】
void fun(int a[],int n)
{int i,j,t;
for(j=0;j＜n-2;j++)
for(i=0;i＜n-1-j;i++)
if(a[i]＞a[i+1])
{t=a[i];
a[i]=a[i+1];
a[i+1]=t;}
}
【解析】
【难度】1
【分数】10.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
函数fun的功能为将任意输入的字符串在显示屏上逆序输出，例如，输入字符串为“welcome”，在显示屏上输出为“emoclew”，请将函数补充完整。
void fun(char a[ ])
{ }
【答案】
函数fun的功能为将任意输入的字符串在屏幕逆序输出，例如，输入字符串为“welcome”，在屏幕上输出为“emoclew”，请将函数补充完整。
void fun(char a[ ])
{int i,j;
char t;
j=strlen(a)-1;
for(i=0;i＜j;i++,j--)
t=a[i];a[i]=a[j];a[j]=t;}
}
【解析】
【难度】1
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
函数fun的功能为判断整数x是否为素数，如果是素数则返回一个值为1，如果不是素数则返回一个值为0，请将函数补充完整。
int fun(int x)
{ }
【答案】
函数fun的功能为判断整数x是否为素数，如果是素数则返回一个值为1，如果不是素数则返回一个值为0，请将函数补充完整。
int fun(int x)
{for(i=0;i＜x;i++)
if(x%i==0) return 0;
return 1;
}
【解析】
【难度】1
【分数】5.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
从键盘上输入两个整数m和n,求其最大公约数和最小公倍数。
【答案】
从键盘上输入两个整数m和n,
求其最大公约数和最小公倍数。
#include＜stdio.h＞
void main()
{int p,r,n,m,temp;
scanf("%d,%d",&n,&m);
if(n＜m)
{ temp=n;
n=m;
m=temp;}
p=n*m;
while(m!=0)
{ r=n%m;
n=m;
m=r;}
printf("最大公约数：%d\n",n);
printf(“最小公倍数：%d\n”,p/n);}
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】编程题
【题干】
用起泡法（冒泡法）对10个整数排序（由小到大）。
【答案】
2. 用起泡法（冒泡法）对10个整数排序（由小到大）。
#include＜stdio.h＞
void main()
{ int a[10];int i,j,t;
for(i=0;i＜10;i++) scanf(“%d”,&a[i]);
printf(“\n”);
for(j=0;j＜9;j++)
for(i=0;i＜9-j;i++)
if(a[i]＞a[i+1])
{t= a[i];
a[i]= a[i+1];
a[i+1]=t;}
printf(“the sorted numbers:\n”);
for(i=0;i＜10;i++) printf(“%d”,a[i]);
printf(“\n”);
}
【解析】
【难度】1
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
【题型】问答题
【题干】
【答案】
【1】 float s=0
【2】 i%4 ==3
【解析】
【难度】2
【分数】4.000
【课程结构】00021001
【关键词】Synchronization
