本答案对应课程为:点我自动跳转查看
本课程起止时间为:2021-09-17到2022-01-16
本篇答案更新状态:已完结

【作业】第1章 程序设计概述 输出菜单

1、 问题:
评分规则: 【 程序框架70
输出语言使用
】

【作业】第1章 程序设计概述 编程2

1、 问题:编程输出4行6列星号，如下图：******
评分规则: 【 程序框架20
printf使用
】

2、 问题:编程任意输入两个整数，并输出它们的和。
评分规则: 【 题目框架
输入函数使用
输出函数使用
】

【作业】第3章 选择结构程序设计 第3次 在线编程作业

1、 问题:输入两个整数，输出最大数。
评分规则: 【 程序框架
printf和scanf使用正确
选择结构使用正确
】

第3章 选择结构程序设计 第1次 顺序结构和选择结构

1、 问题:下面四个选项中，均是不合法的用户标识符的选项的是_。
选项：
A:A          p_o      do
B:float    lao     _A
C:b-a  goto   int
D:_125   temp  INT
答案: 【_125   temp  INT】

2、 问题:若x = 2 , y=3，则x && y的结果是_。A．0     B．1       C．2       D．3
选项：
A:0
B:1
C:2
D:3
答案: 【1】

3、 问题:若有以下类型说明语句：char w ; int x ; float y ; double z ; ，则表达式w * x + z – y的结果为_类型。
选项：
A: float
B:char
C:int
D:double
答案: 【double】

4、 问题:若变量c为char类型，能正确判断出c为小写字母的表达式是_。
选项：
A:a’ <= c <= ‘z’
B:(c >= ‘a’) || (c<= ‘z’)
C:(‘a’ <= c) and (‘z’ >= c)
D:（c >= ‘a’ ） && (c <= ‘z’)
答案: 【（c >= ‘a’ ） && (c <= ‘z’)】

5、 问题:在C语言中，要求运算数必须是整型的运算符是_。
选项：
A:/
B:<=
C:||
D:%
答案: 【%】

6、 问题:已有定义：int x = 3 , y = 4 , z = 5 ; 则表达式!( x + y ) + z –1 && y + z / 2的值是_。
选项：
A:6
B:0
C:2
D:1
答案: 【1】

7、 问题:若a，b，c均为整型变量，则执行以下语句  a =0  b = 0 ; a++ && ( b=8 )  ; 后，a的值为_，b的值为_?
选项：
A:a为1，b为0
B:a为0 ，b为0
C:a为1，b为8
D:a为0，b为8
答案: 【a为1，b为0】

8、 问题:结构化程序由_、_、__，3种基本结构组成。
答案: 【顺序结构、选择结构、循环结构】

9、 问题:C语言源程序文件的后缀是_；经过编译后，生成文件的后缀是_；经过连接后，生成的文件的后缀是__。
答案: 【.c .obj .exe】

第2章 算法及数据类型 第1次 算法

1、 问题:关于C语言程序书写规则说法中正确的是_。
选项：
A:A．程序语句必须占一行
B:B．不区分大小写
C:C．每行必须有行号
D:D．每条语句用分号结束
答案: 【D．每条语句用分号结束】

2、 问题:下面关于算法的说法，错误的是_。
选项：
A:A．算法必须有输出，但不一定有输入
B:B．算法必须在计算机上用某种语言实现
C:C．算法必须在有限步执行后能结束
D:D．算法的每一步骤必须有确切的定义
答案: 【B．算法必须在计算机上用某种语言实现】

3、 问题:结构化程序设计规定的3种基本控制结构是_。
选项：
A:A．顺序、选择和转向
B:B．层次、网状和循环
C:C．模块、选择和循环
D:D．顺序、选择和循环
答案: 【D．顺序、选择和循环】

4、 问题:结构化程序由三种基本结构组成，三种基本结构组成的算法_。
选项：
A:A．可以完成任何复杂的任务
B:B．只能完成部分复杂的任务
C:C．只能完成符合结构化的任务
D:D．只能完成一些简单的任务
答案: 【A．可以完成任何复杂的任务 】

5、 问题:以下运算符中优先级最低的是_
选项：
A:A．&&
B:B．<=
C:C．=
D:D．==
答案: 【C．= 】

第3章 选择结构程序设计 第2次 选择结构

1、 问题:已知a、b、c为int类型，执行语句：scanf( "a=%d, b=%d, c=%d" , &a , &b , &c ) ; ，若要使得a为1，b为2，c为3。则以下选项中正确的输入形式是_。
选项：
A:a=1b=2c=3
B:1, 2, 3
C:a=1, b=2, c=3
D:1,2,3
答案: 【a=1, b=2, c=3】

2、 问题:if语句的选择条件是_。
选项：
A:只能用关系表达式
B:只能用关系表达式或逻辑表达式
C:只能用逻辑表达式    
D:可以用任何表达式
答案: 【可以用任何表达式】

3、 问题:以下程序段的输出结果是_。int a = 2 , b = 1 , c = 2 ;if( a < b )  if( b < 0 )  c = 0 ;  else c += 1 ;printf( "%d" , c ) ;
选项：
A:0
B:1
C:2
D:3
答案: 【2】

4、 问题:当a = 1，b = 3，c = 5，d = 4时，执行下面一段程序后，x的值为_。if( a < b )  if( c < d ) x = 1 ;  elseif( a < c )if( b < d ) x = 2 ;          else x = 3 ;       else x = 6 ;else x = 7 ;
选项：
A:1
B:2
C:3
D:6
答案: 【2】

5、 问题:若有定义：float w ; int a , b ; 则合法的switch语句是_。
选项：
A:switch(w){   case 1.0 : printf("");  case  2.0: printf("?"); }
B:switch(b){   case 1 : printf("");  default: printf("");  case 1+2: printf("?"); }
C:switch(b);{   case 1 : printf("");  default: printf("");  case 1+2: printf("?"); }
D:switch(a){   case 1  printf("");  case 2  printf("?"); }
答案: 【switch(b){   case 1 : printf("*");  default: printf("");  case 1+2: printf("?"); }】

第4章 循环结构程序设计 第1次 循环程序设计(1)

1、 问题:有以下程序段 int k = 10 ;while( k = 0 ) k = k – 1 ;则下面描述中正确的是_。          
选项：
A:A．while循环执行10次
B:B．循环是无限循环
C:C．循环体语句一句也不执行        
D:D．循环体语句执行一次
答案: 【C．循环体语句一句也不执行         】

2、 问题:有以下程序段int x = 0 , s = 0 ;while( !x != 0 )  s += ++x ;printf( "%d" , s ) ;则_。                 
选项：
A:A．运行程序段输出0               
B:B．运行程序段输出1
C:C．程序段中的控制表达式是非法的    
D:D．程序段执行无限次
答案: 【B．运行程序段输出1】

3、 问题:3．下面程序的功能是将从键盘输入的一对数，由小到大排序输出。当输入一对相等数时结束循环，请选择填空。#include<stdio.h>int main( ){ int a , b , t ; scanf( "%d%d" , &a , &b ); while(_) { if( a > b ) { t = a ; a = b ; b = t ; } printf( "%d,%d" , a , b ) ; scanf( "%d%d" , &a , &b ) ; }    return 0 ;}
选项：
A:A．!a = b
B:B．a != b
C:C．a == b
D:D．a = b
答案: 【B．a != b 】

4、 问题:下面程序的功能是在输入的一批正整数中求出最大者，输入0结束循环，请选择填空。#include<stdio.h>int main( ){ int a , max = 0 ; scanf( "%d" , &a ) ; while(_) { if( max < a ) max = a ; scanf( "%d" , &a ) ; } printf( "%d" , max ) ;    return 0 ;}
选项：
A:A．a == 0
B:B．a
C:C．!a == 1
D:D．!a
答案: 【B．a 】

5、 问题:C语言中while和do－while循环的主要区别是_。  
选项：
A:A．do－while的循环体至少无条件执行一次
B:B．while的循环控制条件比do－while的循环控制条件严格
C:C．do－while允许从外部转到循环体内
D:D．do－while的循环体不能是复合语句
答案: 【A．do－while的循环体至少无条件执行一次】

第5章 数组 第1次 数组(1)

1、 问题:若有定义：int a[10]；则对数组a元素的引用正确的是(    )
选项：
A:a[10]
B:a[5.5]
C:a(5)
D:a[10-10]
答案: 【a[10-10]】

2、 问题:下面程序段的输出结果是(     )int k[30]={12,324,45,6,768,98,21,34,453,456};int count=0,i=0;while(k[i])  { if(k[i]%2==0||k[i]%5==0)  count++;    i++;   }printf("%d,%d",count,i);
选项：
A:7,8
B:8,8
C:7,10
D:8,10
答案: 【8,10】

3、 问题:已知int类型的变量占用4个字节的内存空间，则以下程序段输出（   ）int a[10]={1,2,3,4,5};  printf("%d",sizeof(a));
选项：
A:5
B:10
C:20
D:40
答案: 【40】

4、 问题:以下程序段的输出结果是（   ）int a[4][4]={{1,4,3,2},{8,6,5,7},{3,7,2,5},{4,8,6,1}},i,j,k,t;for(i=0;i<4;i++)  for(j=0;j<3;j++)    for(k=j+1;k<4;k++)      if(a[j][i]>a[k][i])        {t=a[j][i]; a[j][i]=a[k][i]; a[k][i]=t; }for(i=0;i<4;i++)  printf("%d,",a[i][i]);
选项：
A:1,6,5,7 
B: 8,7,3,1 
C: 4,7,5,2 
D: 1,6,2,1 
答案: 【1,6,5,7 】

5、 问题:若二维数组a有m列，则在a[i][j]之前的元素个数为（   ）
选项：
A: jm+i 
B: im+j 
C: im+j-1 
D: im+j+1 
答案: 【 i*m+j 】

6、 问题:以下数组定义错误的是(    )
选项：
A:int x[][3]={0}; 
B:int x[2][3]={{1,2},{3,4},{5,6};
C:int x[][3]={{1,2,3},{4,5,6}}; 
D:int x[][3]={1,2,3,4,5,6};
答案: 【int x[2][3]={{1,2},{3,4},{5,6};】

7、 问题:若要给数组的所有元素输入数据，则下面程序段中应填上int a[10],i=0;while(i<10)  scanf("%d",_)
选项：
A:&a[i]
B:&a[i+1] 
C:a
D: a[i] 
答案: 【&a[i]】

8、 问题:在C语言中，引用数组元素时，其数组下标的数据类型不允许是(     )
选项：
A:整型常量 
B:整型表达式    
C:整型常量或整型表达式
D:任何类型的表
答案: 【整型常量或整型表达式】

9、 问题:定义 int a[10] = {6 , 7 , 8 , 9 , 10} ; 的正确理解是(     )  
选项：
A:将5个初值依次赋给a[1]–a[5] 
B:将5个初值依次赋给a[0]–a[4]
C:将5个初值依次赋给a[6]–a[10] 
D:因为数组长度与初值个数不相同，所以此语句不正确
答案: 【将5个初值依次赋给a[0]–a[4]】

10、 问题:以下对二维数组a的正确说明是(    )
选项：
A:int a[3][ ];  
B:float a(3)(4);
C:double a[ 3][4] ;    
D:float a(3,4);
答案: 【double a[ 3][4] ;    】

第5章 数组 第2次 数组(2)

1、 问题:下面程序的运行结果是（ ）#include<stdio.h>#include<string.h>int main( ){ char a[80] = “AB” , b[80] = “LMNP” ; int i = 0 ; strcat( a , b ) ; while( a[i++] != ‘\0’ ) b[i] = a[i] ; puts( b ) ;  return 0 ;}
选项：
A:LB
B:ABLMNP
C:AB
D:LBLMNP
答案: 【LBLMNP】

2、 问题:若有定义：char s[100] = “hello” ;，下列函数调用语句中，不正确的是（ ）
选项：
A:A．strlen( strcpy( s , “well” ) ) ;  
B:B．strcat( s , “!” ) ;
C:C．puts( puts( “hello” ) ) ;     
D:D．!strcmp( “” , s ) ;
答案: 【C．puts( puts( “hello” ) ) ;      】

3、 问题:下面程序段的运行结果是（ ）char a[7] = “abcdef” ;char b[4] = “ABC” ;strcpy( a , b ) ;printf( “%c” , a[5] ) ;
选项：
A:□(□表示一个空格)
B:\0
C:e
D:f
答案: 【f】

4、 问题:有两个字符数组a，b，则以下正确的输入语句是（ ）
选项：
A:gets( a , b ) ;       
B:scanf( “%s,%s” , a , b ) ;
C:scanf( “%s%s” , &a , &b ) ;   
D:gets( “a” ) , gets( “b” ) ;
答案: 【scanf( “%s,%s” , a , b ) ;】

5、 问题:对两个数组a和b进行如下初始化，char a[ ] = “ABCDEF” ;char b[ ] = { ‘A’ , ‘B’ , ‘C’ , ‘D’ , ‘E’ , ‘F’ } ;则以下叙述正确的是（ ）
选项：
A:a和b数组完全相同
B:a与b长度相同
C:a的长度比b短  
D:a的长度比b长
答案: 【a的长度比b长】

6、 问题:以下对数组s的初始化，错误的是（ ）
选项：
A:char s[5] = { “abc” } ;
B:char s[5] = { ‘a’ , ‘b’ , ‘c’ } ;
C:char s[5] = “” ;
D:char s[5] = “abcde” ;
答案: 【char s[5] = “abcde” ;】

7、 问题:下面程序段的运行结果是 （ ）#include<stdio.h>int main( )  { int i , x[3][3] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ; for( i = 0 ; i < 3 ; i++ ) printf( “%2d” , x[i][2-i] ) ;  return 0 ;}
选项：
A:1 5 9
B:1 4 7
C:3 5 7
D:3 6 9
答案: 【3 5 7】

8、 问题: 对二维数组a进行如下初始化 int a[ ][3]={0 , 1 , 2 , 3 , 4 , 5}; 则a[1][1]的值是（ ）。  
选项：
A:0
B:3
C:4
D:1
答案: 【4】

9、 问题:以下对二维数组a初始化正确的语句是 （ ）
选项：
A:int a[2][ ]={{0 , 1 , 2}, {3 , 4 , 5}};
B:int a[ ][3]={{0, 1, 2}, {3, 4, 5}};
C:int a[2][4]={{0, 1 , 2}, {3 , 4}, {5}}; 
D:int a[ ][3]={{0, 1, 2}, { }, {3, 4}};
答案: 【int a[ ][3]={{0, 1, 2}, {3, 4, 5}};】

10、 问题:若有定义： int a[3][4]; , 则对a数组元素的正确引用是 （ ）
选项：
A:a[3][4]
B:a[1,3]
C:a[1+1][0]
D:a(2)(1)
答案: 【a[1+1][0]】

第7章 指针 第1次 指针

1、 问题:下面程序的运行结果是_。#include<stdio.h>void f( int y , int x ){ y = y + x ;   x = x + y ;}int main( ){   int x = 2 , y = 4 ; f( y , &x ) ; printf( "%d,%d" , x , y ) ; return 0 ;}
答案: 【8,4】
分析：【实参相当于等号右侧，形参相当于等号左侧
函数调用第一个参数传送变量y，所以修改形参y的值，实参y值不变
函数调用第二个参数传送地址&x，所以修改形参*x的值，所以实参x的值变化】

2、 问题:下面程序的运行结果是_。#include<stdio.h>void fun( int a , int b ){  printf( "%d %d," , a , b ) ;  a = 2 ; b = 4 ;}int main( ){    int x = 1 , y = 3 ; fun( &y , &x ) ; printf( "%d,%d" , x , y ) ; return 0 ;}
答案: 【3,1,4,2】
分析：【函数执行顺序，首先执行的输出语句是自定义fun函数中的a和b的值
返回调用地点再执行main中的输出语句】

3、 问题:下面程序的运行结果是__。#include<stdio.h>int main( ){   void f( int x , int y ) ; int a = 1 , b = 2 ; f( a , b ) ; printf( "a=%d,b=%d" , a , b ) ;    return 0 ;}void f( int x , int y ){   x = 100 ; y = 200 ;}
答案: 【a=1,b=2】
分析：【f(a,b) 函数调用传送的变量，实参相当于等号右侧，形参相当于等号左侧，自定义函数f中修改形参x和y的值，不影响等号右侧实参的值】

第7章 指针 第1次 指针(1)

1、 问题:下面程序的运行结果是__。#include<stdio.h>int main( ){   void f( int x , int y ) ; int a = 1 , b = 2 ; f( a , b ) ; printf( "a=%d,b=%d" , a , b ) ;    return 0 ;}void f( int x , int y ){   x = 100 ; y = 200 ;}
答案: 【a=1,b=2】

2、 问题:下面程序的运行结果是_。#include<stdio.h>void f( int y , int x ){ y = y + x ;   x = x + y ;}int main( ){   int x = 2 , y = 4 ; f( y , &x ) ; printf( “%d,%d” , x , y ) ; return 0 ;}
答案: 【8,4】

3、 问题:下面程序的运行结果是_。#include<stdio.h>void fun( int a , int b ){  printf( "%d %d," , a , b ) ;  a = 2 ; b = 4 ;}int main( ){   int x = 1 , y = 3 ; fun( &y , &x ) ; printf( "%d,%d" , x , y ) ; return 0 ;}
答案: 【3 1,4,2】

第10周——字符串：C语言世界中的大力水手 第10周测验

1、 问题:下面程序的功能是从键盘输入一个字符串，编程将其字符顺序颠倒后重新存放，并输出这个字符串。程序的运行结果如下：Input a string:abcdef↙The inversed string is:fedcba按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

void Inverse(char *pStr);
int main()
{
    char  str[80];
    printf("Input a string:");
    gets(str);//输入字符串
    Inverse(str);//将存于str数组中的字符串逆序存放
    printf("The inversed string is:");
    puts(str);//输出字符串
    return 0;
}

void Inverse(char pStr)
{
    int  len = 0;
    char temp;
    char pStart = pStr;//指针变量pStart指向字符串的第一个字符
    char pEnd;//指针变量pEnd指向字符串的最后一个字符
    for (; pStart!=’\0′; ___)    //求出字符串长度
        {
            len++;
        }
    for (pStart=pStr,__; pStart<pEnd; pStart++,pEnd–)
    {
        temp = __;
        __;
        
        pEnd = temp;
    }
}
选项：
A:第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd
B:第21行：  pStart++第25行：  pEnd=pStr+len第27行：  pStart第28行：  pStart = pEnd
C:第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd
D:第21行：  pStart++第25行：  pEnd=pStr+len第27行：  pStart第28行：  pStart = pEnd
答案: 【第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd】

2、 问题:Squeeze函数的功能是删除字符串s中所出现的与变量c相同的字符。例如，输入为：abcdef↙c↙输出为：abdef按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

void Squeeze(char s, char c);
int main()
{
    char  a[80], c, s;
    s = a;
    gets(a);
    scanf("%c",&c);
    Squeeze(s, c);
    printf("%s", s);
    return 0;
    }
    
 void  Squeeze(char s, char c)
    {
        int i, j;
        for (i = j = 0; s[i] != ‘\0’; i++)
            {
                if (_)
                {
                    _;
                    j++;
                }
            }
        _______; / 在字符串t2的末尾添加字符串结束标志 */
     }
选项：
A:第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ‘\0’
B:第20行： s[i] == c第22行： s[j] = s[i]第26行： s[i] = ‘\0’
C:第20行： s[j] != c第22行： s[i] = s[j]第26行： s[j] = ‘\0’
D:第20行： s[j] == c第22行： s[j] = s[i]第26行： s[i] = ‘\0’
答案: 【第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ‘\0’】

3、 问题:以下程序中函数FindMinString的功能是返回形参指针s1和s2所指字符串中较小字符串的首地址。例如，若运行时依次输入三个字符串：123↙1223↙124↙输出结果为1223按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

char *FindMinString( ___ )
{
    if(_____)
        return(s1);
    else
        return(s2);
}

int main()
{
    int i; 
    char string[20], str[3][20];
    for(i=0;i<3;i++) 
    {
        gets(str[i]);
    }
    strcpy(string,FindMinString(str[0],str[1])); /对字符串进行复制/
    strcpy(string,_______);
    printf("%s",string);
    return 0;
}
选项：
A:第3行： char s1, char s2第5行： strcmp(s1,s2)<0第20行： FindMinString(string,str[2])
B:第3行： char s1, char s2第5行： s1<s2第20行： FindMinString(string,str[2])
C:第3行： char s1, char s2第5行： strcmp(s1,s2)>0第20行： FindMinString(str[0],str[2])
D:第3行： char s1, char s2第5行： s1>s2第20行： strcmp(str[1],str[2])
答案: 【第3行： char s1, char s2第5行： strcmp(s1,s2)<0第20行： FindMinString(string,str[2])】

4、 问题:子函数Move的功能是将某字符串中的第i个字符向左移动1位，覆盖第i-1个字符。下面程序通过多次调用Move函数，将字符数组b中存放的字符串依次左移3位，并在移动后的字符串末尾添上字符0补足。程序的运行结果为：234567890034567890004567890000按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void Move( ___,int i)
{
    a[i-1]=a[i];
}

int main( )
{   
    char b[11]={"1234567890"};
    int i,j;
    for (j=0;j<=2;j++)
    {
      for(i=1;b[i]!=’\0′;i++)
        {
            _;
            printf("%c",b[i-1]);
        }
      __;
      printf("%c",______);
    }
    return 0;
}
选项：
A:第2行：  char a第15行： Move(b,i)第18行： b[i-1]=’0’第19行： b[i-1]
B:第2行：  char a第15行： Move(b,i)第18行： b[i-1]=’\0’第19行： b[i-1]
C:第2行：  char a第15行： Move(b,i)第18行： b[i]=’0’第19行： b[i]
D:第2行：  char a第15行： Move(i,b)第18行： b[i]=’\0’第19行： b[i]
答案: 【第2行：  char *a第15行： Move(b,i)第18行： b[i-1]=’0’第19行： b[i-1]】

5、 问题:下面能正确进行字符串赋值操作的是
选项：
A:char s=“ABCDE”; 
B:char s[5]={“ABCDE”}; 
C:char s[5]={‘A’, ‘B’, ‘C’, ‘D’, ‘E’}; 
D:char s,scanf(“%s”,s); 
答案: 【char *s=“ABCDE”; 】

6、 问题:下列对字符串的定义中，错误的是
选项：
A:char  str[7] = "FORTRAN";
B:char  str[] = "FORTRAN";
C:char  *str = "FORTRAN";
D:char  str[] = {‘F’,’O’,’R’,’T’,’R’,’A’,’N’,0};
答案: 【char  str[7] = "FORTRAN";】

7、 问题:已知：int *p(); 则p是
选项：
A:一个函数，该函数的返回值是指向int型的指针变量
B:指向int型的指针变量
C:int型的指针数组
D:一个指向函数的指针变量，该函数的返回值是int型
答案: 【一个函数，该函数的返回值是指向int型的指针变量】

8、 问题:下面函数Fun的功能是#include <stdio.h>

include <string.h>

int Fun(char ps)
{
    char p;
    p=ps;
    while(*p++);
    return (p-ps);
}

int main()
{
    char  *s;
    int a1,a2;
    s = "hello";
    a1=Fun(s);
    a2=strlen(s);
    printf("%d,%d", a1,a2);
    return 0;
    }
选项：
A:以上三种说法都不对
B:比较两个字符串的大小
C:求字符串的长度
D:将串ps复制到串s中
答案: 【求字符串的长度】

9、 问题:下面函数Fun的功能是void Fun(char s1, char s2){    while(s2++=s1++);}
选项：
A:串复制
B:求串长
C:串比较
D:串反向
答案: 【串复制】

10、 问题:给出以下定义，则正确的叙述是char  x[ ]= “abcedfg”;char  y[ ]={ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’’, ‘g’ };
选项：
A:数组x 的长度大于数组y的长度
B:数组x 和数组y 等价
C:数组x 和数组y 的长度相同
D:数组x 的长度小于数组y的长度
答案: 【数组x 的长度大于数组y的长度】

11、 问题:执行以下代码段后，输出的字符串是#include <stdio.h>

include <string.h>

int main()
{
   char s1[10],*s2="ab\0cdef";
   strcpy(s1,s2);
   puts(s1);
   …….
   return 0;
}
选项：
A:ab
B:cdef
C:ab\0cdef
D:内容不确定
答案: 【ab】

12、 问题:下面程序的功能是将字符数组中存放的字符串以多种书写形式输出，如“Program”，“PROGRAM”，以及逆序输出的字符串“margorp”等，程序的运行结果为：ProgramPROGRAMmargorp按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main(void)
{
    int  i = 0;
    char  b[] = "program";
    char  a = "PROGRAM";
    printf("_", a, b + 1);  / 输出Program */
    while (___)    / 输出PROGRAM /
    {   
        __;
        i++;
    }
    printf("");
    while (__)                / 输出margorp /
    {
        putchar (__);
    }
    _;
    return 0;
}
选项：
A:第8行：  %c%s第9行：  (a+i)!=’\0’第11行： putchar((a + i))第15行： –i第17行： (b + i)第19行： putchar ((b + i))
B:第8行：  %s%s第9行：  （a+i)!=’\0’第11行： putchar(a + i))第15行： i–第17行： (b + i)第19行： putchar ((b + i))
C:第8行：  %c%s第9行：  (a+i)==’\0’第11行：  putchar((a + i)) 第15行： –i第17行： b + i第19行： putchar (b + i))
D:第8行：  %s%s第9行：  （a+i)==’\0’第11行：  putchar(a + i))第15行： i–第17行： b + i第19行： putchar (b + i)
答案: 【第8行：  %c%s第9行：  (a+i)!=’\0’第11行： putchar((a + i))第15行： –i第17行： (b + i)第19行： putchar (*(b + i))】

13、 问题:下面程序的功能是用字符指针变量作函数参数编程实现字符串连接函数strcat()的功能，将字符串srcStr连接到字符串dstStr的尾部。程序的运行结果如下：Please enter the source string:abcd↙Please enter the other string:efgh↙The concat is:abcdefgh按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void  MyStrcat(char dstStr, char srcStr);
int main()
{
    char  s[80];  //源字符串
    char  t[80];  //待连接字符串
    printf("Please enter the source string: ");
    gets(s);
    printf("Please enter the other string: ");
    gets(t);  //输入字符串
    MyStrcat(s, t);  //将字符数组t中的字符串连到s的尾部
    printf("The concat is:");
    puts(s);  //输出连接后的字符串s
    return 0;
}

void  MyStrcat(char dstStr, char srcStr)   //用字符指针作为函数参数
{
    while (_)
    {
        dstStr++;
    }
    while (*srcStr != ‘\0’)  //若srcStr所指字符不是字符串结束标志
    { 
        __; //将srcStr所指字符复制到dstStr所指的存储单元中
        srcStr++;  //使srcStr指向下一个字符
        dstStr++; //使dstStr指向下一个存储单元
    }
     _____; //在字符串dstStr的末尾添加一个字符串结束标志
}
选项：
A:第19行： dstStr != ‘\0’第25行： dstStr = * srcStr第29行： dstStr = ‘\0’
B:第19行： dstStr != ‘\0’第25行： dstStr =  srcStr第29行： dstStr = ‘\0’
C:第19行： dstStr == ‘\0’第25行： dstStr = * srcStr第29行： dstStr = ”
D:第19行： dstStr == ‘\0’第25行： dstStr =  srcStr第29行： dstStr = ”
答案: 【第19行： dstStr != ‘\0’第25行： dstStr = * srcStr第29行： *dstStr = ‘\0’】

14、 问题:以下程序的功能是分别测量字符数组及数组中存放的字符串的长度，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main( )
{ 
    char a[]="abcdefg",b[10]="abcdefg";
    ____;  /测量字符数组a,b的长度，并输出/
    ____;  /测量字符数组a,b中存放的字符串的长度，并输出/
    return 0;
}
选项：
A:第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))
B:第6行： printf("%d %d",strlen(a) ,strlen(b))第7行： printf("%d %d",sizeof(a) ,sizeof(b))
C:第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))
D:第6行： printf("%d %d",sizeof(&a) ,sizeof(&b))第7行： printf("%d %d",strlen(&a) ,strlen(&b))
答案: 【第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))】

15、 问题:下面程序的功能是将一个字符串s2插入到字符串s1中，其起始插入位置为n。程序运行示例如下：main string:hello,world!sub string:cc site of begining:(<=12)5After instert:hellocc,world!按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 100

int main()
{
    int n, i, j, k, len;
    char s1[N], s2[N], s3[2 * N];
    printf("main string:");
    gets(s1);
    printf("sub string:");
    gets(s2);
    len = strlen(s1);
    do
        {
            printf("site of begining:(<=%d)", len);
            scanf("%d", &n);
        }while (_);
        
    for (i = 0; i < n; i++)
       {
           s3[i] = s1[i];
       }
    for (j = 0; s2[j] != ‘\0’; j++)
      {
           __;
      }
    for (_; s1[k] != ‘\0’; k++)
     {
           ____;
     }
    s3[j + k] = ‘\0’;
    printf("After instert:%s", s3);
    return 0;
}
选项：
A:第17行：  n > len第25行：  s3[i + j] = s2[j]第27行：  k = n第29行：  s3[j + k] = s1[k]
B:第17行：  n < len第25行：  s3[i] = s2[j]第27行：  k = n第29行：  s3[j] = s1[k]
C:第17行：  n <= len第25行：  s2[j]=s3[i + j] 第27行：  k = 0第29行：  s3[j] = s1[k]
D:第17行：  n >= len第25行：  s3[j] = s2[j]第27行：  k = 0第29行：  s1[k] = s3[j + k]
答案: 【第17行：  n > len第25行：  s3[i + j] = s2[j]第27行：  k = n第29行：  s3[j + k] = s1[k]】

16、 问题:下面程序的功能是从键盘输入一行字符（最长不超过80字符），用函数编程统计其中单词（以空格作为间隔符的字符串）的个数。基本思路是：当前被检验字符不是空格，而前一被检验字符是空格，则表示有新单词出现。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。（下面答案中两个单引号”中间都有一个空格）样例1：Input a string:How are you↙Numbers of words = 3样例2：Input a string:  How are you↙Numbers of words = 3#include <stdio.h>
int CountWords(char str[]);
int main()
{
    char  str[81];
    int num;
    printf("Input a string:");
    gets(str);
    num=CountWords(str);
    printf("Number of words=%d", num);
    return 0;
}

int CountWords(char str[])
{
    int  i, num;
    num = (_) ? 1 : 0;
    i=1;
    while (str[i]!=’\0′)
    {
        if (____)
        {
            num++;
        }
         __;
    }
    return num;
}
选项：
A:第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] == ‘ ‘第25行： i++
B:第17行： str[0] == ‘ ‘第21行： str[i]!=’ ‘ || str[i-1] == ‘ ‘第25行： i++
C:第17行： str[0] != ‘\0 ‘第21行： str[i]==’ ‘ && str[i-1] == ‘ ‘第25行： i++
D:第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] != ‘ ‘第25行： num++
答案: 【第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] == ‘ ‘第25行： i++】

17、 问题:下面程序的功能是实现字符串逆序存放。程序运行结果如下：Input a string:ABCDEFGHI↙Inversed results:IHGFEDCBA按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 80

void Inverse(char *pStr);
int main()
{
    char a[N];
    printf("Input a string:");
    gets(a);
    Inverse(a);
    printf("Inversed results:%s", a);
    return 0;
}

/ 函数功能： 实现将字符数组中的字符串逆序存放 /
void Inverse(__)
{
    int  len;
    char temp;
    char pStart;  / 指针变量pStart指向字符串的第一个字符 /
    char pEnd;   / 指针变量pEnd指向字符串的最后一个字符 /
    len = strlen(pStr);  / 求出字符串长度 /
    for (pStart=pStr,___; pStart<pEnd; pStart++,_)
    {
        temp = *pStart;
        _____;
        
        pEnd = temp;
    }
}
选项：
A:第16行：   char pStr第23行：   pEnd=pStr+len-1             pEnd–第26行：   pStart = pEnd
B:第16行：   char pStr第23行：   pEnd=pStr+len             pEnd–第26行：   pStart = pEnd
C:第16行：  char pStr第23行：  pEnd=pStr+len-1            pEnd++第26行：   pStart = pEnd
D:第16行：  char pStr第23行：  pEnd=pStr+len+1            pEnd++第26行：   pStart = pEnd
答案: 【第16行：   char pStr第23行：   pEnd=pStr+len-1             pEnd–第26行：   pStart = pEnd】

18、 问题:下面程序的功能是从键盘输入一行字符（不超过80个），统计其中的英文字符、数字字符、空格和其他字符的个数。例如，输入的一行字符为*c language.***输出为English character:  9digit character:  0space:  1other character:  11按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define STR_LEN 80

int main()
{
    char str[STR_LEN+1];
    int  len, i, letter = 0, digit = 0, space = 0, others = 0;
    printf("Please input a  string:");
    __;
    for (i = 0; _; i++)
        {
            if (_____)
                letter ++;              /统计英文字符 /
            else if (________)
                digit ++;               /统计数字字符 /
            else if (str[i] == ‘ ‘ )
                space ++;               /统计空格/
            else
                others ++;              /统计其他字符的个数/
    }
    printf("English character:  %d", letter);
    printf("digit character:  %d", digit);
    printf("space:  %d", space);
    printf("other character:  %d", others);
    return 0;
    }
选项：
A:第9行：  gets(str)第10行： str[i] != ‘\0’第12行： str[i] >= ‘a’ && str[i] <= ‘z’ || str[i] >= ‘A’ && str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 
B:第9行：  scanf("%s",str)第10行： str[i] != ‘\0’第12行： ‘z’ >= str[i] >= ‘a’ || ‘A’ <= str[i] <= ‘Z’第14行： 9 >= str[i] >= 0 
C:第9行：  puts(str)第10行： str[i] != ”第12行： ‘z’ >= str[i] >= ‘a’ || ‘A’ <= str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 
D:第9行：  scanf("%s",str)第10行： str[i] != ”第12行： str[i] >= ‘a’ || str[i] <= ‘z’ && str[i] >= ‘A’ || str[i] <= ‘Z’第14行： str[i] >= 0 && str[i] <= 9 
答案: 【第9行：  gets(str)第10行： str[i] != ‘\0’第12行： str[i] >= ‘a’ && str[i] <= ‘z’ || str[i] >= ‘A’ && str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 】

19、 问题:下面程序的功能是在字符串每个字符间插入一个空格。程序的运行结果如下：Input a string:Howareyou↙Insert results:H o w a r e y o u按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 100

void Insert(char s[]);
int main()
{
     char str[N];
     printf("Input a string:");
     gets(str);
     Insert(str);
     printf("Insert results:%s", str);
     return 0;
}

void Insert(char s[])
{
    char t[N];
    int  i, j;
    __;
    for (i=0, j=0; _; i++, j++)
    {
        _;
        j++;
        ______;
    }
    s[j] = ‘\0’;/ 在字符串s的末尾添加字符串结束标志 /
}
选项：
A:第19行：strcpy(t, s)第20行：t[i]!=’\0’第22行：s[j] = t[i]第24行：s[j] = ‘ ‘
B:第19行：t=s;第20行：t[i]!=’\0’第22行：s[i] = t[j]第24行：s[j] = ‘ ‘
C:第19行：strcpy(t, s)第20行：t[i]=’\0’第22行：t[j] = s[i]第24行：s[j] = ‘\0 ‘
D:第19行：strcpy(s, t)第20行：t[i]==’\0’第22行：s[j] = t[i]第24行：s[j] = ‘0 ‘
答案: 【第19行：strcpy(t, s)第20行：t[i]!=’\0’第22行：s[j] = t[i]第24行：s[j] = ‘ ‘】

20、 问题:子函数Change的功能是将英文大写字母转换为小写字母，下面程序的输出结果是 abc_abc_def按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void Change(_)
{    
    int i;
    for(;_;ch++)
    {
        if(_)  
        __;
    }
}

int main()
{   
     char s[]="ABC_abc_DEF";
     Change(s);
     printf("%s",s);
     return 0;
}
选项：
A:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
B:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
C:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
D:第2行：  char ch[]第5行：  ch==’\0’第7行：  ch>=’A’|| ch<=’Z’第8行：  ch=ch-‘A’+’a’
答案: 【第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=*ch-‘A’+’a’】

21、 问题:下面程序的功能是比较用户键盘输入的口令userInput与内设的口令password是否相同。若相同，则输出"Correct password! Welcome to the system…"，若userInput<password，则输出"Invalid password!user input<password"，否则输出"Invalid password!user input>password"。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main()
{
    char password[7] = "secret";     
    char userInput[81] ; 
    printf("Input Password:");
    scanf(___);
    if ( __ )
        printf("Correct password! Welcome to the system…");
    else if ( _____)
    
        printf("Invalid password!user input<password");
    else 
        printf("Invalid password!user input>password");    
    return 0;
}
选项：
A:第8行： "%s", userInput第9行： strcmp(userInput, password) == 0第11行： strcmp(userInput, password) < 0
B:第8行： "%c", userInput第9行： strcmp(userInput, password) = 0第11行： strcmp(userInput, password) < 0
C:第8行： "%s", userInput第9行： userInput==password第11行： userInput<password
D:第8行： "%c", userInput第9行： strcpy(userInput, password) == 0第11行： strcpy(userInput, password) < 0
答案: 【第8行： "%s", userInput第9行： strcmp(userInput, password) == 0第11行： strcmp(userInput, password) < 0】

22、 问题:下列说法错误的是
选项：
A:字符数组的最后一个元素必须是字符’0’才能表示一个字符串。
B:char pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
C:char pStr;scanf("%s", pStr);这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。
D:字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
E:用双引号括起的一串字符是字符串常量，系统自动为其添加空字符’\0’作为字符串的结束标志。
F:通过间接寻址运算符引用指针变量指向的变量的值，称为指针的解引用。
答案: 【字符数组的最后一个元素必须是字符’0’才能表示一个字符串。;
char pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。;
char pStr;scanf("%s", pStr);这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。】

23、 问题:下列说法正确的是
选项：
A:指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。
B:指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。
C:指针变量占用的内存单元字节数就是它所指向的变量所占用的内存单元字节数。
D:strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符’\0’将被覆盖。
E:字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
F:strlen()计算的是包含’\0’在内的字符串的长度。
答案: 【指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。;
指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。】

第11周——指针的孪生兄弟 第11周测验

1、 问题:下面程序的功能是用指针变量作函数参数编程计算任意m×n阶矩阵的转置矩阵。要求用指向一维数组的指针变量即二维数组的行指针作函数参数。程序的运行结果如下：Please enter matrix:1 2 3 4↙1 2 3 4↙1 2 3 4↙The transposed matrix is:1    1    12    2    23    3    34    4    4按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

define ROW 3

define COL 4

void Transpose(int (a)[COL], int (at)[ROW], int row, int col);  
void InputMatrix(int (s)[COL], int row, int col);    
void PrintMatrix(int (s)[ROW], int row, int col);    
int main(void)
{
    int s[ROW][COL];//s代表原矩阵
    int st[COL][ROW];//st代表转置后的矩阵
    printf("Please enter matrix:");
    InputMatrix(s, ROW, COL);//输入原矩阵,s指向矩阵s的第0行,是行指针
    Transpose(s, st, ROW, COL);//对矩阵s进行转置,结果存放于st中  
    printf("The transposed matrix is:");
    PrintMatrix(st, COL, ROW); //输出转置矩阵,*st指向st的第0行,是行指针
    return 0;
}

//函数功能： 对任意row行col列的矩阵a转置，转置后的矩阵为at
void Transpose(__,int (*at)[ROW], int row, int col)   
{ 
    int i, j;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            _______;   
        }
    }
}

void InputMatrix(__, int row, int col)   //输入矩阵元素
{
    int i, j;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            scanf("%d", __);// 元素s[i][j]
        }
    }
}

void PrintMatrix(int _____, int row, int col)   //输出矩阵元素
{
    int i, j;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            printf("%d\t", ((s+i)+j)); // 元素s[i][j]
        }
        printf(" ");
    }
}
选项：
A:第20行：  int (a)[COL]第27行：  ((at+j)+i) = ((a+i)+j)第32行：  int(s)[COL]第39行：  (s+i)+j第44行：  (s)[ROW]
B:第20行：  int a[COL]第27行：  ((at+j)+i) = ((a+i)+j)第32行：  int(s)[ROW]第39行：  (s+i)+j第44行：  s[COL]
C:第20行：  int (a)[ROW]第27行：  (at+j+i) = ((a+i)+j)第32行：  int(s)[COL]第39行：  (s+i+j)第44行：  (s)[ROW]
D:第20行：  int (a)[COL]第27行：  ((at+j)+i) = ((a+i+j))第32行：  int(s)[ROW]第39行：  (s)+i+j第44行：  (s)[COL]
答案: 【第20行：  int (a)[COL]第27行：  ((at+j)+i) = ((a+i)+j)第32行：  int(s)[COL]第39行：  (s+i)+j第44行：  (s)[ROW]】

2、 问题:口袋中有若干红、黄、蓝、白、黑5种颜色的球，每次从口袋中取出3个球，编程输出得到3种不同颜色的球的所有可能取法。下面程序用三重循环模拟取球过程，但每次取出的球如果与前面的球颜色相同就抛弃。程序的运行结果如下：1:RED,YELLOW,BLUE2:RED,YELLOW,WHITE3:RED,YELLOW,BLACK4:RED,BLUE,WHITE5:RED,BLUE,BLACK6:RED,WHITE,BLACK7:YELLOW,BLUE,WHITE8:YELLOW,BLUE,BLACK9:YELLOW,WHITE,BLACK10:BLUE,WHITE,BLACK按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
    char bColor[] = {"RED","YELLOW","BLUE","WHITE","BLACK"};
    int i, j, k, m = 0;
    for (i=0; i<5; i++)
    {
        for (_; j<5; j++)
        {
            for (_; k<5; k++)
            {
                m++;
                printf("%d:%s,%s,%s", _______);
            }
        }
    }
    return 0;
}
选项：
A:第8行：   j=i+1第10行：  k=j+1第13行：  m, bColor[i], bColor[j], bColor[k]
B:第8行：   j=1第10行：  k=1第13行：  m, bColor+i, bColor+j, bColor+k
C:第8行：   j=i第10行：  k=j第13行：  m,(bColor+i), (bColor+j), (bColor+k)
D:第8行：   j=0第10行：  k=0第13行：  m, bColor[i], bColor[j], bColor[k]
答案: 【第8行：   j=i+1第10行：  k=j+1第13行：  m, bColor[i], bColor[j], bColor[k]】

3、 问题:char (*p)[10];该语句定义了一个
选项：
A:指向含有10个元素的一维字符型数组的指针变量p
B:指向长度为10的字符串的指针变量p
C:有10个元素的指针数组p，每个元素可以指向一个字符串
D:有10个元素的指针数组p，每个元素存放一个字符串
答案: 【指向含有10个元素的一维字符型数组的指针变量p】

4、 问题:设有以下定义：       int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};       int (ptr)[3] = a;       int p = a[0];则以下能够正确表示数组元素a[1][2]的表达式是
选项：
A:((ptr + 1) + 2)
B:((ptr + 1) + 2)
C:((p + 5))
D:(ptr + 1) + 2
答案: 【(*(ptr + 1) + 2)】

5、 问题:二维数组a有m行n列，则在a[i][j]之前的元素个数为
选项：
A:in+j
B:jn+i
C:in+j-1 
D:in+j+1 
答案: 【i*n+j】

6、 问题:下面关于表达式(p)++和p++的含义分析说明中，错误的是
选项：
A:(p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，此时p不再指向原来的存储单元。
B:(p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，而p仍然指向原来的存储单元。
C:p++则指的是先取出p指向的存储单元中的内容，然后将p值加1，此时p不再指向原来的存储单元。
D:表达式(p)++和p++具有不同的含义，(p)++并没有修改指针p的指向，而p++则修改了指针p的指向。
答案: 【(p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，此时p不再指向原来的存储单元。】

7、 问题:假设有下面定义语句：float a[10];float p=a;则p++相当于是加上（）个字节
选项：
A:sizeof(float)
B:1个字节
C:sizeof(p)
D:sizeof(a)
E:sizeof(float)
答案: 【sizeof(float)】

8、 问题:下列说法中错误的是
选项：
A:char country[] = {"French", "England", "Japan", "China", "Finland"};这条语句定义了一个字符指针数组country，并将初始化列表中的字符串保存到字符指针数组中。
B:当指针变量指向一维数组的时候，sizeof(数组名）和sizeof(指针变量名）的计算结果是不相同的。
C:指针的算术运算允许通过对指针变量重复自增来访问数组的元素。
D:指针指向数组元素时，指针算术运算才是有意义的。
答案: 【char country[] = {"French", "England", "Japan", "China", "Finland"};这条语句定义了一个字符指针数组country，并将初始化列表中的字符串保存到字符指针数组中。】

9、 问题:下面程序希望得到的运行结果如下：Total string numbers = 3How are you但是现在代码存在错误，找出下面选项中修改正确的语句#include <stdio.h>
void  Print(char arr[], int len);  
int main()
{
    char pArray[] = {"How","are","you"};
    int   num = sizeof(pArray) / sizeof(char);  
    printf("Total string numbers = %d", num); 
    Print(pArray, num);
    return 0;
}

void  Print(char arr[], int len)
{
    int  i;    
    for (i=0; i<len; i++)
    {
        printf("%s ", arr[i]);
    }
    printf("");
}
选项：
A:第6行应该是：  int   num = sizeof(pArray) / sizeof(char);
B:第12行应该是：  void  Print(char arr[], int len)
C:第5行应该是：  char pArray[] = {"How","are","you"};
D:第6行应该是：  int   num = sizeof(pArray/char );  
答案: 【第6行应该是：  int   num = sizeof(pArray) / sizeof(char);】

10、 问题:以下程序运行后的输出结果是#include <stdio.h>
int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;
    b=p[5];
    printf("%d",b);
    return 0;
}
选项：
A:9
B:5
C:6
D:8
答案: 【9】

11、 问题:有以下程序段,则(p[0]+1)所代表的数组元素是#include <stdio.h>
int main()
{
     int a[3][2]={1,2,3,4,5,6,},p[3];
     p[0]=a[1];
     …..
     return 0;
}
选项：
A:a[1][1]
B:a[0][1]
C:a[1][0]
D:a[1][2]
答案: 【a[1][1]】

12、 问题:以下程序运行后的输出结果是#include <stdio.h>
int main()
{ 
    int a[3][3],*p,i;
    p=&a[0][0];
    for(i=0;i<9;i++) 
    {
        p[i]=i+1;
    }
    printf("%d",a[1][2]);
    return 0;
}
选项：
A:6
B:3
C:9
D:2
答案: 【6】

13、 问题:如下程序的执行结果是 #include<stdio.h>
int main()
 {  
     int a[ ][4]={1,3,5,7,9,11,13,15,17,19,21,23};
     int (p)[4],i=1,j=2;
     p=a;
     printf("%d",(*(p+i)+j));
     return 0;
}
选项：
A:13
B:9
C:11
D:17
答案: 【13】

14、 问题:在以下程序段中的空白处填写适当的表达式或语句，使程序能正确引用c数组元素。#include <stdio.h>
int main()
{
    int c[4][5],(p)[5],i,j,d=0;
    for(i=0;i<4;i++)
    {
for(j=0;j<5;j++)
{
    c[i][j]=d;
    d++;
    printf("%4d",c[i][j]);
}
printf("");
    }
    p=c;
    printf("%d,%d",______);
    return 0;
}
选项：
A:(p[0]+2),c[0][2]
B:(p+1)+3,c[1][3]
C:(p+3),c[0][3]
D:p+1,c[0][1]
答案: 【*(p[0]+2),c[0][2]】

15、 问题:下面给出的选项中，能定义为一个指针数组的语句是
选项：
A:int ptr[5];
B:int (ptr)[5];
C:int (ptr[5]);
D:int ptr[5];
答案: 【int ptr[5];】

16、 问题:若有定义“int p[5];”，则以下叙述中正确的是 
选项：
A:定义了一个指针数组p，该数组含有5个元素，每个元素都是基类型为int的指针变量
B:定义了一个基类型为int的指针变量p，该变量有5个指针
C:定义了一个名为p的整型数组，该数组含有5个int类型元素
D:定义了一个可指向一维数组的指针变量p，所指一维数组应具有5个int类型元素
答案: 【定义了一个指针数组p，该数组含有5个元素，每个元素都是基类型为int的指针变量】

17、 问题:设有定义语句int x[6]={2,4,6,8,5,7},p=x,i;要求依次输出x数组6个元素中的值，不能完成此操作的语句是
选项：
A:for(i=0;i<6;i++) printf("%2d",(p)++);
B:for(i=0;i<6;i++) printf("%2d",(p++)); 
C:for(i=0;i<6;i++) printf("%2d",(p+i)); 
D:for(i=0;i<6;i++) printf("%2d",p++); 
答案: 【for(i=0;i<6;i++) printf("%2d",(p)++);】

18、 问题:若二维数组a有m行n列，则下面能够正确引用元素a[i][j]的为
选项：
A:((a+i)+j)
B:(a+jn+i)
C:(a+in+j)
D:(a+i)+j
答案: 【((a+i)+j)】

19、 问题:设有语句“int array[3][4];”，则在下面几种引用下标为i和j的数组元素的方法中，不正确的引用方式是__。
选项：
A:(array + i4 + j)
B:array[i][j]
C:((array + i) + j)
D:(array[i] + j)
答案: 【(array + i*4 + j)】

20、 问题:有int *p[10];以下说法错误的是__。
选项：
A:p++操作是合法的
B:p是数组名
C:p是一个指针数组
D:p中每个元素都是一个指针变量
答案: 【p++操作是合法的】

第10周——字符串：C语言世界中的大力水手 练兵区——单选题——不计入总分

1、 问题:下面能正确进行字符串赋值操作的是
选项：
A:char s=“ABCDE”; 
B:char s[5]={“ABCDE”}; 
C:char s[5]={‘A’, ‘B’, ‘C’, ‘D’, ‘E’}; 
D:char s,scanf(“%s”,s); 
答案: 【char *s=“ABCDE”; 】

2、 问题:已知：int *p(); 则p是
选项：
A:一个函数，该函数的返回值是指向int型的指针变量
B:指向int型的指针变量
C:int型的指针数组
D:一个指向函数的指针变量，该函数的返回值是int型
答案: 【一个函数，该函数的返回值是指向int型的指针变量】

3、 问题:给出以下定义，则正确的叙述是char  x[ ]= “abcedfg”;char  y[ ]={ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’’, ‘g’ };
选项：
A:数组x 的长度大于数组y的长度
B:数组x 和数组y 等价
C:数组x 和数组y 的长度相同
D:数组x 的长度小于数组y的长度
答案: 【数组x 的长度大于数组y的长度】

4、 问题:下面程序的功能是用字符指针变量作函数参数编程实现字符串连接函数strcat()的功能，将字符串srcStr连接到字符串dstStr的尾部。程序的运行结果如下：Please enter the source string:abcd↙Please enter the other string:efgh↙The concat is:abcdefgh按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void  MyStrcat(char dstStr, char srcStr);
int main()
{
    char  s[80];  //源字符串
    char  t[80];  //待连接字符串
    printf("Please enter the source string: ");
    gets(s);
    printf("Please enter the other string: ");
    gets(t);  //输入字符串
    MyStrcat(s, t);  //将字符数组t中的字符串连到s的尾部
    printf("The concat is:");
    puts(s);  //输出连接后的字符串s
    return 0;
}

void  MyStrcat(char dstStr, char srcStr)   //用字符指针作为函数参数
{
    while (_)
    {
        dstStr++;
    }
    while (*srcStr != ‘\0’)  //若srcStr所指字符不是字符串结束标志
    { 
        __; //将srcStr所指字符复制到dstStr所指的存储单元中
        srcStr++;  //使srcStr指向下一个字符
        dstStr++; //使dstStr指向下一个存储单元
    }
     _____; //在字符串dstStr的末尾添加一个字符串结束标志
}
选项：
A:第19行： dstStr != ‘\0’第25行： dstStr = * srcStr第29行： dstStr = ‘\0’
B:第19行： dstStr != ‘\0’第25行： dstStr =  srcStr第29行： dstStr = ‘\0’
C:第19行： dstStr == ‘\0’第25行： dstStr = * srcStr第29行： dstStr = ”
D:第19行： dstStr == ‘\0’第25行： dstStr =  srcStr第29行： dstStr = ”
答案: 【第19行： dstStr != ‘\0’第25行： dstStr = * srcStr第29行： *dstStr = ‘\0’】

5、 问题:以下程序中函数FindMinString的功能是返回形参指针s1和s2所指字符串中较小字符串的首地址。例如，若运行时依次输入三个字符串：123↙1223↙124↙输出结果为1223按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

char *FindMinString( ___ )
{
    if(_____)
        return(s1);
    else
        return(s2);
}

int main()
{
    int i; 
    char string[20], str[3][20];
    for(i=0;i<3;i++) 
    {
        gets(str[i]);
    }
    strcpy(string,FindMinString(str[0],str[1])); /对字符串进行复制/
    strcpy(string,_______);
    printf("%s",string);
    return 0;
}
选项：
A:第3行： char s1, char s2第5行： strcmp(s1,s2)<0第20行： FindMinString(string,str[2])
B:第3行： char s1, char s2第5行： s1<s2第20行： FindMinString(string,str[2])
C:第3行： char s1, char s2第5行： strcmp(s1,s2)>0第20行： FindMinString(str[0],str[2])
D:第3行： char s1, char s2第5行： s1>s2第20行： strcmp(str[1],str[2])
答案: 【第3行： char s1, char s2第5行： strcmp(s1,s2)<0第20行： FindMinString(string,str[2])】

6、 问题:子函数Move的功能是将某字符串中的第i个字符向左移动1位，覆盖第i-1个字符。下面程序通过多次调用Move函数，将字符数组b中存放的字符串依次左移3位，并在移动后的字符串末尾添上字符0补足。程序的运行结果为：234567890034567890004567890000按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void Move( ___,int i)
{
    a[i-1]=a[i];
}

int main( )
{   
    char b[11]={"1234567890"};
    int i,j;
    for (j=0;j<=2;j++)
    {
      for(i=1;b[i]!=’\0′;i++)
        {
            _;
            printf("%c",b[i-1]);
        }
      __;
      printf("%c",______);
    }
    return 0;
}
选项：
A:第2行：  char a第15行： Move(b,i)第18行： b[i-1]=’0’第19行： b[i-1]
B:第2行：  char a第15行： Move(b,i)第18行： b[i-1]=’\0’第19行： b[i-1]
C:第2行：  char a第15行： Move(b,i)第18行： b[i]=’0’第19行： b[i]
D:第2行：  char a第15行： Move(i,b)第18行： b[i]=’\0’第19行： b[i]
答案: 【第2行：  char *a第15行： Move(b,i)第18行： b[i-1]=’0’第19行： b[i-1]】

7、 问题:下面程序的功能是将字符数组中存放的字符串以多种书写形式输出，如“Program”，“PROGRAM”，以及逆序输出的字符串“margorp”等，程序的运行结果为：ProgramPROGRAMmargorp按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main(void)
{
    int  i = 0;
    char  b[] = "program";
    char  a = "PROGRAM";
    printf("_", a, b + 1);  / 输出Program */
    while (___)    / 输出PROGRAM /
    {   
        __;
        i++;
    }
    printf("");
    while (__)                / 输出margorp /
    {
        putchar (__);
    }
    _;
    return 0;
}
选项：
A:第8行：  %c%s第9行：  (a+i)!=’\0’第11行： putchar((a + i))第15行： –i第17行： (b + i)第19行： putchar ((b + i))
B:第8行：  %s%s第9行：  （a+i)!=’\0’第11行： putchar(a + i))第15行： i–第17行： (b + i)第19行： putchar ((b + i))
C:第8行：  %c%s第9行：  (a+i)==’\0’第11行：  putchar((a + i)) 第15行： –i第17行： b + i第19行： putchar (b + i))
D:第8行：  %s%s第9行：  （a+i)==’\0’第11行：  putchar(a + i))第15行： i–第17行： b + i第19行： putchar (b + i)
答案: 【第8行：  %c%s第9行：  (a+i)!=’\0’第11行： putchar((a + i))第15行： –i第17行： (b + i)第19行： putchar (*(b + i))】

8、 问题:Squeeze函数的功能是删除字符串s中所出现的与变量c相同的字符。例如，输入为：abcdef↙c↙输出为：abdef按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

void Squeeze(char s, char c);
int main()
{
    char  a[80], c, s;
    s = a;
    gets(a);
    scanf("%c",&c);
    Squeeze(s, c);
    printf("%s", s);
    return 0;
    }
    
 void  Squeeze(char s, char c)
    {
        int i, j;
        for (i = j = 0; s[i] != ‘\0’; i++)
            {
                if (_)
                {
                    _;
                    j++;
                }
            }
        _______; / 在字符串t2的末尾添加字符串结束标志 */
     }
选项：
A:第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ‘\0’
B:第20行： s[i] == c第22行： s[j] = s[i]第26行： s[i] = ‘\0’
C:第20行： s[j] != c第22行： s[i] = s[j]第26行： s[j] = ‘\0’
D:第20行： s[j] == c第22行： s[j] = s[i]第26行： s[i] = ‘\0’
答案: 【第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ‘\0’】

9、 问题:下列对字符串的定义中，错误的是
选项：
A:char  str[7] = "FORTRAN";
B:char  str[] = "FORTRAN";
C:char  *str = "FORTRAN";
D:char  str[] = {‘F’,’O’,’R’,’T’,’R’,’A’,’N’,0};
答案: 【char  str[7] = "FORTRAN";】

10、 问题:下面函数Fun的功能是void Fun(char s1, char s2){    while(s2++=s1++);}
选项：
A:串复制
B:求串长
C:串比较
D:串反向
答案: 【串复制】

11、 问题:执行以下代码段后，输出的字符串是#include <stdio.h>

include <string.h>

int main()
{
   char s1[10],*s2="ab\0cdef";
   strcpy(s1,s2);
   puts(s1);
   …….
   return 0;
}
选项：
A:ab
B:cdef
C:ab\0cdef
D:内容不确定
答案: 【ab】

12、 问题:下面程序的功能是从键盘输入一个字符串，编程将其字符顺序颠倒后重新存放，并输出这个字符串。程序的运行结果如下：Input a string:abcdef↙The inversed string is:fedcba按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

void Inverse(char *pStr);
int main()
{
    char  str[80];
    printf("Input a string:");
    gets(str);//输入字符串
    Inverse(str);//将存于str数组中的字符串逆序存放
    printf("The inversed string is:");
    puts(str);//输出字符串
    return 0;
}

void Inverse(char pStr)
{
    int  len = 0;
    char temp;
    char pStart = pStr;//指针变量pStart指向字符串的第一个字符
    char pEnd;//指针变量pEnd指向字符串的最后一个字符
    for (; pStart!=’\0′; ___)    //求出字符串长度
        {
            len++;
        }
    for (pStart=pStr,__; pStart<pEnd; pStart++,pEnd–)
    {
        temp = __;
        __;
        
        pEnd = temp;
    }
}
选项：
A:第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd
B:第21行：  pStart++第25行：  pEnd=pStr+len第27行：  pStart第28行：  pStart = pEnd
C:第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd
D:第21行：  pStart++第25行：  pEnd=pStr+len第27行：  pStart第28行：  pStart = pEnd
答案: 【第21行：  pStart++第25行：  pEnd=pStr+len-1第27行：  pStart第28行：  pStart = pEnd】

13、 问题:下面函数Fun的功能是#include <stdio.h>

include <string.h>

int Fun(char ps)
{
    char p;
    p=ps;
    while(*p++);
    return (p-ps);
}

int main()
{
    char  *s;
    int a1,a2;
    s = "hello";
    a1=Fun(s);
    a2=strlen(s);
    printf("%d,%d", a1,a2);
    return 0;
    }
选项：
A:以上三种说法都不对
B:比较两个字符串的大小
C:求字符串的长度
D:将串ps复制到串s中
答案: 【求字符串的长度】

14、 问题:下面程序的功能是从键盘输入一行字符（不超过80个），统计其中的英文字符、数字字符、空格和其他字符的个数。例如，输入的一行字符为*c language.***输出为English character:  9digit character:  0space:  1other character:  11按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define STR_LEN 80

int main()
{
    char str[STR_LEN+1];
    int  len, i, letter = 0, digit = 0, space = 0, others = 0;
    printf("Please input a  string:");
    __;
    for (i = 0; _; i++)
        {
            if (_____)
                letter ++;              /统计英文字符 /
            else if (________)
                digit ++;               /统计数字字符 /
            else if (str[i] == ‘ ‘ )
                space ++;               /统计空格/
            else
                others ++;              /统计其他字符的个数/
    }
    printf("English character:  %d", letter);
    printf("digit character:  %d", digit);
    printf("space:  %d", space);
    printf("other character:  %d", others);
    return 0;
    }
选项：
A:第9行：  gets(str)第10行： str[i] != ‘\0’第12行： str[i] >= ‘a’ && str[i] <= ‘z’ || str[i] >= ‘A’ && str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 
B:第9行：  scanf("%s",str)第10行： str[i] != ‘\0’第12行： ‘z’ >= str[i] >= ‘a’ || ‘A’ <= str[i] <= ‘Z’第14行： 9 >= str[i] >= 0 
C:第9行：  puts(str)第10行： str[i] != ”第12行： ‘z’ >= str[i] >= ‘a’ || ‘A’ <= str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 
D:第9行：  scanf("%s",str)第10行： str[i] != ”第12行： str[i] >= ‘a’ || str[i] <= ‘z’ && str[i] >= ‘A’ || str[i] <= ‘Z’第14行： str[i] >= 0 && str[i] <= 9 
答案: 【第9行：  gets(str)第10行： str[i] != ‘\0’第12行： str[i] >= ‘a’ && str[i] <= ‘z’ || str[i] >= ‘A’ && str[i] <= ‘Z’第14行： str[i] >= ‘0’ && str[i] <= ‘9’ 】

15、 问题:下面程序的功能是在字符串每个字符间插入一个空格。程序的运行结果如下：Input a string:Howareyou↙Insert results:H o w a r e y o u按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 100

void Insert(char s[]);
int main()
{
     char str[N];
     printf("Input a string:");
     gets(str);
     Insert(str);
     printf("Insert results:%s", str);
     return 0;
}

void Insert(char s[])
{
    char t[N];
    int  i, j;
    __;
    for (i=0, j=0; _; i++, j++)
    {
        _;
        j++;
        ______;
    }
    s[j] = ‘\0’;/ 在字符串s的末尾添加字符串结束标志 /
}
选项：
A:第19行：strcpy(t, s)第20行：t[i]!=’\0’第22行：s[j] = t[i]第24行：s[j] = ‘ ‘
B:第19行：t=s;第20行：t[i]!=’\0’第22行：s[i] = t[j]第24行：s[j] = ‘ ‘
C:第19行：strcpy(t, s)第20行：t[i]=’\0’第22行：t[j] = s[i]第24行：s[j] = ‘\0 ‘
D:第19行：strcpy(s, t)第20行：t[i]==’\0’第22行：s[j] = t[i]第24行：s[j] = ‘0 ‘
答案: 【第19行：strcpy(t, s)第20行：t[i]!=’\0’第22行：s[j] = t[i]第24行：s[j] = ‘ ‘】

16、 问题:下面程序的功能是实现字符串逆序存放。程序运行结果如下：Input a string:ABCDEFGHI↙Inversed results:IHGFEDCBA按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 80

void Inverse(char *pStr);
int main()
{
    char a[N];
    printf("Input a string:");
    gets(a);
    Inverse(a);
    printf("Inversed results:%s", a);
    return 0;
}

/ 函数功能： 实现将字符数组中的字符串逆序存放 /
void Inverse(__)
{
    int  len;
    char temp;
    char pStart;  / 指针变量pStart指向字符串的第一个字符 /
    char pEnd;   / 指针变量pEnd指向字符串的最后一个字符 /
    len = strlen(pStr);  / 求出字符串长度 /
    for (pStart=pStr,___; pStart<pEnd; pStart++,_)
    {
        temp = *pStart;
        _____;
        
        pEnd = temp;
    }
}
选项：
A:第16行：   char pStr第23行：   pEnd=pStr+len-1             pEnd–第26行：   pStart = pEnd
B:第16行：   char pStr第23行：   pEnd=pStr+len             pEnd–第26行：   pStart = pEnd
C:第16行：  char pStr第23行：  pEnd=pStr+len-1            pEnd++第26行：   pStart = pEnd
D:第16行：  char pStr第23行：  pEnd=pStr+len+1            pEnd++第26行：   pStart = pEnd
答案: 【第16行：   char pStr第23行：   pEnd=pStr+len-1             pEnd–第26行：   pStart = pEnd】

17、 问题:子函数Change的功能是将英文大写字母转换为小写字母，下面程序的输出结果是 abc_abc_def按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
void Change(_)
{    
    for(;_;ch++)
    {
        if(_)  
        __;
    }
}

int main()
{   
     char s[]="ABC_abc_DEF";
     Change(s);
     printf("%s",s);
     return 0;
}
选项：
A:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
B:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
C:第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=ch-‘A’+’a’
D:第2行：  char ch[]第5行：  ch==’\0’第7行：  ch>=’A’|| ch<=’Z’第8行：  ch=ch-‘A’+’a’
答案: 【第2行：  char ch第5行：  ch!=’\0’第7行：  ch>=’A’&& ch<=’Z’第8行：  ch=*ch-‘A’+’a’】

18、 问题:下面程序的功能是比较用户键盘输入的口令userInput与内设的口令password是否相同。若相同，则输出"Correct password! Welcome to the system…"，若userInput<password，则输出"Invalid password!user input<password"，否则输出"Invalid password!user input>password"。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main()
{
    char password[7] = "secret";     
    char userInput[81] ; 
    printf("Input Password:");
    scanf(___);
    if ( __ )
        printf("Correct password! Welcome to the system…");
    else if ( _____)
    
        printf("Invalid password!user input<password");
    else 
        printf("Invalid password!user input>password");    
    return 0;
}
选项：
A:第8行： "%s", userInput第9行： strcmp(userInput, password) == 0第11行： strcmp(userInput, password) < 0
B:第8行： "%c", userInput第9行： strcmp(userInput, password) = 0第11行： strcmp(userInput, password) < 0
C:第8行： "%s", userInput第9行： userInput==password第11行： userInput<password
D:第8行： "%c", userInput第9行： strcpy(userInput, password) == 0第11行： strcpy(userInput, password) < 0
答案: 【第8行： "%s", userInput第9行： strcmp(userInput, password) == 0第11行： strcmp(userInput, password) < 0】

19、 问题:下列说法正确的是
选项：
A:指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。
B:指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。
C:指针变量占用的内存单元字节数就是它所指向的变量所占用的内存单元字节数。
D:strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符’\0’将被覆盖。
E:字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
F:strlen()计算的是包含’\0’在内的字符串的长度。
答案: 【指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。;
指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。】

20、 问题:下列说法错误的是
选项：
A:字符数组的最后一个元素必须是字符’0’才能表示一个字符串。
B:char pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
C:char pStr;scanf("%s", pStr);这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。
D:字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
E:用双引号括起的一串字符是字符串常量，系统自动为其添加空字符’\0’作为字符串的结束标志。
F:通过间接寻址运算符引用指针变量指向的变量的值，称为指针的解引用。
答案: 【字符数组的最后一个元素必须是字符’0’才能表示一个字符串。;
char pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。;
char pStr;scanf("%s", pStr);这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。】

21、 问题:以下程序的功能是分别测量字符数组及数组中存放的字符串的长度，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

int main( )
{ 
    char a[]="abcdefg",b[10]="abcdefg";
    ____;  /测量字符数组a,b的长度，并输出/
    ____;  /测量字符数组a,b中存放的字符串的长度，并输出/
    return 0;
}
选项：
A:第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))
B:第6行： printf("%d %d",strlen(a) ,strlen(b))第7行： printf("%d %d",sizeof(a) ,sizeof(b))
C:第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))
D:第6行： printf("%d %d",sizeof(&a) ,sizeof(&b))第7行： printf("%d %d",strlen(&a) ,strlen(&b))
答案: 【第6行： printf("%d %d",sizeof(a) ,sizeof(b))第7行： printf("%d %d",strlen(a) ,strlen(b))】

22、 问题:下面程序的功能是将一个字符串s2插入到字符串s1中，其起始插入位置为n。程序运行示例如下：main string:hello,world!sub string:cc site of begining:(<=12)5After instert:hellocc,world!按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <string.h>

define N 100

int main()
{
    int n, i, j, k, len;
    char s1[N], s2[N], s3[2 * N];
    printf("main string:");
    gets(s1);
    printf("sub string:");
    gets(s2);
    len = strlen(s1);
    do
        {
            printf("site of begining:(<=%d)", len);
            scanf("%d", &n);
        }while (_);
        
    for (i = 0; i < n; i++)
       {
           s3[i] = s1[i];
       }
    for (j = 0; s2[j] != ‘\0’; j++)
      {
           __;
      }
    for (_; s1[k] != ‘\0’; k++)
     {
           ____;
     }
    s3[j + k] = ‘\0’;
    printf("After instert:%s", s3);
    return 0;
}
选项：
A:第17行：  n > len第25行：  s3[i + j] = s2[j]第27行：  k = n第29行：  s3[j + k] = s1[k]
B:第17行：  n < len第25行：  s3[i] = s2[j]第27行：  k = n第29行：  s3[j] = s1[k]
C:第17行：  n <= len第25行：  s2[j]=s3[i + j] 第27行：  k = 0第29行：  s3[j] = s1[k]
D:第17行：  n >= len第25行：  s3[j] = s2[j]第27行：  k = 0第29行：  s1[k] = s3[j + k]
答案: 【第17行：  n > len第25行：  s3[i + j] = s2[j]第27行：  k = n第29行：  s3[j + k] = s1[k]】

23、 问题:下面程序的功能是从键盘输入一行字符（最长不超过80字符），用函数编程统计其中单词（以空格作为间隔符的字符串）的个数。基本思路是：当前被检验字符不是空格，而前一被检验字符是空格，则表示有新单词出现。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。（下面答案中两个单引号”中间都有一个空格）样例1：Input a string:How are you↙Numbers of words = 3样例2：Input a string:  How are you↙Numbers of words = 3#include <stdio.h>
int CountWords(char str[]);
int main()
{
    char  str[81];
    int num;
    printf("Input a string:");
    gets(str);
    num=CountWords(str);
    printf("Number of words=%d", num);
    return 0;
}

int CountWords(char str[])
{
    int  i, num;
    num = (_) ? 1 : 0;
    i=1;
    while (str[i]!=’\0′)
    {
        if (____)
        {
            num++;
        }
         __;
    }
    return num;
}
选项：
A:第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] == ‘ ‘第25行： i++
B:第17行： str[0] == ‘ ‘第21行： str[i]!=’ ‘ || str[i-1] == ‘ ‘第25行： i++
C:第17行： str[0] != ‘\0 ‘第21行： str[i]==’ ‘ && str[i-1] == ‘ ‘第25行： i++
D:第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] != ‘ ‘第25行： num++
答案: 【第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] == ‘ ‘第25行： i++】

第13周——原来内存也可以这么玩，我是指针我怕谁 练兵区——单选题——不计入总分

1、 问题:假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存mn个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。p = (int ) malloc(mnsizeof(int));或者p = (int ) calloc(mn, sizeof(int));
选项：
A:p[in+j]
B:（p+in+j）
C:p[jn+i]
D:p[i][j]
E:p[in+j]
F:p+in
G:p+in+j
答案: 【p[in+j];
（p+i*n+j）】

2、 问题:下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>

include <stdlib.h>

int main()
{
    int p,n,i;
    printf("Enter array size:");
    scanf("%d",&n);
    ___;
    
    for(i=0;i<n;i++)
    { 
        ___;
    }
    for(i=0;i<n;i++)
    {
        ___;
    }    
    free(p);
    return 0;
}
选项：
A:第8行：  p=(int )malloc(nsizeof(int));第12行： (p+i)=i10第16行： printf("array[%d]=%d",i,(p+i))
B:第8行：  p=(int )(nmalloc(sizeof(int)))第12行： p+i=i10第16行： printf("array[%d]=%d",i,(p+i))
C:第8行：  p=(int )malloc(nsizeof(int));第12行： p+i=i10第16行： printf("array[i]=%d",i,p+i)
D:第8行：  p=(int)malloc(nsizeof(int ));第12行： (p+i)=i10第16行： printf("array[i]=%d",i,(p+i))
答案: 【第8行：  p=(int )malloc(nsizeof(int));第12行： (p+i)=i10第16行： printf("array[%d]=%d",i,*(p+i))】

3、 问题:下列说法正确的是
选项：
A:执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
B:函数free()的参数是指向被释放的动态内存的指针变量。
C:对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
D:函数free的函数原型是void free(void p);表示函数没有返回值。
E:程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
F:执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
G:用动态内存分配函数来申请的内存都是从栈上分配的。
H:栈的特点是先进先出。
I:用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
答案: 【执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。;
函数free()的参数是指向被释放的动态内存的指针变量。;
对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。】

4、 问题:对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
选项：
A:void 的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B:void 的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C:void 的含义是指该函数没有返回值
D:以上说法都不对
答案: 【void 的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。】

5、 问题:下列说法错误的是
选项：
A:无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
B:用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
C:在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
D:对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
E:对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
F:用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
G:计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
H:为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。
答案: 【无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。;
用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。;
在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。】

6、 问题:下列说法错误的是
选项：
A:系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B:函数realloc()用于改变原来分配的存储空间的大小。
C:对于函数void  calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D:向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E:函数void  calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F:void型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type)为其他类型。
G:用calloc动态申请的内存会自动初始化为0.
答案: 【系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.】

7、 问题:下面关于内存泄漏问题的描述错误的是（）
选项：
A:只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
B:内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
C:指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
D:出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
E:内存泄漏问题通常需要运行相当一段时间后才能发现。
F:C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
G:需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。
答案: 【只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。;
内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。;
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。】

8、 问题:下面程序希望得到的运行结果如下：Total string numbers = 3How are you目前程序存在错误，请找出错误所在并加以改正。#include <stdio.h>
void  Print(char arr[], int len);  
int main()
{
    char pArray[] = {"How","are","you"};
    int   num = sizeof(pArray) / sizeof(char);  
    printf("Total string numbers = %d", num); 
    Print(pArray, num);
    return 0;
}

void  Print(char arr[], int len)
{
    int  i;    
    for (i=0; i<len; i++)
    {
        printf("%s ", arr[i]);
    }
    printf("");
}
选项：
A:第6行错误改正为：int   num = sizeof(pArray) / sizeof(char);
B:第6行错误改正为：int   num = sizeof(char) / sizeof(pArray);
C:第12行错误改正为：char arr[]
D:第5行错误改正为：char pArray = {"How","are","you"}
答案: 【第6行错误改正为：int   num = sizeof(pArray) / sizeof(char*);】

9、 问题:申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？
选项：
A:p = (int ) malloc(n * sizeof(int)); 
B:p = (int )calloc(n, sizeof(int)); 
C:p = (int ) malloc(n, sizeof(int)); 
D:p = (int )calloc(n * sizeof(int)); 
E:int p[n];
F:p = (int ) realloc(n * sizeof(int)); 
答案: 【p = (int ) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int)); 】

10、 问题:关于下面程序中的变量和常量分布的内存区域说法错误的是#include <stdio.h>

include <stdlib.h >

static char array2[] = {"dddd"};
char array3[100];
int main()
{
     short b;
     char array1[]="aaaa";
     char p;
     p = (char )malloc(10*sizeof(int));
     strcpy(p,"bbbb");
     free(p);
     return 0;
}
选项：
A:指针变量p存放在堆中
B:"bbbb"存放在栈中
C:array3数组存放在静态存储区
D:本题中指针变量p指向的内存空间在堆中
E:"bbbb"存放在常量区
F:array2存放在静态存储区
答案: 【指针变量p存放在堆中;
"bbbb"存放在栈中】

11、 问题:下面说法错误的是
选项：
A:调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
B:如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
C:动态内存分配是指在程序运行时为变量分配内存的一种方法。
D:栈和堆都属于动态存储区。
答案: 【调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。】

12、 问题:申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？
选项：
A:p = (int ) malloc(mnsizeof(int)); 
B:p = (int )calloc(mn, sizeof(int)); 
C:p = (int ) malloc(mn, sizeof(int)); 
D:p = (int )calloc(m * n * sizeof(int)); 
E:int p[m][n];
F:p = (int ) realloc(m * n * sizeof(int)); 
答案: 【p = (int ) malloc(mnsizeof(int)); ;
p = (int )calloc(mn, sizeof(int)); 】

第14周——结构设计的艺术 练兵区——单选题——不计入总分

1、 问题:已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p，*q;则下面语句序列的功能是while(p->next->next != NULL)
{
  p = p->next;
}
free(p->next);
p->next = NULL;
选项：
A:删除链表的尾结点
B:删除p结点
C:删除结点q
D:删除p的前驱结点
答案: 【删除链表的尾结点】

2、 问题:已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p;若要删除头结点，则下面正确的语句序列是
选项：
A:p = head;head = p->next;free(p);
B:head = head->next;free(head);
C:p = head->next;free(p);
D:head = head->next;p = head;free(p);
答案: 【p = head;head = p->next;free(p);】

3、 问题:关于图的说法正确的是
选项：
A:图由顶点和边构成
B:图的邻接表属于顺序存储方式
C:图的邻接表属于链式存储方式
D:图的邻接矩阵中存储的是图的顶点
答案: 【图由顶点和边构成】

4、 问题:若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是
选项：
A:p = p->next; q->next = p; p->next = q; 
B:q->next = NULL; p = p->next; p->next = q; 
C:p = p->next; q->next = p->next; p->next = q;
D:p = (p).next; (q).next = (p).next; (p).next = q; 
答案: 【p = p->next; q->next = p; p->next = q; 】

5、 问题:以下程序执行后的输出结果是#include <stdio.h>

include <stdlib.h>

struct NODE
{
    int num;
    struct NODE *next;
};

int main( )
{ 
    struct NODE p,q,r;
    int sum=0;
    p=(struct NODE )malloc(sizeof(struct NODE));
    q=(struct NODE )malloc(sizeof(struct NODE));
    r=(struct NODE )malloc(sizeof(struct NODE));
    p->num=1;
    q->num=2;
    r->num=3;
    p->next=q;
    q->next=r;
    r->next=NULL;
    sum+=q->next->num;
    sum+=p->num;
    printf("%d",sum);
    return 0;
}
选项：
A:4
B:3
C:5
D:6
答案: 【4】

6、 问题:有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是struct node
{ 
    int data;
    struct node next;
}p, q, r;
选项：
A:r->next=q; q->next=r->next; p->next=r;
B:q->next=r->next; p->next=r; r->next=q;
C:p->next=r; q->next=r->next; r->next=q;
D:q->next=r->next; r->next=q; p->next=r;
答案: 【r->next=q; q->next=r->next; p->next=r;】

7、 问题:下面属于动态数据结构的是
选项：
A:链表
B:栈
C:结构体数组
D:指针数组
E:字符数组
答案: 【链表;
栈】

8、 问题:向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p, pr, head;则操作正确的是
选项：
A:p->next = pr->next;pr->next = p;
B:struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
C:pr->next = p;
D:p->next = pr->next;pr = p;
E:pr->next = p;p->next = pr->next;
答案: 【p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;】

9、 问题:已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p, pr, head;若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是
选项：
A:pr = head;
while(pr->next!=p) 
{
    pr = pr->next;
}
B:p = head;
pr = head;
while(pr->next!=p) 
{
   pr = pr->next;
}
C:pr = head;
while(pr!=p) 
{
   pr = pr->next;
}
D:p = head;
while(p->next!=pr)
{
   p = p->next;
}
答案: 【pr = head;
while(pr->next!=p) 
{
    pr = pr->next;
}】

10、 问题:下列叙述中正确的是
选项：
A:作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
B:对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
C:线性链表的长度是固定的，在访问之前就已经确定下来。
D:构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
E:线性链表的数据域一般只包含一个成员数据，如data。
F:作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。
答案: 【作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。;
对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。】

11、 问题:关于队列的说法正确的是
选项：
A:队列和栈都属于线性结构
B:队列存储在数组a中，队首为a[front],队尾为a[rear],则队列为空的条件是rear == front
C:一个队列的入队顺序是a,b,c,d,则出队顺序应该是d,c,b,a
D:队列具有先进后出的特点
答案: 【队列和栈都属于线性结构】

12、 问题:关于树的说法错误的是
选项：
A:树至少有一个结点
B:树必须有根结点
C:树是一种非线性结构
D:树的结点之间是一对多的关系
E:二叉树的左右子树不能交换
答案: 【树至少有一个结点;
树必须有根结点】

13、 问题:关于单向链表说法错误的是
选项：
A:单向链表在内存中是连续存储的
B:结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
C:存储空间可以动态的获取和释放
D:与数据相比，单向链表适合反复进行删除、插入操作
答案: 【单向链表在内存中是连续存储的】

第2周——数字间的那些事儿，做点计算哈 练兵区——单选题——不计入总分

1、 问题:设有语句“int a = 3;”，执行语句“a += a -= a * a;”后，变量a的值是
选项：
A:-12
B:3
C:0
D:9
答案: 【-12】

2、 问题:在C程序中如果要使用数学函数，如sin(x),log(x)等，需要在程序中加入的语句是
选项：
A:#include <math.h>
B:#include <stdio.h>
C:#define <math.h>
D:#define <stdio.h>
答案: 【#include <math.h>】

3、 问题:设有以下定义,则下面给出的语句中错误的是int a=0; 
float b=1.25;
char c=’A’;

define d 2

选项：
A:d++;
B:(a+b)++;
C:(-a)++;
D:(a+1)++;
E:a++;
F:b++;
G:c++;
答案: 【d++;;
(a+b)++;;
(-a)++;;
(a+1)++;】

4、 问题:下列关于单目运算符++、–的叙述中正确的是
选项：
A:a++的运算过程是：先使用变量a的值，然后再执行a=a+1。
B:++a的运算过程是：先使用变量a的值，然后再执行a=a+1。
C:a++的运算过程是：先执行a=a+1,然后再使用变量a的值。
D:a++和++a都是最终使变量a执行a=a+1,因此对于包含a++或++a的表达式而言(如j=a++;或者j=++a;)，两种情况下表达式的最终运算结果一定是相同的。
答案: 【a++的运算过程是：先使用变量a的值，然后再执行a=a+1。】

5、 问题:以下程序的输出结果是：#include <stdio.h>
int main() 
{ 
    int a=1, b=2; 
    a=a+b; 
    b=a-b; 
    a=a-b; 
    printf("%d,%d", a, b );  
    return 0;
}
选项：
A:2,1
B:3,1
C:3,2
D:1,2
答案: 【2,1】

6、 问题:下面哪条语句可以生成0-9之间的随机数
选项：
A:magic=rand()%10;
B:magic=rand()%10+1;
C:magic=rand()/10;
D:magic=rand()/10+1;
答案: 【magic=rand()%10;】

7、 问题:在下面的C语言语句中，存在错误的是
选项：
A:int a=b=10;
B:int a=10,b=10;
C:int a,b;a=b=10;
D:int a,b;a=10;b=10;
答案: 【int a=b=10;】

8、 问题:若有以下定义，则表达式“a * b + d – c”的值的类型为#include <stdio.h>
int main()
{
    char  a;
    int b;
    float  c;
    double d;
    ….
    return 0;
}
选项：
A:double
B:int
C:float
D:char
答案: 【double】

9、 问题:十进制3位数整数x,下面哪条语句能正确分离出它的十位上的数字d?
选项：
A:d=(x-(x/100)100)/10;
B:d=(x%100)/10;
C:d=(x/10)%10;
D:d=x%10;
E:d=(x-x%10)/10;
F:d=x%100;
答案: 【d=(x-(x/100)100)/10;;
d=(x%100)/10;;
d=(x/10)%10;】

10、 问题:在C语言中对下面的语句而言，哪个说法是错误的？int a, b;
选项：
A:变量a和b中的值都是0
B:变量a和b中都没有数值
C:变量a和b中的值都是未知的随机数
D:a和b都是整型变量
E:变量a和b占用的内存空间的大小是相同的
答案: 【变量a和b中的值都是0;
变量a和b中都没有数值】

11、 问题:下列程序的输出结果是#include <stdio.h>
int main()
{ 
   int a=7,b=5;   
   printf("%d",b/a);
   return 0;   
}
选项：
A:0
B:5
C:1
D:0.7
答案: 【0】

12、 问题:程序运行后的输出结果是#include <stdio.h>
int main()
{ 
    int m=3,n=4,x;
    x=m++;
    ++n;
    x=x+8/n;
    printf("%d,%d",x,m);
    return 0;
}
选项：
A:4,4
B:4,3
C:5,4
D:5,3
答案: 【4,4】

13、 问题:下面程序的运行结果是#include  <stdio.h>
int main()
{
    int    a = 2, b = 3 ;
    float  x = 3.5, y = 2.5 ;
    printf("%f", (float)(a+b) / 2 + (int)x % (int)y) ;
    return 0;
}
选项：
A:3.500000
B:3.000000
C:3.5
D:3
答案: 【3.500000】

14、 问题:以下非法的赋值语句是
选项：
A:++(i+1);
B:x=(j–);
C:n=++i;
D:j++;
答案: 【++(i+1);】

15、 问题:已知int a,b;并且有a=5%3;以及b=5/3;，则a和b的值分别是
选项：
A:2和1
B:0和1.67
C:3和1
D:5和1
E:0和1
F:3和1.67
G:5和1.67
答案: 【2和1】

16、 问题:设a和b均为double型变量，且a=5.5、b=2.5，则表达式（int）a+b/b的值是
选项：
A:6.000000
B: 6.500000
C:6
D:5.500000  
答案: 【6.000000】

17、 问题:以下程序的运行结果是#include <stdio.h>
int main() 
{ 
    int  a = 12, b = 3; 
    float  x = 18.5, y = 4.5; 
    printf("%f", (float)(a * b) / 2); 
    printf("%d", (int)x %(int)y); 
    return 0;
}
选项：
A:18.0000002
B:182
C:182.000000
D:18.0000002.000000
答案: 【18.0000002】

18、 问题:在C语言中，要求操作数必须是整型的运算符是
选项：
A:%
B:/
C:*
D:+
E:-
答案: 【%】

19、 问题:程序运行后的输出结果是#include <stdio.h>
int main()
{ 
    char a=’a’;
    printf("%c,",++a);
    printf("%c",a++);
    return 0;
}
选项：
A:b,b
B:b,c
C:a,b
D:a,c
答案: 【b,b】

20、 问题:若以下选项中的变量已正确定义，则正确的赋值语句是
选项：
A:x3=x2=x1=0； 
B:x1=26.8%3；
C:1+2=x2； 
D:x4=1+2=3；
答案: 【x3=x2=x1=0； 】

第1周——初识C语言从认识变量和常量开始 第1周测验

1、 问题:下列选项中，合法的C语言标识符是
选项：
A:_a1
B:width.x
C:#abc123 
D:123abc
E:o*k
F:a?
G:a+b
H:%a
I:b!
答案: 【_a1】

2、 问题:以下不适合定义为用户标识符的是
选项：
A:int 
B:a2
C:def2
D:3com
E:PI 
F:Source
G:abc
答案: 【int 】

3、 问题:#include <stdio.h>是
选项：
A:编译预处理指令
B:语句
C:函数
D:什么都不是
E:有语法错误
答案: 【编译预处理指令】

4、 问题:在windows下,程序编译链接后形成的可执行文件是
选项：
A:.obj文件
B:.exe文件
C:.o文件
D:.c文件
E:.h文件
答案: 【.exe文件】

5、 问题:程序编译链接后显示" 0 error,0 warning" 代表
选项：
A:程序中没有语法错误
B:程序是正确的
C:程序是不正确的
D:程序中可能存在语法错误
E:程序中有语义错误
答案: 【程序中没有语法错误】

6、 问题:用8位无符号二进制数能表示的最大十进制数为
选项：
A:255
B:127
C:128
D:256
答案: 【255】

7、 问题:关于可执行文件说法正确的是
选项：
A:可执行文件是编译链接后生成的文件
B:可执行文件就是源代码文件
C:可执行文件后缀为.obj
D:可执行文件就是main.c文件
答案: 【可执行文件是编译链接后生成的文件】

8、 问题:若变量a是int类型，并执行了语句：a=’A’+1.6；，则正确的叙述是
选项：
A:’A’+1.6的结果是浮点型
B:a的值还是整型
C:a的值是字符C
D:a的值是浮点型
E:不允许字符型和浮点型相加
答案: 【‘A’+1.6的结果是浮点型;
a的值还是整型】

9、 问题:Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）
选项：
A:运算符
B:一元运算符
C:只需要一个操作数的运算符
D:函数
E:语句
F:标识符
G:变量
答案: 【运算符;
一元运算符;
只需要一个操作数的运算符】

10、 问题:以下不属于Codeblocks中用于调试程序的工具是
选项：
A:run
B:build
C:run to cursor
D:next line
E:stop debugger
F:watches
答案: 【run;
build】

11、 问题:程序的开发步骤中不包括
选项：
A:撰写文档
B:运行程序
C:编译链接
D:程序测试
E:编辑（编写代码）
答案: 【撰写文档】

12、 问题:下列说法中错误的是（）
选项：
A:尾数决定了实数的表数范围，阶码决定了实数的表数精度。
B:内存是按位编址的。
C:有符号和无符号整数的表数范围是相同的。
D:int型在所有的计算机上都占4个字节的存储单元。
E:编译器按变量定义的类型对不同类型的变量分配不同大小的内存空间。
F:内存是按字节编址的。
G:对于同样的尾数，阶码的值越大，则浮点数所表示的数值的绝对值就越大。
H:sizeof是编译时执行的运算符，不会导致额外的运行时间开销。
答案: 【尾数决定了实数的表数范围，阶码决定了实数的表数精度。;
内存是按位编址的。;
有符号和无符号整数的表数范围是相同的。;
int型在所有的计算机上都占4个字节的存储单元。】

13、 问题:若有定义：int a=8，b=5，c; ，执行语句c=a/b+0.4;后，c的值为
选项：
A:1
B:1.4
C:2.0
D:2
答案: 【1】

14、 问题:在C语言中，字符型数据在内存中以字符的（  ）形式存放
选项：
A:ASCII码
B:国标码
C:BCD码
D:反码 
答案: 【ASCII码】

15、 问题:以下符合C语言语法的实型常量是
选项：
A:5e-3
B:3.14.159e
C:1.2e0.5
D:e15
答案: 【5e-3】

16、 问题:以下选项中可作为C语言合法整数的是
选项：
A:0xffa
B:10110B       
C:038x
D:x2a2
答案: 【0xffa】

17、 问题:下列说法正确的是
选项：
A:在C语言中，变量必须先定义后使用。
B:一条变量定义语句可定义多个同类型的变量。
C:C89规定所有变量必须在第一条可执行语句前定义。
D:const常量只能在定义时赋值。
E:实型常量的默认类型是double类型。
F:一条变量定义语句不可以同时定义多个变量。
G:不同类型的变量分配的存储空间大小都是相同的。
H:在C语言中，所有变量都必须在定义时进行初始化。
I:变量在没有初始化的时候，其值都是0
J:宏常量有数据类型，编译器在宏替换时可以进行类型检查。
答案: 【在C语言中，变量必须先定义后使用。;
一条变量定义语句可定义多个同类型的变量。;
C89规定所有变量必须在第一条可执行语句前定义。;
const常量只能在定义时赋值。;
实型常量的默认类型是double类型。】

18、 问题:下列变量定义中合法的是
选项：
A:long ao=0xfdaL；
B:short _a=1-.1e-1；
C:double b=1+5e2.5；
D:float 2_and=1-e-3；
答案: 【long ao=0xfdaL；】

第14周——结构设计的艺术 第14周测验

1、 问题:关于图的说法正确的是
选项：
A:图由顶点和边构成
B:图的邻接表属于顺序存储方式
C:图的邻接表属于链式存储方式
D:图的邻接矩阵中存储的是图的顶点
答案: 【图由顶点和边构成】

2、 问题:已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p, pr, head;若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是
选项：
A:pr = head;
while(pr->next!=p) 
{
    pr = pr->next;
}
B:p = head;
pr = head;
while(pr->next!=p) 
{
   pr = pr->next;
}
C:pr = head;
while(pr!=p) 
{
   pr = pr->next;
}
D:p = head;
while(p->next!=pr)
{
   p = p->next;
}
答案: 【pr = head;
while(pr->next!=p) 
{
    pr = pr->next;
}】

3、 问题:关于队列的说法正确的是
选项：
A:队列和栈都属于线性结构
B:队列存储在数组a中，队首为a[front],队尾为a[rear],则队列为空的条件是rear == front
C:一个队列的入队顺序是a,b,c,d,则出队顺序应该是d,c,b,a
D:队列具有先进后出的特点
答案: 【队列和栈都属于线性结构】

4、 问题:若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是
选项：
A:p = p->next; q->next = p; p->next = q; 
B:q->next = NULL; p = p->next; p->next = q; 
C:p = p->next; q->next = p->next; p->next = q;
D:p = (p).next; (q).next = (p).next; (p).next = q; 
答案: 【p = p->next; q->next = p; p->next = q; 】

5、 问题:下列叙述中正确的是
选项：
A:作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
B:对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
C:线性链表的长度是固定的，在访问之前就已经确定下来。
D:构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
E:线性链表的数据域一般只包含一个成员数据，如data。
F:作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。
答案: 【作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。;
对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。】

6、 问题:下面属于动态数据结构的是
选项：
A:链表
B:栈
C:结构体数组
D:指针数组
E:字符数组
答案: 【链表;
栈】

7、 问题:关于树的说法错误的是
选项：
A:树至少有一个结点
B:树必须有根结点
C:树是一种非线性结构
D:树的结点之间是一对多的关系
E:二叉树的左右子树不能交换
答案: 【树至少有一个结点;
树必须有根结点】

8、 问题:以下程序执行后的输出结果是#include <stdio.h>

include <stdlib.h>

struct NODE
{
    int num;
    struct NODE *next;
};

int main( )
{ 
    struct NODE p,q,r;
    int sum=0;
    p=(struct NODE )malloc(sizeof(struct NODE));
    q=(struct NODE )malloc(sizeof(struct NODE));
    r=(struct NODE )malloc(sizeof(struct NODE));
    p->num=1;
    q->num=2;
    r->num=3;
    p->next=q;
    q->next=r;
    r->next=NULL;
    sum+=q->next->num;
    sum+=p->num;
    printf("%d",sum);
    return 0;
}
选项：
A:4
B:3
C:5
D:6
答案: 【4】

9、 问题:向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p, pr, head;则操作正确的是
选项：
A:p->next = pr->next;pr->next = p;
B:struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
C:pr->next = p;
D:p->next = pr->next;pr = p;
E:pr->next = p;p->next = pr->next;
答案: 【p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;】

10、 问题:关于单向链表说法错误的是
选项：
A:单向链表在内存中是连续存储的
B:结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
C:存储空间可以动态的获取和释放
D:与数据相比，单向链表适合反复进行删除、插入操作
答案: 【单向链表在内存中是连续存储的】

11、 问题:已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p，*q;则下面语句序列的功能是while(p->next->next != NULL)
{
  p = p->next;
}
free(p->next);
p->next = NULL;
选项：
A:删除链表的尾结点
B:删除p结点
C:删除结点q
D:删除p的前驱结点
答案: 【删除链表的尾结点】

12、 问题:有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是struct node
{ 
    int data;
    struct node next;
}p, q, r;
选项：
A:r->next=q; q->next=r->next; p->next=r;
B:q->next=r->next; p->next=r; r->next=q;
C:p->next=r; q->next=r->next; r->next=q;
D:q->next=r->next; r->next=q; p->next=r;
答案: 【r->next=q; q->next=r->next; p->next=r;】

13、 问题:已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：struct node{     int data;    struct node next;}p;若要删除头结点，则下面正确的语句序列是
选项：
A:p = head;head = p->next;free(p);
B:head = head->next;free(head);
C:p = head->next;free(p);
D:head = head->next;p = head;free(p);
答案: 【p = head;head = p->next;free(p);】

第3周——从键盘中来，到键盘中去，开始输入和输出啦 第3周测验

1、 问题:分析下列程序，写出程序运行结果#include <stdio.h>
int main()
{ 
    char c1 = ‘a’, c2 = ‘b’, c3 = ‘c’;
    printf("a%cb%cc%cabc", c1, c2, c3);
    return 0;
}
选项：
A:aabbccabc
B:acbcabc
C:aabcabc
D:acbbcabc
答案: 【aabbccabc】

2、 问题:有如下语句,为使变量a的值为1，b的值为2，从键盘输入数据的正确形式是scanf("a=%d,b=%d",&a,&b);
选项：
A:a=1,b=2
B:1 2
C:1,2
D:a=1 b=2
答案: 【a=1,b=2】

3、 问题:#include <stdio.h>
int main()
{ 
    int a,b,c,d;
    scanf("%c%c%d,%d",&a,&b,&c,&d);
    printf("%c,%c,%c,%c",a,b,c,d);
    return 0;
}若运行以上程序时从键盘上输入：6565,66<回车>。则输出结果是
选项：
A:6,5,A,B
B:6,5,65,66
C:6,5,6,5
D:6,5,6,6
答案: 【6,5,A,B】

4、 问题:给出程序的运行结果,程序运行时从键盘输入：54321<回车>#include <stdio.h>
int main()
{  
    int a,b,s;
    scanf("%2d%2d",&a,&b);
    s=a/b;
    printf("s=%d",s);
    return 0;
}
选项：
A:1
B:1.6875
C:2
D:0
答案: 【1】

5、 问题:以下程序的输出结果为#include <stdio.h> 
int main() 
{ 
   float a = 1234.567,b = 55.32; 
   printf("a = %4.2f, b = %5.1f", a,b); 
   return 0;
 }
选项：
A:a = 1234.57, b = 55.3
B:a =1234, b =55
C:a = 1234.6, b = 5.32
D:a =1234.567, b = 55.32
答案: 【a = 1234.57, b = 55.3】

6、 问题:以下程序的输出结果为#include <stdio.h>
int main()
{
      int a=2, c=5;
      printf("a = %%d, b = %%d", a, c);
      return 0;
}
选项：
A:a = %d, b = %d
B:a = %2, b = %5
C:a = 2, b = 5
D:a = %%d, b = %%d
答案: 【a = %d, b = %d】

7、 问题:有以下程序，运行时若输入为B，则输出是#include <stdio.h>
int main()
 { 
     char ch;
     ch=getchar();
     ch=ch+32;
     printf("%c",ch);
     return 0;
}
选项：
A:b
B:98
C:32
D:66
答案: 【b】

8、 问题:在调用printf函数输出数据时，当数据的实际位宽小于printf函数中的指定位宽时，下面叙述正确的是
选项：
A:如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。
B:如果格式字符前面没有负号，那么输出的数据将会左对齐、右补空格；如果格式字符前面有负号，那么输出的数据将会右对齐、左补空格。
C:如果格式字符前面没有负号，那么输出的数据将会右对齐、左补0；如果格式字符前面有负号，那么输出的数据将会左对齐、右补0。
D:如果格式字符前面没有负号，那么输出的数据将会左对齐、右补0；如果格式字符前面有负号，那么输出的数据将会右对齐、左补0。
答案: 【如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。】

9、 问题:设有语句“char c=’\72′;”，则变量c
选项：
A:包含1个字符
B:包含2个字符
C:包含3个字符
D:不合法
答案: 【包含1个字符】

10、 问题:在下列语句中存在错误的是
选项：
A:int a,b;scanf("%d %f",&a,&b);
B:int a,b;scanf("%d %d",a,b);
C:int a,b;scanf("%d%d",&a,&b);printf("%d %d",a,b);
D:float a,b;scanf("%3.2f %4.2f",&a,&b);printf("%f %f",a,b);
E:float a,b;scanf("%f %f",&a,&b);printf("%f %f",a,b);
F:float a,b;scanf("%f %f",&a,&b);printf("a=%4.3f,b=%4.3f",a,b);
G:int a,b;scanf("%2d%2d",&a,&b);printf("a=%d,b=%d",a,b);
H:int a,b;scanf("%d,%d",&a,&b);printf("a=%2d,b=%2d",a,b);
I:int a,b;scanf("a=%d,b=%d",&a,&b);printf("a=%d,b=%d",a,b);
答案: 【int a,b;scanf("%d %f",&a,&b);;
int a,b;scanf("%d %d",a,b);;
int a,b;scanf("%d%d",&a,&b);printf("%d %d",a,b);;
float a,b;scanf("%3.2f %4.2f",&a,&b);printf("%f %f",a,b);】

11、 问题:程序运行后的输出结果是#include <stdio.h>
int main()
{ 
    int a=666,b=888;
    printf("%d",a,b);
    return 0;
}
选项：
A:666
B:错误信息 
C:888  
D:666,888
答案: 【666】

12、 问题:有以下语句段#include <stdio.h>
int main()
{
    int n1=10,n2=20;
    printf("___",n1,n2);
    return 0;
}要求按以下格式输出n1和n2的值，每个输出行都是从第一列开始，则空白处代码填写正确的是运行结果示例如下：n1=10n2=20
选项：
A:n1=%dn2=%d
B:n1=%dn2=%d
C:n1=%d,n2=%d
D:n1=%d n2=%d
答案: 【n1=%dn2=%d】

13、 问题:以下选项中合法的字符常量是
选项：
A: ‘\010’
B:"B"
C:68
D:D
答案: 【 ‘\010’】

14、 问题:写出下面程序的输出结果#include<stdio.h>
int main()
  {
     int x=6,y,z;
     x*=18+1;
     printf("%d,",x–);
     x+=y=z=11;
     printf("%d",x);
     return 0;
}
选项：
A:114,124
B:113,124
C:109,116
D:110,116
答案: 【114,124】

15、 问题:给出程序的运行结果,程序运行时从键盘输入：45-12<回车>#include <stdio.h>
int main()
{  
    int a,b,sum;
    scanf("%d%*c%d",&a,&b);
    sum=a+b;
    printf("sum=%d",sum);
    return 0;
}
选项：
A:57
B:输出报错
C:33
D:输出一个随机数
答案: 【57】

16、 问题:给出程序的运行结果#include <stdio.h>
int main()
{  
    int a,b,s;
    char op;
    scanf("%d %c%d",&a,&op,&b);
    s=a%b;
    printf("s=%d",s);
    return 0;
}程序运行时从键盘输入：15<回车>%5<回车>
选项：
A:0
B:程序报错
C:输出一个随机数
D:3
答案: 【0】

17、 问题:给出程序的运行结果#include <stdio.h>
int main()
{
  int a,b,c,d;
  char op1,op2,op3;
  int sum;
  printf("please input:a+b+c+d");
  scanf("%d%c%d%c%d%c%d",&a,&op1,&b,&op2,&c,&op3,&d);
  sum=a+b+c+d;
  printf("sum=%d",sum);
  return 0;
}程序运行时从键盘输入:1<回车>2+3+1<回车>
选项：
A:7
B:1
C:3
D:6
答案: 【7】

18、 问题:在C语言中，字符型数据在内存中以（  ）形式存放
选项：
A:ASCII码
B:国标码
C:BCD码
D:反码
答案: 【ASCII码】

19、 问题:以下程序的执行结果是#include  <stdio.h> 
int main() 
{ 
   int  a = 5, b = 4, x, y; 
   x = 2  a++;
   y = –b  2; 
   printf("a=%d, x=%d", a, x); 
   printf("b=%d, y=%d", b, y); 
   return 0;
}
选项：
A:a=6,  x=10b=3,  y=6
B:a=6,  x=10b=3,  y=8
C:a=6,  x=12b=3,  y=6
D:以上均不对
答案: 【a=6,  x=10b=3,  y=6】

20、 问题:以下程序运行后的输出结果是#include <stdio.h>
int main()
{ 
    int a; 
    int c=10;
    float f=100.0; 
    double x;
    a=f/=c*=(x=6.5);
    printf("%d,%d,%3.1f,%3.1f",a,c,f,x);
    return 0;
}
选项：
A:1,65,1.5,6.5
B:1,65,1,6.5
C:1,65,1.0,6.5
D: 2,65,1.5,6.5
答案: 【1,65,1.5,6.5】

21、 问题:给出程序的运行结果#include <stdio.h>
int main()
{
  char a,b;
  int s;
  printf("please input a and b:");
  a=getchar();
  b=getchar();
  s=a+b;
  printf("a=%c,b=%c",a,b);
  return 0;
}程序运行时从键盘输入:1<空格>2<回车>
选项：
A:a=1,b=
B:a=1,b=2
C:a= ,b=2
D:输出乱码
答案: 【a=1,b=】

22、 问题:以下程序的输出结果是#include <stdio.h>
int main()
{
    int a=1234;
    printf("%2d",a);
    return 0;
}
选项：
A:1234
B:12
C:34
D:提示出错、无结果
答案: 【1234】

第5周——周而复始的循环之道 练兵区——单选题——不计入总分

1、 问题:程序运行后的输出结果是#include <stdio.h>
int main()
{ 
        int i;
  
        for(i=0;i<3;i++)   
        
            switch(i)    
                   
                {       
     
                    case 0: printf("%d",i);
         
                    case 2: printf("%d",i);
         
                    default: printf("%d",i);       
    
                } 
    
        return 0; 
 
}
选项：
A:000122
B:022111
C:021021
D:012
答案: 【000122】

2、 问题:若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是
选项：
A:for( i=1; i<=5; i++ ){    p=1;    p=i;}
B:for(i=1,p=1;i<=5;i++) 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 );
答案: 【for( i=1; i<=5; i++ ){    p=1;    p*=i;}】

3、 问题:下面程序的输出是#include <stdio.h>
int main()
{ 
    int y=9;
    for( ; y>0; y–)
        {   
            if(y%3==0)
                { 
                    printf("%d", –y);
                    continue;
                }
        }
    return 0;
}
选项：
A:852
B:741
C:963
D:875421 
答案: 【852】

4、 问题:爱因斯坦数学题。爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶，最后才正好1阶不剩。请问，这条阶梯共有多少阶？代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
    int  x = 1, find = 0;
    while (_)
    {
        if (_______)
        {
                printf("x = %d", x);
                find = 1;   
        }
        x++;
    }
    
    return 0;
}
选项：
A:第5行：     !find第7行：     x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
B:第5行：      find==1第7行：      x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
C:第5行：      find!=1第7行：      x/2==1 && x/3==2 && x/5==4 && x/6==5 && x/7==0
D:第5行：      find!=0第7行：      x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
答案: 【第5行：     !find第7行：     x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0】

5、 问题:鸡兔同笼，共有98个头，386只脚，编程求鸡、兔各多少只。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
    int x, y;
    for (x=1; _; x++)
    {
        __;
        if (____)
        {
                printf("x = %d, y = %d", x, y);
        }
    }
    
    return 0;
}
选项：
A:第5行：     x<=97第7行：     y = 98 – x第8行：     2x+4y == 386
B:第5行：     x<97第7行：     x = 98 – y第8行：     2x+4y == 386
C:第5行：     x<97第7行：     y = 98 – x第8行：     2x+4y == 386
D:第5行：     x<=97第7行：     x = 98 – y第8行：     2x+4y <= 386
答案: 【第5行：     x<=97第7行：     y = 98 – x第8行：     2x+4y == 386】

6、 问题:以下正确的描述是
选项：
A:只能在循环体内和switch语句体内使用break语句
B: continue语句的作用是结束整个循环的执行
C:在循环体内使用break语句或continue语句的作用相同  
D:continue语句可以写在循环体之外
答案: 【只能在循环体内和switch语句体内使用break语句】

7、 问题:华氏和摄氏温度的转换公式为C=5/9×（F-32）。式中，C表示摄氏温度，F表示华氏温度。要求：华氏0℉～300℉，每隔20℉输出一个华氏温度对应的摄氏温度值。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
    int    upper = 300, step = 20;
    float  fahr = 0, celsius;
    while (fahr < upper)
    {
        __;
        printf("%4.0f\t%6.1f", fahr, celsius);
         _______ ;
    }
    return 0;
}
选项：
A:第8行代码： celsius = 5.0 / 9 * (fahr – 32)第10行代码： fahr = fahr + step
B:第8行代码：  celsius = 5 / 9 * (fahr – 32)第10行代码：  fahr = fahr + step
C:第8行代码：  celsius = 5.0 / (9 * (fahr – 32))第10行代码： fahr = fahr + step
D:第8行代码：  celsius = 5.0 / 9 * (fahr – 32)第10行代码： fahr = fahr – step
答案: 【第8行代码： celsius = 5.0 / 9 * (fahr – 32)第10行代码： fahr = fahr + step】

8、 问题:利用泰勒级数：计算e的近似值，当最后一项的绝对值小于时认为达到了精度要求，要求统计总共累加了多少项。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <math.h>

include <stdio.h>

int main()
{   
    int n = 1, count = 1;
    ____;
    double term = 1.0;
    while (fabs(term) >= 1e-5) //判末项大小
    {
            __;   //求出累加项
            e = e + term;     //累加
            n++;               // 计算下一项
            ___;   //统计累加项数
    }
 
    
       printf("e = %f, count = %d", e, count);
    return 0;
}
选项：
A:第6行代码：      double e = 1.0第10行代码：     term = term / n第13行代码：     count++
B:第6行代码：   double e = 0第10行代码：  term = term / n第13行代码：  count++
C:第6行代码：  double e = 1.0第10行代码： term = term n第13行代码： count++
D:第6行代码：  double e = 0第10行代码： term = term n第13行代码： count++
答案: 【第6行代码：      double e = 1.0第10行代码：     term = term / n第13行代码：     count++】

9、 问题:打印所有的“水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如，153是“水仙花数”，因为代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
    int i, j, k, n;
    printf("result is:");
    for (n=100; _; n++)
    {
        i = n / 100;            //分离出百位
        j = __;       //分离出十位
        k = _;       //分离出个位  
        if (___)
        {
                printf("%d\t ",n);  //输出结果
        }
    }
    printf("");
    return 0;
}
选项：
A:第6行： n<1000第9行： (n – i * 100) / 10第10行：n % 10第11行：i100+j10+k == iii+jjj+kkk
B:第6行： n<1000第9行： (n – i * 100) / 10第10行：n % 10第11行：i100+j10+k = iii+jjj+kkk
C:第6行： n<=1000第9行： n % 100第10行：n % 10第11行：i100+j10+k == iii+jjj+kkk
D:第6行： n<1000第9行： (n – i * 100) / 10第10行：n /10第11行：i100+j10+k == iii+jjj+kkk
答案: 【第6行： n<1000第9行： (n – i * 100) / 10第10行：n % 10第11行：i100+j10+k == iii+jjj+kkk】

10、 问题:以下程序执行后的输出结果是#include <stdio.h>
int main( )
{ 
    int i,n=0;
    for(i=2;i<5;i++)
      { 
        do 
        { 
           if(i%3) continue;
           n++;
        }while(!i);
       n++;
     }
   printf("n=%d",n);
   return 0;
}
选项：
A:n=4
B:n=5
C:n=2
D:n=3
答案: 【n=4】

11、 问题:以下程序运行后的输出结果是#include <stdio.h>
int main()
 {     
    int i=0,s=0;
    for (;;)
    { 
        if(i==3||i==5) continue;
        if (i==6) break;
        i++;
        s+=i;
    }
    printf("%d",s);
    return 0;
 }
选项：
A:程序进入死循环
B:10
C:13
D:21
答案: 【程序进入死循环】

12、 问题:程序执行后的输出结果是#include <stdio.h>
int main( )
{
     int i,s=0;
     for(i=1;i<10;i+=2)
     {
        s+=i+1;
     }
     printf("%d",s);
     return 0;
}
选项：
A:自然数1～10中的偶数之和
B:自然数1～9的累加和
C:自然数1～10的累加和
D:自然数1～9中的奇数之和
答案: 【自然数1～10中的偶数之和】

13、 问题:以下程序运行时，从键盘输入：01<回车>，程序执行后的输出结果是#include <stdio.h>
int main( )
{ 
    char k; 
    int i;
    for(i=1;i<3;i++)
    { 
        scanf("%c",&k);
        switch(k)
        { 
            case ‘0’: printf("another");
            case ‘1’: printf("number");
        }
   }
   return 0;
}
选项：
A:anothernumbernumber
B:numbernumber
C:anothernumber
D:anothernumberanother
答案: 【anothernumbernumber】