本答案对应课程为:点我自动跳转查看
本课程起止时间为:2020-03-11到2020-08-31
本篇答案更新状态:已完结

第1周——海陆空齐上阵：又来了一堆数据 第1周测验

1、 问题:设有以下说明语句,则下面的叙述中错误的是struct ex
{ 
    int x ; 
    float y; 
    char z ;
 } example;
选项：
A:example是结构体类型名
B:struct是结构体类型的关键字
C:x,y,z都是结构体成员名
D:ex为结构体标签。
答案: 【example是结构体类型名】

2、 问题:若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。struct 
{   
    short a;
    float b;
} v1;union 
{   
    short a;
    float b;
} v2;
选项：
A:执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
B:执行sizeof(v1)获得的结果是6个字节，只能对结构体变量v1中的第一个成员进行初始化。
C:执行sizeof(v2)获得的结果是6个字节，只能对共用体变量v2中的第一个成员进行初始化。
D:执行sizeof(v2)获得的结果是4个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
E:执行sizeof(v2)获得的结果是8个字节，只能对共用体变量v2中的第一个成员进行初始化
F:执行sizeof(v1)获得的结果是8个字节，只能对结构体变量v1中的第一个成员进行初始化。
G:执行sizeof(v1)获得的结果是4个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
H:执行sizeof(v2)获得的结果是6个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
答案: 【执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。】

3、 问题:以下正确的描述是
选项：
A:结构体和共用体变量都不能进行比较操作。
B:两个结构体变量可以比较，但不能将结构体类型作为函数返回值类型。 
C:既可以对两个共用体变量进行比较操作，也可以将共用体变量作为函数参数。 
D:关键字typedef用于定义一种新的数据类型。
E:结构体和共用体变量都能进行比较操作。
F:枚举类型和结构体、共用体一样，也是一种构造数据类型。
G:不同结构体类型的成员名不能相同。
H:和数组一样，即使是相同类型的结构体变量也不能整体赋值，只能逐个成员进行赋值。
答案: 【结构体和共用体变量都不能进行比较操作。】

4、 问题:以下选项中不能正确把cl定义成结构体变量的是
选项：
A:struct color cl
{ 
    int red;
    int green;
    int blue;
}
B:typedef struct
{ 
    int red;
    int green;
    int blue;
} COLOR;
COLOR cl;
C:struct color 
{ 
    int red;
    int green;
    int blue;
} cl;
D:struct
{ 
    int red;
    int green;
    int blue;
} cl;
答案: 【struct color cl
{ 
    int red;
    int green;
    int blue;
}】

5、 问题:以下程序执行后的输出结果是#include <stdio.h>
struct STU
{
    char name[10];
    int num;
};

void Fun1(struct STU c)
{
    struct STU b={"LiGuo",2042};
    c=b;
};

void Fun2(struct STU c)
{
    struct STU b={"SunDan",2044};
    c=b;
};

int main()
{
    struct STU a={"YangHan",2041},b={"WangYi",2043};
    Fun1(a);
    Fun2(&b);
    printf("%d %d",a.num,b.num);
    return 0;
}
选项：
A:2041 2044
B:2041 2043 
C:2042 2044 
D:2042 2043
答案: 【2041 2044】

6、 问题:下面说法错误的是
选项：
A:在一个结构体内不能包含另一个不同类型的结构体作为其成员。
B:用结构体变量做函数参数，是将结构体变量的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
C:结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
D:和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
E:用指向结构体变量的指针做函数参数，是将结构体变量的地址传给被调函数，因此在被调函数中对结构体内容的修改会影响原结构体变量。
答案: 【在一个结构体内不能包含另一个不同类型的结构体作为其成员。】

7、 问题:若能使程序运行后的输出结果如下：201501201502201503则空白处填写的表达式或语句应该是#include <stdio.h>
struct student
 { 
     int age;
     char num[8];
  };
  
int main()
{
    struct student stu[3]={{20,"201501"},{21,"201502"},{19,"201503"}};
    struct student p=stu;
   
    ________
    
    return 0;
}
选项：
A:    printf("%s",(p).num);    printf("%s",(++p)->num);    printf("%s",stu[2].num);
B:    printf("%s",(p++).num);    printf("%s",(p++).num);    printf("%s",(p++).num);
C:    printf("%s",(++p)->num);    printf("%s",(++p)->num);    printf("%s",(p).num);
D:    printf("%s",stu[0]->num);    printf("%s",stu[1]->num);    printf("%s",stu[2]->num);
答案: 【    printf("%s",(p).num);    printf("%s",(++p)->num);    printf("%s",stu[2].num);】

8、 问题:以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <stdio.h>
typedef struct clock
{
int hour;
int minute;
int second;
}CLOCK;

/ 函数功能：时、分、秒时间的更新 /
void Update(_)                 
{
static long m = 1;   
t->hour = m / 3600;   
t->minute = ___;   
t->second = _;   
m++;   
if (t->hour == 24)  m = 1;   
}

/ 函数功能：时、分、秒时间的显示 /
void Display(CLOCK *t)                     
{
    printf("%2d:%2d:%2d\r", t->hour, t->minute, t->second);
}

/ 函数功能：模拟延迟1秒的时间 /
void Delay(void)                     
{
long t;
for (t=0; t<50000000; t++)
        {
/ 循环体为空语句的循环，起延时作用 /
        }
}

int main()
{
long i;
CLOCK myclock;
myclock.hour = myclock.minute = myclock.second = 0;   
for (i=0; i<100000; i++)   / 利用循环，控制时钟运行的时间 /
{ 
Update(&myclock);           / 时钟值更新 /
Display(____);           / 时间显示 /
Delay();                      / 模拟延时1秒 /
}    
        return 0;
}
选项：
A:第10行：  CLOCK t第14行：  (m – 3600 * t->hour) / 60第15行：  m % 60第44行：  &myclock
B:第10行：  CLOCK t第14行：  (m – 3600 * hour) / 60第15行：  m / 60第44行：  &myclock
C:第10行：  CLOCK t第14行：  (m – 3600 * t->hour) / 60第15行：  m / 60第44行：  myclock
D:第10行：  CLOCK t第14行：  (m – 3600 * hour) / 60第15行：  m % 60第44行：  myclock
答案: 【第10行：  CLOCK *t第14行：  (m – 3600 * t->hour) / 60第15行：  m % 60第44行：  &myclock】

9、 问题:有以下说明和定义语句，下面各输入语句中错误的是#include <stdio.h>
int main()
{
    struct student
    {
         int age;
         char sex;
         char name[8];
    };
    
    struct student std;
    struct student p=&std;
    …….
    return 0;
}
选项：
A:scanf("%c",&std[0].sex); 
B:scanf("%d",&(p).age); 
C:scanf("%s",std.name);
D:scanf("%c",&(p->sex));
答案: 【scanf("%c",&std[0].sex); 】

10、 问题:以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
struct stu
{ 
    char num[10]; 
    float score[3];
};

int main()
{
    struct stu s[3]={{"20021",90,95,85},{"20022",95,80,75},{"20023",100,95,90}},*p=s;
    int i,j; 
    float sum;
    
    ____
    
    return 0;
}
选项：
A:       for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }        
        printf("%6.2f",sum);
        p++;
    }
B:               sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }
        printf("%6.2f",sum);
C:                 sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
            p++;
        }        
        printf("%6.2f",sum);
D:       for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
            p++;
        }        
        printf("%6.2f",sum);      
    }
答案: 【       for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }        
        printf("%6.2f",sum);
        p++;
    }】

11、 问题:某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是
选项：
A: struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;
 
 s.birth.year = 1984;
 s.birth.month = 11;
 s.birth.day = 11;
B:struct student
{   
    int number;
    char name[20];
    char sex;
    int year;
    int month;
    int day;
} s;
 
 year = 1984;
 month = 11;
 day = 11;
C: struct student
{   
    int number;
    char name[20];
    char sex;
} s;

struct
{   
    int year;
    int month;
    int day;
} birth;

birth.year = 1984;
birth.month = 11;
birth.day = 11;
D: struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;

s.year = 1984;
s.month = 11; 
s.day = 11;
答案: 【 struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;
 
 s.birth.year = 1984;
 s.birth.month = 11;
 s.birth.day = 11;】

12、 问题:下面程序的输出结果是#include <stdio.h>
int main()
{  
    union
    { 
        int i[2];
        int k;
        int c;
    }t,*s = &t;
    
    s->i[0] = 10;
    s->i[1] = 20;
    s->k=30;
    printf("%d", s->k);    
    printf("%d", s->i[0]); 
    printf("%d", s->c);   
    return 0;
}
选项：
A:303030
B:102030
C:3010随机数
D:301020
答案: 【303030】

13、 问题:设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。
选项：
A:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                 / 定义职业结构体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                        / 姓名 /
    char sex;                             / 性别 /
    struct date birthday;                 / 出生日期 /
    struct professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}
B:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                   / 定义职业结构体类型 /
{
    char college[80];                      / 所在学院/
    char professionalTitle[20];            / 职称 /
    char duty[20];                         / 职务 /
};
int main()
{
    char name[20];                         / 姓名 /
    char sex;                              / 性别 /
    struct date birthday;                  / 出生日期 /
    struct professionalState occupation;   / 职业状况 /
    ……
    return 0;
}
C:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
int main()
{
    char name[20];                   / 姓名 /
    char sex;                        / 性别 /
    struct date birthday;            / 出生日期 /
    char college[80];                / 所在学院/
    char professionalTitle[20];      / 职称 /
    char duty[20];                   / 职务 /
    ……
    return 0;
}
D:#include <stdio.h>
int main()
{
    char name[20];                   / 姓名 /
    char sex;                        / 性别 /
    char college[80];                / 所在学院/
    char professionalTitle[20];      / 职称 /
    char duty[20];                   / 职务 /
    int   year;                      / 年 /
    int   month;                     / 月 /
    int   day;                       / 日 /
    …..
    return 0;
}
E:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
union professionalState                  / 定义职业共用体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                       / 姓名 /
    char sex;                            / 性别 /
    struct date birthday;                / 出生日期 /
    union professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}
答案: 【#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                 / 定义职业结构体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                        / 姓名 /
    char sex;                             / 性别 /
    struct date birthday;                 / 出生日期 /
    struct professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}】

14、 问题:下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <stdio.h>

include  <string.h>

define NUM_ELECTORATE 10

define NUM_CANDIDATE 3

struct candidate
{
    char  name[20];
    int   count;
}candidate[3] = {"li",0, "zhang",0, "wang",0};

int main()
{
    int  i, j, flag = 1, wrong = 0;
    char  name[20];
    for (i=1; i<=NUM_ELECTORATE; i++)
    {
       printf("Input vote %d:", i);
       scanf("%s", name);
       strlwr(name); / C语言的标准库函数，功能是将name中的字符全部变成小写字母 /
       flag = 1;
       
       for (j=0; j<NUM_CANDIDATE; j++)
       {         
            if (__) 
            {
                _;
                flag = 0;
            }
        }
        
       if (flag)
        {
            wrong++;  / 废票计数 /
            _;
        }
        }
       printf("Election results:");
       
       for (i=0; i<NUM_CANDIDATE; i++)
       {
            printf("%s:%d", ______);
       }
       
       printf("Wrong election:%d", wrong);
       return 0;
}
选项：
A:第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 0第41行：  candidate[i].name, candidate[i].count
B:第24行：  name == candidate[j].name第26行：  count++第34行：  flag = 0第41行：  name, count
C:第24行：  name = candidate[j].name第26行：  count++第34行：  flag = 1第41行：  candidate[i].name[i], candidate[i].count
D:第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 1第41行：  name, count
答案: 【第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 0第41行：  candidate[i].name, candidate[i].count】

第1周——海陆空齐上阵：又来了一堆数据 练兵区——单选题——不计入总分

1、 问题:设有以下说明语句，则下面的叙述中错误的是struct ex
{ 
    int x ; 
    float y; 
    char z ;
 } example;
选项：
A:example是结构体类型名
B:struct是结构体类型的关键字
C:x,y,z都是结构体成员名
D:ex为结构体标签。
答案: 【example是结构体类型名】

2、 问题:以下正确的描述是
选项：
A:结构体和共用体变量都不能进行比较操作。
B:两个结构体变量可以比较，但不能将结构体类型作为函数返回值类型。 
C:既可以对两个共用体变量进行比较操作，也可以将共用体变量作为函数参数。 
D:关键字typedef用于定义一种新的数据类型。
E:结构体和共用体变量都能进行比较操作。
F:枚举类型和结构体、共用体一样，也是一种构造数据类型。
G:不同结构体类型的成员名不能相同。
H:和数组一样，即使是相同类型的结构体变量也不能整体赋值，只能逐个成员进行赋值。
答案: 【结构体和共用体变量都不能进行比较操作。】

3、 问题:以下程序执行后的输出结果是#include <stdio.h>
struct STU
{
    char name[10];
    int num;
};

void Fun1(struct STU c)
{
    struct STU b={"LiGuo",2042};
    c=b;
};

void Fun2(struct STU c)
{
    struct STU b={"SunDan",2044};
    c=b;
};

int main()
{
    struct STU a={"YangHan",2041},b={"WangYi",2043};
    Fun1(a);
    Fun2(&b);
    printf("%d %d",a.num,b.num);
    return 0;
}
选项：
A:2041 2044
B:2041 2043 
C:2042 2044 
D:2042 2043
答案: 【2041 2044】

4、 问题:以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
struct stu
{ 
    char num[10]; 
    float score[3];
};

int main()
{
    struct stu s[3]={{"20021",90,95,85},{"20022",95,80,75},{"20023",100,95,90}},*p=s;
    int i,j; 
    float sum;
    
    ____
    
    return 0;
}
选项：
A:for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }        
        printf("%6.2f",sum);
        p++;
    }
B:        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }
        printf("%6.2f",sum);
C:        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
            p++;
        }        
        printf("%6.2f",sum)
D:   for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
            p++;
        }        
        printf("%6.2f",sum);      
    }
答案: 【for (j=0;j<3;j++)
    {   
        sum=0;
        for(i=0;i<3;i++)
        {   
            sum=sum+p->score[i];
        }        
        printf("%6.2f",sum);
        p++;
    }】

5、 问题:某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是
选项：
A:struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;
 
 s.birth.year = 1984;
 s.birth.month = 11;
 s.birth.day = 11;
B:struct student
{   
    int number;
    char name[20];
    char sex;
    int year;
    int month;
    int day;
} s;
 
 year = 1984;
 month = 11;
 day = 11;
C:struct student
{   
    int number;
    char name[20];
    char sex;
} s;
struct
{   
    int year;
    int month;
    int day;
} birth;
birth.year = 1984;
birth.month = 11;
birth.day = 11;
D:struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;

s.year = 1984;
s.month = 11; 
s.day = 11;
答案: 【struct student
{   
    int number;
    char name[20];
    char sex;
    struct
    {   
        int year;
        int month;
        int day;
    } birth;
} s;
 
 s.birth.year = 1984;
 s.birth.month = 11;
 s.birth.day = 11;】

6、 问题:若能使程序运行后的输出结果如下：201501201502201503则空白处填写的表达式或语句应该是#include <stdio.h>
struct student
 { 
     int age;
     char num[8];
  };
  
int main()
{
    struct student stu[3]={{20,"201501"},{21,"201502"},{19,"201503"}};
    struct student p=stu;
   
    ________
    
    return 0;
}
选项：
A:    printf("%s",(p).num);    printf("%s",(++p)->num);    printf("%s",stu[2].num);
B:    printf("%s",(p++).num);    printf("%s",(p++).num);    printf("%s",(p++).num);
C:    printf("%s",(++p)->num);    printf("%s",(++p)->num);    printf("%s",(p).num);
D:    printf("%s",stu[0]->num);    printf("%s",stu[1]->num);    printf("%s",stu[2]->num);
答案: 【    printf("%s",(p).num);    printf("%s",(++p)->num);    printf("%s",stu[2].num);】

7、 问题:以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <stdio.h>
typedef struct clock
{
    int hour;
    int minute;
    int second;
}CLOCK;

/ 函数功能：时、分、秒时间的更新 /
void Update(_)                 
{
    static long m = 1;   
    t->hour = m / 3600;   
    t->minute = ___;   
    t->second = _;   
    m++;   
    if (t->hour == 24)  m = 1;   
}

/ 函数功能：时、分、秒时间的显示 /
void Display(CLOCK *t)                     
{
    printf("%2d:%2d:%2d\r", t->hour, t->minute, t->second);
}

/ 函数功能：模拟延迟1秒的时间 /
void Delay(void)                     
{
    long t;
    for (t=0; t<50000000; t++)
        {
            / 循环体为空语句的循环，起延时作用 /
        }
}

int main()
{
    long i;
    CLOCK myclock;
    myclock.hour = myclock.minute = myclock.second = 0;   
    for (i=0; i<100000; i++)  / 利用循环，控制时钟运行的时间 /
    { 
        Update(&myclock);          / 时钟值更新 /
        Display(____);          / 时间显示 /
        Delay();                     / 模拟延时1秒 /
    }    
    return 0;
}
选项：
A:第10行：  CLOCK t第14行：  (m – 3600 * t->hour) / 60第15行：  m % 60第44行：  &myclock
B:第10行：  CLOCK t第14行：  (m – 3600 * hour) / 60第15行：  m / 60第44行：  &myclock
C:第10行：  CLOCK t第14行：  (m – 3600 * t->hour) / 60第15行：  m / 60第44行：  myclock
D:第10行：  CLOCK t第14行：  (m – 3600 * hour) / 60第15行：  m % 60第44行：  myclock
答案: 【第10行：  CLOCK *t第14行：  (m – 3600 * t->hour) / 60第15行：  m % 60第44行：  &myclock】

8、 问题:下面程序的输出结果是#include <stdio.h>
int main()
{  
    union
    { 
        int i[2];
        int k;
        int c;
    }t,*s = &t;
    
    s->i[0] = 10;
    s->i[1] = 20;
    s->k=30;
    printf("%d", s->k);    
    printf("%d", s->i[0]); 
    printf("%d", s->c);   
    return 0;
}
选项：
A:303030
B:102030
C:3010随机数
D:301020
答案: 【303030】

9、 问题:设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。
选项：
A:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                 / 定义职业结构体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                        / 姓名 /
    char sex;                             / 性别 /
    struct date birthday;                 / 出生日期 /
    struct professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}
B:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                   / 定义职业结构体类型 /
{
    char college[80];                      / 所在学院/
    char professionalTitle[20];            / 职称 /
    char duty[20];                         / 职务 /
};
int main()
{
    char name[20];                         / 姓名 /
    char sex;                              / 性别 /
    struct date birthday;                  / 出生日期 /
    struct professionalState occupation;   / 职业状况 /
    ……
    return 0;
}
C:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
int main()
{
    char name[20];                   / 姓名 /
    char sex;                        / 性别 /
    struct date birthday;            / 出生日期 /
    char college[80];                / 所在学院/
    char professionalTitle[20];      / 职称 /
    char duty[20];                   / 职务 /
    ……
    return 0;
}
D:#include <stdio.h>
int main()
{
    char name[20];                   / 姓名 /
    char sex;                        / 性别 /
    char college[80];                / 所在学院/
    char professionalTitle[20];      / 职称 /
    char duty[20];                   / 职务 /
    int   year;                      / 年 /
    int   month;                     / 月 /
    int   day;                       / 日 /
    …..
    return 0;
}
E:#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
union professionalState                  / 定义职业共用体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                       / 姓名 /
    char sex;                            / 性别 /
    struct date birthday;                / 出生日期 /
    union professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}
答案: 【#include <stdio.h>
struct date                            / 定义日期结构体类型 /
{
    int   year;                        / 年 /
    int   month;                       / 月 /
    int   day;                         / 日 /
};
struct professionalState                 / 定义职业结构体类型 /
{
    char college[80];                    / 所在学院/
    char professionalTitle[20];          / 职称 /
    char duty[20];                       / 职务 /
};
struct person                            / 定义职工个人信息结构体类型 /
{
    char name[20];                        / 姓名 /
    char sex;                             / 性别 /
    struct date birthday;                 / 出生日期 /
    struct professionalState occupation;  / 职业状况 /
};
int main()
{ 
    ……
    return 0;
}】

10、 问题:下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <stdio.h>

include  <string.h>

define NUM_ELECTORATE 10

define NUM_CANDIDATE 3

struct candidate
{
    char  name[20];
    int   count;
}candidate[3] = {"li",0, "zhang",0, "wang",0};

int main()
{
    int  i, j, flag = 1, wrong = 0;
    char  name[20];
    for (i=1; i<=NUM_ELECTORATE; i++)
    {
       printf("Input vote %d:", i);
       scanf("%s", name);
       strlwr(name); / C语言的标准库函数，功能是将name中的字符全部变成小写字母 /
       flag = 1;
       
       for (j=0; j<NUM_CANDIDATE; j++)
       {         
            if (__) 
            {
                _;
                flag = 0;
            }
        }
        
       if (flag)
        {
            wrong++;  / 废票计数 /
            _;
        }
        }
       printf("Election results:");
       
       for (i=0; i<NUM_CANDIDATE; i++)
       {
            printf("%s:%d", ______);
       }
       
       printf("Wrong election:%d", wrong);
       return 0;
}
选项：
A:第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 0第41行：  candidate[i].name, candidate[i].count
B:第24行：  name == candidate[j].name第26行：  count++第34行：  flag = 0第41行：  name, count
C:第24行：  name = candidate[j].name第26行：  count++第34行：  flag = 1第41行：  candidate[i].name[i], candidate[i].count
D:第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 1第41行：  name, count
答案: 【第24行：  strcmp(name, candidate[j].name) == 0第26行：  candidate[j].count++第34行：  flag = 0第41行：  candidate[i].name, candidate[i].count】

11、 问题:下面说法错误的是
选项：
A:在一个结构体内不能包含另一个不同类型的结构体作为其成员。
B:用结构体变量做函数参数，是将结构体变量的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
C:结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
D:和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
E:用指向结构体变量的指针做函数参数，是将结构体变量的地址传给被调函数，因此在被调函数中对结构体内容的修改会影响原结构体变量。
答案: 【在一个结构体内不能包含另一个不同类型的结构体作为其成员。】

12、 问题:有以下说明和定义语句，下面各输入语句中错误的是#include <stdio.h>
int main()
{
    struct student
    {
         int age;
         char sex;
         char name[8];
    };
    
    struct student std;
    struct student p=&std;
    …….
    return 0;
}
选项：
A:scanf("%c",&std[0].sex); 
B:scanf("%d",&(p).age); 
C:scanf("%s",std.name);
D:scanf("%c",&(p->sex));
答案: 【scanf("%c",&std[0].sex); 】

13、 问题:若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。struct 
{   
    short a;
    float b;
} v1;union 
{   
    short a;
    float b;
} v2;
选项：
A:执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
B:执行sizeof(v1)获得的结果是6个字节，只能对结构体变量v1中的第一个成员进行初始化。
C:执行sizeof(v2)获得的结果是6个字节，只能对共用体变量v2中的第一个成员进行初始化。
D:执行sizeof(v2)获得的结果是4个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
E:执行sizeof(v2)获得的结果是8个字节，只能对共用体变量v2中的第一个成员进行初始化
F:执行sizeof(v1)获得的结果是8个字节，只能对结构体变量v1中的第一个成员进行初始化。
G:执行sizeof(v1)获得的结果是4个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
H:执行sizeof(v2)获得的结果是6个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
答案: 【执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。】

14、 问题:以下选项中不能正确把cl定义成结构体变量的是
选项：
A:struct color cl
{ 
    int red;
    int green;
    int blue;
}
B:typedef struct
{ 
    int red;
    int green;
    int blue;
} COLOR;
COLOR cl;
C:struct color 
{ 
    int red;
    int green;
    int blue;
} cl;
D:struct
{ 
    int red;
    int green;
    int blue;
} cl;
答案: 【struct color cl
{ 
    int red;
    int green;
    int blue;
}】

【作业】第1周——海陆空齐上阵：又来了一堆数据 第1周编程题在线测试

1、 问题:计算时间差V2.0
建议：【本题是主观题,暂无解析】

2、 问题:奖学金发放
建议：【本题是主观题,暂无解析】

3、 问题:评选最牛群主v1.0
建议：【本题是主观题,暂无解析】

4、 问题:星期判断
建议：【本题是主观题,暂无解析】

【作业】第1周——海陆空齐上阵：又来了一堆数据 练兵区——编程题——不计入总分

1、 问题:大奖赛现场统分
建议：【本题是主观题,暂无解析】

2、 问题:学生成绩管理系统V3.0
建议：【本题是主观题,暂无解析】

3、 问题:单词接龙
建议：【本题是主观题,暂无解析】

4、 问题:分数比较
建议：【本题是主观题,暂无解析】

5、 问题:百万富翁的换钱计划
建议：【本题是主观题,暂无解析】

6、 问题:用计数控制的循环实现正数累加求和
建议：【本题是主观题,暂无解析】

7、 问题:平方根表
建议：【本题是主观题,暂无解析】

8、 问题:最大公约数
建议：【本题是主观题,暂无解析】

9、 问题:23根火柴游戏
建议：【本题是主观题,暂无解析】

【作业】第1周——海陆空齐上阵：又来了一堆数据 第1周编程题在线测试+

1、 问题:计算时间差V2.1
建议：【本题是主观题,暂无解析】

第2周——原来内存也可以这么玩，我是指针我怕谁 第2周测验

1、 问题:下面程序的功能是通过动态分配内存函数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))】

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

3、 问题:申请一个具有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)); 】

4、 问题:假设用下面语句申请了一块动态内存，并用指针变量指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）】

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、 问题:关于下面程序中的变量和常量分布的内存区域说法错误的是#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"存放在栈中】

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

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

11、 问题:下面程序希望得到的运行结果如下：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*);】

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)); 】

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

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)); 】

【作业】第2周——原来内存也可以这么玩，我是指针我怕谁 练兵区——编程题——不计入总分

1、 问题:学生成绩管理系统V4.0
建议：【本题是主观题,暂无解析】

2、 问题:寻找最高分成绩的学生
建议：【本题是主观题,暂无解析】

3、 问题:程序改错
建议：【本题是主观题,暂无解析】

4、 问题:矩阵转置
建议：【本题是主观题,暂无解析】

5、 问题:在升序排序的数组中插入一个元素
建议：【本题是主观题,暂无解析】

6、 问题:计算平均数、中位数和众数
建议：【本题是主观题,暂无解析】

第3周——结构设计的艺术 练兵区——单选题

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、 问题:若已建立下面的链表结构，指针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; 】

4、 问题:以下程序执行后的输出结果是#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】

5、 问题:有以下结构体说明和变量定义，如图所示，指针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;】

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

7、 问题:向建立好的单向链表中的结点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;】

8、 问题:已知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;
}】

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

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

【作业】第3周——结构设计的艺术 练兵区——编程题

1、 问题:学生成绩管理系统V5.0
建议：【本题是主观题,暂无解析】

2、 问题:字符串中的字符排序
建议：【本题是主观题,暂无解析】

3、 问题:纯数字字符串检验
建议：【本题是主观题,暂无解析】

4、 问题:孪生素数
建议：【本题是主观题,暂无解析】

5、 问题:求解不等式
建议：【本题是主观题,暂无解析】

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

1、 问题:已知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;
}】

2、 问题:若已建立下面的链表结构，指针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; 】

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

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

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、 问题:向建立好的单向链表中的结点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;】

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

8、 问题:已知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的前驱结点
答案: 【删除链表的尾结点】

9、 问题:有以下结构体说明和变量定义，如图所示，指针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;】

10、 问题:已知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);】

第4周——学会保存你的数据 第4周测验

1、 问题:若要以“a+”方式打开一个已存在的文件，则以下叙述正确的是
选项：
A:文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
B:文件打开时，原有文件内容不被删除，位置指针移动到文件开头，可做重写和读操作。
C:文件打开时，原有文件内容被删除，只可做写操作。
D:以上各种说法都不正确。
答案: 【文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。】

2、 问题:在C语言中，从计算机内存中将数据写入文件中，称为
选项：
A:输出
B:输入
C:修改
D:删除
答案: 【输出】

3、 问题:下面的程序执行后，文件test中的内容是#include <stdio.h>

include <string.h>

void Fun(char fname,char st)
{ 
    FILE *myf; int i;
    myf=fopen(fname,"w" );
    if (myf == NULL)
    {
        printf("cannot open the file.");
        exit(0);
    }
    
   for(i=0;i<strlen(st); i++)
   {
        fputc(st[i],myf);
   }
   
   fclose(myf);
}

int main()
{ 
    Fun("test","new world"); 
    Fun("test","hello");
    return 0;
}
选项：
A:hello
B:new worldhello 
C:new world 
D:hello rld 
答案: 【hello】

4、 问题:阅读以下程序,对程序功能的描述中正确的是#icnlude <stdio.h>
int main()
{
    FILE in, out;
    char ch, infile[10], outfile[10];
    printf("Enter the infile name:");
    scanf("%s", infile);
    printf("Enter the outfile name:");
    scanf("%s", outfile);
    if ((in = fopen(infile, "r")) == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    if ((out = fopen(outfile, "w")) == NULL)
    {
        printf("cannot open outfile.");
        exit(0);
    }
    
    while (!feof(in))
    {
        fputc(fgetc(in), out);
    }
    fclose(in);
    fclose(out);
    return 0;
}
选项：
A:程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
B:程序完成将磁盘文件的信息在屏幕上显示的功能。
C:程序完成将两个磁盘文件合二为一的功能。
D:程序完成将两个磁盘文件合并并在屏幕上输出的功能。
答案: 【程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。】

5、 问题:C语言中标准输入文件stdin是指
选项：
A:键盘
B:显示器
C:鼠标
D:硬盘
E:U盘
答案: 【键盘】

6、 问题:设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是struct st
{
    char name[8];
    int num;
    float s[4];
} student[50];
选项：
A:fwrite(student, 25 * sizeof(struct st), 1, fp); 
B: fwrite(student, sizeof(struct st), 50, fp); 
C:fwrite(student, 50 * sizeof(struct st), 1, fp); 
D:for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp); 
答案: 【for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp); 】

7、 问题:若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
选项：
A:“wb+” 
B:“ab+” 
C:“rb+” 
D:“ab” 
答案: 【“wb+” 】

8、 问题:以下叙述中错误的是
选项：
A:Ｃ语言中顺序读写方式不适用于二进制文件
B:Ｃ语言中的文本文件以ASCⅡ码形式存储数据
C:Ｃ语言中对二进制文件的访问速度比文本文件快
D:Ｃ语言中随机读写方式不适用于文本文件
答案: 【Ｃ语言中顺序读写方式不适用于二进制文件】

9、 问题:有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为#include <stdio.h>
int main()
 {
     FILE *fp1;
     fp1=fopen("f1.txt","w");
     
     if (fp1 == NULL)
     {
         printf("cannot open the file.");
         exit(0);
     }
    
     fprintf(fp1,"abc");
     fclose(fp1);
     return 0;
 }
选项：
A:abc
B:goodabc
C:good
D:abcgood 
答案: 【abc】

10、 问题:以下程序执行后输出结果是#include <stdio.h>
int main()
{ 
    FILE *fp; 
    int i,k=0,n=0;
    fp=fopen("d1.dat","w");
    
    if (fp == NULL)
    {
        printf("cannot open the file.");
        exit(0);
    }
    
    for(i=1;i<4;i++) 
    {
        fprintf(fp,"%d",i);
    }
    fclose(fp);
    
    fp=fopen("d1.dat","r");
    if (fp == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    fscanf(fp,"%d%d",&k,&n); 
    printf("%d %d",k,n);
    fclose(fp);
    return 0;
}
选项：
A:123 0
B:1 2
C:1 23
D:0 0
答案: 【123 0】

11、 问题:关于文件读写，正确的叙述是
选项：
A:可把整型数以二进制形式存放到文件中的函数是fwrite函数。
B:使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。
C:使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。
D:使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。
E:以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。
F:以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。
G:文件打开后一定要检查是否打开成功。
H:文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。
I:以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。
J:以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
K:文件一旦按文本方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是文本，对应的内容都是字符‘1’。
L:文件一旦按二进制方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是二进制文件，对应的内容都是数值1。
M:用FILE只能定义指向文本文件的文件指针。
N:用FILE只能定义指向二进制文件的文件指针。
O:C语言中的文件都是流式文件，只能按顺序读写，不能进行随机读写。
P:文件的读写方式中w+和r+都是可读可写方式，二者是完全一样的。
答案: 【可把整型数以二进制形式存放到文件中的函数是fwrite函数。;
使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。;
使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。;
使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。;
以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。;
以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。;
文件打开后一定要检查是否打开成功。;
文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。;
以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。;
以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。】

12、 问题:以下叙述中错误的是
选项：
A:不可以用FILE定义指向二进制文件的文件指针。
B:二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
C:在程序结束时，应当用fclose()函数关闭已打开的文件。
D:在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。
答案: 【不可以用FILE定义指向二进制文件的文件指针。】

13、 问题:下列关于C语言数据文件的叙述中正确的是
选项：
A:文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
B:文件由ASCII码字符序列组成，C语言只能读写文本文件 
C:文件由二进制数据序列组成，C语言只能读写二进制文件
D:文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
答案: 【文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件】

14、 问题:若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
选项：
A:0
B:1
C:-1
D:一个非0值
答案: 【0】

15、 问题:在进行文件操作时，写文件的一般含义是
选项：
A:将计算机内存中的信息存入磁盘。
B:将磁盘中的信息存入计算机内存。
C:将计算机CPU中的信息存入磁盘。
D:将磁盘中的信息存入计算机CPU。
答案: 【将计算机内存中的信息存入磁盘。】

16、 问题:以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是#include <stdio.h>
int main()
{ 
    FILE *fout; char ch;
    fout=fopen(‘abc.txt’,’w’);
    if (fout == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    ch=fgetc(stdin);
    while(ch!=’#’)
    { 
        fputc(ch,fout);
        ch=fgetc(stdin);
    }
    
    fclose(fout);
    return 0;
}
选项：
A:函数fopen()调用形式错误
B:输入文件没有关闭 
C:函数fgetc()调用形式错误
D:文件指针stdin没有定义
答案: 【函数fopen()调用形式错误】

第4周——学会保存你的数据 练兵区——单选题

1、 问题:下面的程序执行后，文件test中的内容是#include <stdio.h>

include <string.h>

void Fun(char fname,char st)
{ 
    FILE *myf; int i;
    myf=fopen(fname,"w" );
    if (myf == NULL)
    {
        printf("cannot open the file.");
        exit(0);
    }
    
   for(i=0;i<strlen(st); i++)
   {
        fputc(st[i],myf);
   }
   
   fclose(myf);
}

int main()
{ 
    Fun("test","new world"); 
    Fun("test","hello");
    return 0;
}
选项：
A:hello
B:new worldhello
C:new world 
D:hello rld 
答案: 【hello】

2、 问题:有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为#include <stdio.h>
int main()
 {
     FILE *fp1;
     fp1=fopen("f1.txt","w");
     
     if (fp1 == NULL)
     {
         printf("cannot open the file.");
         exit(0);
     }
    
     fprintf(fp1,"abc");
     fclose(fp1);
     return 0;
 }
选项：
A:abc
B:goodabc
C:good
D:abcgood
答案: 【abc】

3、 问题:下列关于C语言数据文件的叙述中正确的是
选项：
A:文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
B:文件由ASCII码字符序列组成，C语言只能读写文本文件 
C:文件由二进制数据序列组成，C语言只能读写二进制文件
D:文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
答案: 【文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件】

4、 问题:以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是#include <stdio.h>
int main()
{ 
    FILE *fout; char ch;
    fout=fopen(‘abc.txt’,’w’);
    if (fout == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    ch=fgetc(stdin);
    while(ch!=’#’)
    { 
        fputc(ch,fout);
        ch=fgetc(stdin);
    }
    
    fclose(fout);
    return 0;
}
选项：
A:函数fopen()调用形式错误
B:输入文件没有关闭 
C:函数fgetc()调用形式错误
D:文件指针stdin没有定义
答案: 【函数fopen()调用形式错误】

5、 问题:阅读以下程序,对程序功能的描述中正确的是#icnlude <stdio.h>
int main()
{
    FILE in, out;
    char ch, infile[10], outfile[10];
    printf("Enter the infile name:");
    scanf("%s", infile);
    printf("Enter the outfile name:");
    scanf("%s", outfile);
    if ((in = fopen(infile, "r")) == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    if ((out = fopen(outfile, "w")) == NULL)
    {
        printf("cannot open outfile.");
        exit(0);
    }
    
    while (!feof(in))
    {
        fputc(fgetc(in), out);
    }
    fclose(in);
    fclose(out);
    return 0;
}
选项：
A:程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
B:程序完成将磁盘文件的信息在屏幕上显示的功能。
C:程序完成将两个磁盘文件合二为一的功能。
D:程序完成将两个磁盘文件合并并在屏幕上输出的功能。
答案: 【程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。】

6、 问题:设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是struct st
{
    char name[8];
    int num;
    float s[4];
} student[50];
选项：
A:fwrite(student, 25 * sizeof(struct st), 2, fp); 
B: fwrite(student, sizeof(struct st), 50, fp); 
C:fwrite(student, 50 * sizeof(struct st), 1, fp); 
D:for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp); 
答案: 【for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp); 】

7、 问题:C语言中标准输入文件stdin是指
选项：
A:键盘
B:显示器
C:鼠标
D:硬盘
E:U盘
答案: 【键盘】

8、 问题:若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
选项：
A:“wb+” 
B:“ab+”
C:“rb+”
D:“ab” 
答案: 【“wb+” 】

9、 问题:在进行文件操作时，写文件的一般含义是
选项：
A:将计算机内存中的信息存入磁盘。
B:将磁盘中的信息存入计算机内存。
C:将计算机CPU中的信息存入磁盘。
D:将磁盘中的信息存入计算机CPU。
答案: 【将计算机内存中的信息存入磁盘。】

10、 问题:关于文件读写，正确的叙述是
选项：
A:可把整型数以二进制形式存放到文件中的函数是fwrite函数。
B:使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。
C:使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。
D:使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。
E:以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。
F:以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。
G:文件打开后一定要检查是否打开成功。
H:文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。
I:以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。
J:以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
K:文件一旦按文本方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是文本，对应的内容都是字符‘1’。
L:文件一旦按二进制方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是二进制文件，对应的内容都是数值1。
M:用FILE只能定义指向文本文件的文件指针。
N:用FILE只能定义指向二进制文件的文件指针。
O:C语言中的文件都是流式文件，只能按顺序读写，不能进行随机读写。
P:文件的读写方式中w+和r+都是可读可写方式，二者是完全一样的。
答案: 【可把整型数以二进制形式存放到文件中的函数是fwrite函数。;
使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。;
使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。;
使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。;
以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。;
以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。;
文件打开后一定要检查是否打开成功。;
文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。;
以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。;
以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。】

11、 问题:若要以“a+”方式打开一个已存在的文件，则以下叙述正确的是
选项：
A:文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
B:文件打开时，原有文件内容不被删除，位置指针移动到文件开头，可做重写和读操作。
C:文件打开时，原有文件内容被删除，只可做写操作。
D:以上各种说法都不正确。
答案: 【文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。】

12、 问题:在C语言中，从计算机内存中将数据写入文件中，称为
选项：
A:输出
B:输入
C:修改
D:删除
答案: 【输出】

13、 问题:以下叙述中错误的是
选项：
A:Ｃ语言中顺序读写方式不适用于二进制文件
B:Ｃ语言中的文本文件以ASCⅡ码形式存储数据
C:Ｃ语言中对二进制文件的访问速度比文本文件快
D:Ｃ语言中随机读写方式不适用于文本文件
答案: 【Ｃ语言中顺序读写方式不适用于二进制文件】

14、 问题:以下程序执行后输出结果是#include <stdio.h>
int main()
{ 
    FILE *fp; 
    int i,k=0,n=0;
    fp=fopen("d1.dat","w");
    
    if (fp == NULL)
    {
        printf("cannot open the file.");
        exit(0);
    }
    
    for(i=1;i<4;i++) 
    {
        fprintf(fp,"%d",i);
    }
    fclose(fp);
    
    fp=fopen("d1.dat","r");
    if (fp == NULL)
    {
        printf("cannot open infile.");
        exit(0);
    }
    
    fscanf(fp,"%d%d",&k,&n); 
    printf("%d %d",k,n);
    fclose(fp);
    return 0;
}
选项：
A:123 0
B:1 2
C:1 23
D:0 0
答案: 【123 0】

15、 问题:以下叙述中错误的是
选项：
A:不可以用FILE定义指向二进制文件的文件指针。
B:二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
C:在程序结束时，应当用fclose()函数关闭已打开的文件。
D:在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。
答案: 【不可以用FILE定义指向二进制文件的文件指针。】

16、 问题:若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
选项：
A:0
B:1
C:-1
D:一个非0值
答案: 【0】

【作业】第4周——学会保存你的数据 练兵区——编程题

1、 问题:计算零件数
建议：【本题是主观题,暂无解析】

2、 问题:走台阶
建议：【本题是主观题,暂无解析】

3、 问题:将数据按照奇偶排序
建议：【本题是主观题,暂无解析】

4、 问题:三色球分组
建议：【本题是主观题,暂无解析】

5、 问题:同构数
建议：【本题是主观题,暂无解析】

第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】

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

15、 问题:以下能正确计算1×2×3×4…×10的程序段是
选项：
A:i=1;
s=1;
do {
        s=si;
        i++;
     } while(i<=10);
B:do
{
    i=1;
    s=1;
    s=si;
    i++;
} while(i<=10);
C:do
{
    i=1;
    s=0;
    s=si;
    i++;
} while(i<=10);
D:i=1;s=0;do {        s=si;        i++;     } while(i<=10);
答案: 【i=1;
s=1;
do {
        s=s*i;
        i++;
     } while(i<=10);】

16、 问题:下面程序的功能是输出以下形式的图案,则在下划线处应填入的是    *#include <stdio.h>
int main( )
{   int i,j;
    for(i=1;i<=4;i++)
     {  
        for(j=1;j<=____;j++) 
        {
            printf("");
        }
        printf("");
     }
    return 0;
}
选项：
A:2i-1
B:2i+1
C:i+2
D:i
答案: 【2*i-1】

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

18、 问题:以下不是死循环的程序段是
选项：
A:int s=36;
while (s) 
{
   –s;
}
B:int i=100;
while(1)
{
    i=i%100+1;
    if (i>100) break;
}
C:for( ; ;);
D:unsigned int k=0;
do{
        ++k;
} while (k>=0);
答案: 【int s=36;
while (s) 
{
   –s;
}】

19、 问题:计算直到最后一项的绝对值小于为止。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include  <stdio.h>

include  <math.h>

int main()
{
    int n = 1;
    float term = 1, sum = 0;
    __;
    
    while (fabs(term) >= 1e-4)      //判末项大小
    {
        term = sign / n;            //求出累加项
        sum = sum + term;           //累加
        ____;               //改变项的符号
       
        n++;                            //分母加1
    }
    printf("sum = %f", sum);
    return 0;
}
选项：
A:第7行代码： float sign=1第13行代码： sign = -sign
B:第7行代码： float sign= -1第13行代码： sign = -sign
C:第7行代码： float sign=1第13行代码： term = -term
D:第7行代码： float sign= -1第13行代码： term = -term
答案: 【第7行代码： float sign=1第13行代码： sign = -sign】

20、 问题:设已定义i和k为int类型变量，则以下for循环语句for(i=0,k=-1;k=1; i++,k++)
    printf( "   ");
选项：
A:是无限循环
B:判断循环结束的条件不合法 
C:循环一次也不执行
D:循环只执行一次
答案: 【是无限循环】

21、 问题:有以下程序,若从键盘给n输入的值是-3,则程序的输出结果是#include <stdio.h>
int main()
{ 
    int s=0,a=1,n;
    scanf("%d",&n);
    do
    { 
        s+=1; 
        a=a-2; 
    } while(a!=n);
    printf("%d",s);
    return 0;
}
选项：
A:2
B:-1
C:3
D:0
答案: 【2】

22、 问题:三色球问题。若一个口袋中放有12个球，其中有3个红色的，3个白色的，6个黑色的，从中任取8个球，问共有多少种不同的颜色搭配？代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h>
int main()
{
    int i, j, k;
    for (i=0; i<=3; i++)
    {
        for (j=0; j<=3; j++)
        {
                for (____)
                {
                    if (______)
                    {
                        printf("i=%d, j=%d, k=%d", i, j, k);
                    }
                }
        }
    }
    
    return 0;
}
选项：
A:第9行：   k=0; k<=6; k++第11行：  i + j + k == 8
B:第9行：   k=0; k<=6; k++第11行：  i + j + k = 8
C:第9行：   k=0; k<=6; k++第11行：  i + j + k <= 8
D:第9行：   k=0; k<6; k++第11行：  i + j + k == 8
答案: 【第9行：   k=0; k<=6; k++第11行：  i + j + k == 8】

23、 问题:我国古代的《张丘建算经》中有这样一道著名的百鸡问题：“鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。百钱买百鸡，问鸡翁、母、雏各几何？”其意为：公鸡每只5元，母鸡每只3元，小鸡3只1元。用100元买100只鸡，问公鸡、母鸡和小鸡各能买多少只？代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h>
int main()
{
    int x, y, z;
    for (x=0; x<=20; x++)
    {
        for (y=0; ___; y++)
        {
                __;
                if (__)
                {
                    printf("x=%d, y=%d, z=%d", x, y, z);
                }
        }
    }
    
    return 0;
选项：
A:第7行：     y<=33第9行：     z = 100 – x – y第10行：     5x + 3y + z/3.0 == 100
B:第7行：     y<=33第9行：     z + y + x = 100第10行：     5x + 3y + z/3.0 = 100
C:第7行：     y<=33第9行：     z = 100 – x – y第10行：     5x + 3y + z/3.0 == 100
D:第7行：     y<33第9行：     z = 100 – x – y第10行：     5x + 3y + z/3.0 <= 100
答案: 【第7行：     y<=33第9行：     z = 100 – x – y第10行：     5x + 3y + z/3.0 == 100】

24、 问题:以下程序的功能是计算：s= 1+1/2+1/3+……+1/10,程序运行后输出结果错误，导致错误结果的程序行是#include <stdio.h>
int main()
{ 
    int n; 
    float s;
    s=1.0;
    for(n=10;n>1;n–)
    {
        s=s+1/n;
    }
    printf("%6.4f",s);
    return 0;
}
选项：
A:s=s+1/n;
B: printf("%6.4f",s);
C:for(n=10;n>1;n–)
D:s=1.0;
答案: 【s=s+1/n;】

第5周——周而复始的循环之道 第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 x=0,y=5,z=3;
    while(z–>0 && ++x<5) 
    {
        y=y-1;
    }
    printf("%d,%d,%d",x,y,z);
    return 0;
}
选项：
A:3,2,-1
B:3,2,0
C:4,3,-1
D:5,-2,-5
答案: 【3,2,-1】

4、 问题:下面程序的输出是#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 】

5、 问题:爱因斯坦数学题。爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨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】