C语言 题库答案汇总
答案是 A、函数
C语言程序的基本单位是函数。程序是由一系列函数组成的，每个函数完成特定的任务。程序的执行从主函数 main() 开始，由 main() 函数调用其他函数，其他函数可以再调用其他函数，形成程序的执行流程。
C
C语言的执行是从程序的入口点开始。在C语言中，程序的入口点是main函数。当程序被执行时，操作系统会找到并加载可执行文件，然后从main函数开始执行。
C
A选项：从main函数开始
B选项：C语言中不是说要调用的函数必须在mian()函数内定义，而是每个函数在调用前要对其进行定义(申明)。
D选项：main()函数可以放在程序中的任意位置 ，但不论main函数在整个过程中的位置如何，一个C程序总是从mam函数开始执行的。
B
C语言严格区分大小写
C
C语言规定
1、标识符只能由字母（A-Z，a-z）、数字（0-9）和下划线（_）组成。
2、标识符的第一个字符只能是字母或者下划线
B
标识符可以由字母、数字、下划线组成，且开头不能是数字
C
只能有字母、数字和下划线组成，且以字母或下划线开头。
A
标识符：必须以字母、下划线或数字组成 且 数字不能开头 且 不能用关键字
D
整型：整数int、short、long、
实型：浮点数float、double
字符型：char
C
在C语言中，%表示取模运算符，用于计算两个整数相除后的余数。
对于表达式5%2，我们按照以下步骤进行计算：
5除以2的商是2，余数是1。
因此，5%2的结果是1。
所以，正确答案是C)1。
A
条件运算符的格式是：条件 ? 表达式1 : 表达式2。它的意思是，如果“条件”为真（非0），则整个表达式的值为“表达式1”的值；否则，其值为“表达式2”的值。
给定int a=3,b=4，我们可以计算条件表达式"a<b? a:b"的值。
首先评估条件a<b。由于3确实小于4，所以条件为真。
因为条件为真，所以整个表达式的值就是“表达式1”的值，即a的值。
根据题目，a的值为3。
所以，条件表达式"a<b? a:b"的值是3。
B
首先，我们需要了解x<z?y:z这个表达式的含义。
这是一个条件运算符（也叫三元运算符），它的格式是：条件 ? 表达式1 : 表达式2。它的意思是，如果“条件”为真（非0），则整个表达式的值为“表达式1”的值；否则，其值为“表达式2”的值。
现在，给定int x=2,y=3,z=4，我们可以计算x<z?y:z的值。
首先评估条件x<z。由于2确实小于4，所以条件为真。
因为条件为真，所以整个表达式的值就是“表达式1”的值，即y的值。
根据题目，y的值为3。
所以，x<z?y:z的结果是3。
答案是B)3。
B
关系表达式（&、|、~）和逻辑表达式(&&、||)运算的结果用0或1表示
D
A选项答案应该是3，C语言中整型直接保留前面的整数部分，小数直接舍去，B,C答案是小数，且结果也不为4
B
1/a = 0，再强制转换为float的话是0.0
A
C语言中，float强制转换成int采取的是只保留整数部分的方式，正数向下，负数向上
D
C语言中初始值要为常量，不允许对数组的大小做动态定义
C
A选项小括号应该是{}
B选项a(5)应该是a[5]
D选项a{5}应该是a[5]
D
#define N 10,是预编译过程，在编译前会把所有的N替换成10，因此int x[N]在编译前会被换成：int x[10]；，N即常量10，因此不会有错。
至于 后面int N = 10; int x[N]; N为变量，在c语言中，是不允许的。
D
数组下标是从0-9（10-1）下标最大减一
C
i=10,a[i]就是a[10]=9
然后a[9]就是6
B
C
C
A
A
B
C
A
D
C
B
C
D
C
A
D
B
C
B
D
A
B
no
min=-34
5
1.00, 3.00, 7.00
7.0
-9 is a negative odd
1
2
3
3,7
3 2
2,1
abcde
ABABCDCD
10 5
AB
10
70-80
60-70
852
55
x=0,y=12
1 2 3 5
8 13 21 34
*
*
*
*
852
5 4 3 2 1 0
21
3,0
6 8
0 1 2
1 2 3
2 3 4
*
* *
* *
* *
*
1 1 2 3
5 8 13 21
34 55
0 1 2 3
ave= 36.00
1 4 2 5 3 6
24
0,0,0,0,1,2,0,0,2,3,4,0,3,4,5,6，
result =3
min is 5
10, 20
4
1
r=15
3!=6
12
Max is 8
30
ch=f
1:3
10
*p=1, x=3, y=5
Porm
A ABCD
B BCD
C CD
D D
14
1234,wang,89.5
6
6
main( )
{ char ch;
ch=getchar();
if( ch>=’a’&&ch<=’z’|| ch>=’A’&&ch<=’Z’ )
printf("It is an English character\n");
else if( ch>=’0’&&ch<=’9’ )
printf("It is a digit character\n");
else if( ch== ‘ ’ )
printf("It is a space character\n");
else
printf("It is other character\n"); }
C语言中，字符串后面需要一个结束标志位'\0'，通常系统会自动添加。
对一维数组初始化时可采用字符串的形式(例如本题数组x)，也可采用字符集合的形式(例如本题数组y)。在以字符串形式初始化时，数组x不尽要存储字符串中的字符，还要存储字符串后的结束标志位，因此数组x的长度为6;在以字符集合形式初始化时，数组y，仅存储集合中的元素，因此数组y长度为5
void main()
{ int n,i=0,j=0;
printf(“input a integer,0 for end\n”);
scanf(“%d”,&n);
while ( n或n!=0 ) {
if(n>0) i= i+1 ;
else j=j+1;
scanf(“%d”,&n);
}
printf(“i=%4d,j=%4d\n”,i,j);
}
#include <stdio.h>
void main()
{ int i, sum = 0;
for (i = 1; i<=101 ; i=i+2; )
sum = sum + i;
printf("sum=%d\n", sum); }
main()
{ int i, sum = 0;
i=1;
while ( i<100 )
{ sum = sum + i;
i=i+2 ; }
printf("sum=%d\n", sum);
}
#include <stdio.h>
void main()
{char c;
printf("input a character:");
c=getchar();
if(c>= ‘A’ &&c<= ‘Z’ || c>=‘a’ &&c<= ‘z’) printf("Yes\n");
else printf("No");
}
#include <stdio.h>
void main()
{ int a[10],i,x;
printf(“input 10 integers：”);
for(i=0;i<10;i++)
scanf(“%d”,&a[i]);
printf(“input the number you want to find x：”);
scanf(“%d”, &x );
for(i=0;i<10;i++)
if( x==a[i] )
break;
if( i<10 )
printf(“the pos of x is：%d\n”,i);
else printf(“can not find x！\n”);
}
#include <stdio.h>
main( )
{ int i, a[20], s, count;
s=count=0;
for(i=0; i<20; i++)
scanf(“%d”, &a[i] );
for(i=0; i<20; i++)
{ if( a[i]<0 ) continue ;
s+=a[i] ;
count++;
}
printf(“s=%d\t count=%d\n”, s, count”);
}
#include <stdio.h>
int main(void){
int i, index, k, n, temp;
int a[10]; /* 定义1个数组a，它有10个整型元素*/
printf(“Enter n: ");
scanf_s("%d",&n);
printf(“Enter %d integers: ", n);
for(i = 0; i < n; i++)
scanf("%d", &a[i]);
for(k = 0; k < n-1; k++){ /* 对n个数排序 */
index = k;
for( i=k+1;i<n;i++ ) //从k+1开始，依次遍历找到最小值
if( a[i]<a[index] ) index = i;
temp=a[k]; a[k]=a[index]; a[index]=temp //将当前未交换a[k]的值和最小值交换，即将最小值依次保存在前方。
}
printf("After sorted: ");
for(i = 0; i < n; i++) /* 输出n个数组元素的值 */
printf_s("%d ",a[i]);
return 0;}
C
D
D
D
C
B
B
D
C
A
15
3
6
1,1
ogram#
1#3#2
max value is 36
#include <stdio.h> ————————1分
main()
{
int x,y； ————————1分
printf(“请输入x的值：”)；
scanf(“%d”,&x); ————————1分
if(x<5)
{y=x-9;
printf(“函数的值为：%d”，y); ————————2分
}
else if(x<15)
{
y=5*x-3;
printf(“函数的值为：%d”，y); ————————3分
}
else
{
y=6*x+9;
printf(“函数的值为：%d”，y); ————————2分
}
}
#include "stdio.h"
main()
{
int i;
int fact(); ————————————1分；
for(i=0;i<5;i++)
printf("%d!=%d\n",i,fact(i)); ————————————2分
}
int fact(j)
int j;
{
int sum;
if(j==0)
sum=1; ——————————————3分
else
sum=j*fact(j-1); ——————————————4分
return sum;
}
#include “stdio.h”
#include “malloc.h”
#define NULL 0
#define LEN sizeof(struct student)
struct student
{
long num;
float score;
struct student *next; ————————3分
} ;
int n;
struct student *creat(void)
{
struct student * head;
struct student *p1,*p2;
n=0;
p1=p2=(struct student *)malloc(LEN); ————————2分
scanf(“%ld,%f”,&p1->num,&p1->score);
head=NULL;
while(p1->num!=0)
{
n=n+1;
if (n==1) head=p1;
else p2->next=p1;
p2=p1;
p1=(struct student *)malloc(LEN);
scanf(“%ld,%f”,&p1->num,&p2->score); ————————3分
}
p2->next=NULL;
return(head);
}
void main( )
{
struct student *pt;
pt=creat( );
printf(“\nnum:%ld\nscore:%5.1f\n”,pt->num,pt->score); ————————2分
}
#include “stdio.h”
main()
{
int a[11]={1,5,6,7,13,22,27,37,38,45};
int temp1,temp2,num,end,i,j; ————————1分
printf("original array is:\n");
for(i=0;i<10;i++)
printf("%5d",a[i]);
printf("\n");
printf("insert a new number:");
scanf("%d",&num);
end=a[9]; ————————2分
if(num>end)
a[10]=num;
else
{for(i=0;i<10;i++)
{ if(a[i]>num)
{temp1=a[i];
a[i]=num; ————————2分
for(j=i+1;j<11;j++)
{ temp2=a[j]; ————————2分
a[j]=temp1;
temp1=temp2; ————————2分
}
break;
}
}
}
for(i=0;i<11;i++)
printf("%d",a[i]); ————————1分
}
#include <stdio.h>
int main()
{
int a[2][3]={{1,2,3},{4,5,6}}; ————————1分（也可循环输入）
int b[3][2],i,j; ————————1分
for (i=0;i<=2;i++) ————————2分
{
for (j=0;j<=1;j++) ————————2分
{ b[i][j]=a[j][i]; ————————3分
printf("%5d",b[i][j]); ————————1分
}
printf("\n");
}
return 0;
}
B
D
A
A
D
C
A
C
解析：选项A、B、D都无分号
变量 = 表达式;//赋值语句是一定带分号的
int a=b=c=5;//本语句错误
{
int a,b,c;
a = b = c = 5;
}//正确赋值语句
B
a=4,b=8
x=1,y=2 答对一半给3分
1 3 2 答错一个扣2分
2
4
6
8 答错一个扣1分
ga
12
15
#include <stdio.h> 1分
int main() 1分
{ int i,j,k,n; 1分
for(n=100;n<=999;n++) 1分
{ i=n/100; 1分
j=n/10%10; 1分
k=n%10; 1分
if(n==(i*i*i+j*j*j+k*k*k)) 1分
printf("%d\n",n); 1分
}
return 0; 1分
}
#include<stdio.h> 1分
int main( ) 1分
{
char s1[20],s2[20]; 1分
int i; 1分
scanf("%s",s1); 1分
for(i=0;s1[i]!='\0';i++) 1分
s2[i]=s1[i]; 1分
s2[i]='\0'; 1分
printf("%s\n",s2); 1分
return 0; 1分
}
#include<stdio.h>
struct student
{ int num;
char name[8];
float salary;
} s[5]; 2分
int main()
{ int min, i; 1分
for (i=0; i<5; i++) 1分
scanf ("%d%s%f", &s[i].num, s[i].name, &s[i].salary); 1分
min=0; 1分
for (i=1; i<5; i++) 1分
if (s[min].salary>s[i].salary) 1分
min=i; 1分
printf("%s\n", s[min].name); 1分
return 0;
}
#include “stdio.h” 1分
int main() 1分
{ int m, n, i; 1分
scanf(“%d,%d”, &m, &n); 1分
i=m ; 1分
while ( ! (m%i==0 && n%i==0)) 2分
i--; 1分
printf(“%d”, i); 1分
return 0; 1分
}
#include <stdio.h> 1分
int main() 1分
{
int a[2][3]={{1,2,3},{4,5,6}}; 1分
int b[3][2],i,j; 1分
for (i=0;i<=2;i++) 1分
{
for (j=0;j<=1;j++) 1分
{ b[i][j]=a[j][i]; 1分
printf("%5d",b[i][j]); 1分
}
printf("\n"); 1分
}
return 0; 1分
}
C
D
D
D
A
C
D
C
A
A
B
D
B
C
C
A
B
A
B
C
答案是2，不是3
++a||++b＆＆++a
按照运算符优先级，等价于：
++a||(++b＆＆++a)
因为++a的值为2，为真，所以整个表达式的值为真，||右边的表达式不再运算，即逻辑或短路，所以b的值还是原来的值，即2
A
B
D
A
B
C
A
D
Ａ
B
这是用两个逗号将三个表达式连成的一个逗号表达式。
计算该逗号表达式值时，从左至右逐一计算每个表达式的值。该逗号表达式的值是最后一个表达式的值，该表达式类型也是最后一个表达式的类型。所以这个表达式(m+1,n+1,(--m)+(n--)),m的最后的值(--m)之后m是4，n的值(n--)之后n还是3，所以m+1 的值是 5;n+1的值是4，(m+1,n+1,(--m)+(n--)) 最终的值应该是 5,4,7
C
B
A
A
A
B
C
D
A
A
D
A
D
D
C
B
A
B
B
C
A
B
B
D
B
D
C
B
B
B
B
A
D
C
C
A
C
B
D
C
B
D
C
B
D
A
C
A
D
B
B
A
A
D
A
A
D
A
B
A
D
B
A
C
B
B
B
B
B
C
A
B
D
Ａ
D
B
D
A
C
A
C
B
C
A
D
A
B
D
A
C
A
A
D
因为if语句不会为真，即不会执行语句x=*(p+i)*2;
所以x的值不会改变，由于x未初始化赋值，所以x的值不确定。
D
B
D
字节对齐，所以是4 + 10 + 2 + 4 = 20
C
B
字节对齐如下图
C
语句1和语句2错误，语句3正确
语句1的a重复定义，语句2赋值表达式写法不对，语句3使用枚举值没问题，变量j虽然没有初始值就自增，但是没有语法错误。
D
答案C
A错，STU是结构类型名，B错，PSTU是指向STU的指针类型，D错。
C
在考虑内存对齐的情况下，我们需要对结构体的内存布局进行分析。
首先，对于union u_type，其大小由其最大的成员决定，也就是double x，所以它的大小是8字节。
接下来，对于struct str_type：
char str[100]：大小为100字节。
union u_type u[2]：大小为2 * 8 = 16字节。
在大多数平台上，struct的对齐通常是基于其最宽成员的对齐要求。在这里，最宽的成员是double x，所以结构体的对齐要求可能是8字节。
那么，在进行内存布局时，char str[100]占据100字节，之后可能有一些填充字节使得union u_type u[2]能够按照8字节对齐开始。考虑到100字节后正好是12的倍数，为了满足8字节对齐，可能会插入4个填充字节。之后，union u_type u[2]占据16字节。
所以，整个struct str_type的大小可能是100字节（char数组） + 4字节（填充） + 16字节（两个union）= 120字节。
因此，考虑内存对齐后，"printf("%d", sizeof(struct str_type));"的输出结果可能是120。答案是C、120。
C
A
A
B
D
C
【解析】本题中if(a＝1)b＝1；与else d＝3； 之间多了语句c＝2；所以会出现else语句的位置错误的编译失败提示。
【解析】case常量表达式只是起语句标号作用，并不是该处进行条件判断。在执行switch语句时，根据switch的表达式，找到与之匹配的case语句，就从此case子句执行下去，不在进行判断，直到碰到break或函数结束为止。所以执行内层switch(y)时只执行了a＋＋，此时a的值为1。然后执行外层case 2语句的a＋＋；b＋＋；a为2，b为1。所以结果为B)。
【解析】由于内层循环 for( k＝1； k<3； k＋＋)后面直接跟了空语句"；“所以在循环内部什么操作也不做，跳出外层循环后执行打印语句，所以打印了一个”"，选择C)。
【解析】case常量表达式只是起语句标号作用，并不是该处进行条件判断。在执行switch语句时，根据switch的表达式，找到与之匹配的case语句，就从此case子句执行下去，不再进行判断，直到碰到break或函数结束为止。简单的说break是结束整个循环体，而continue是结束单次循环。B)选项中当产生的随机数n为4时要执行打印操作。C)选项中当产生的随机数为1和2时分别执行case3与case4后面语句的内容。由于存在break语句所以for循环不是固定执行8次，执行次数与产生的随机数n有关系。
【解析】第一次调用m＝f(f(f(1)))，第二次为m＝f(f(2))，第三次为m＝f(4)，即返回值为8。
【解析】不能将一个整数直接赋给指针变量作为地址，所以A)是错误的。函数的返回值可以是地址，即指针。函数调用中形参值的变化不会传递给实参。
【解析】指针是用来存放地址的变量，用 (类型名 *指针变量名)的形式定义。赋值时应将某个变量地址即&x 赋给指针变量，所以选择B)。
【解析】D)选项中x[2][3]定义的是一个两行三列的二维数组，而在给数组元素赋值时却赋成了三行，所以错误。
【解析】本题中的函数fun()的功能是将数组k中前5个元素倒序，所以返回后数组k中的元素排列是5,4,3,2,1,6,7,8,9,10。所以打印输出k[2]到k[7]元素的值，即321678，所以选择A。
【解析】 本题中由fun函数可知，b[0]＝a[0][0]－a[0][3]＝1－4＝－3，b[1]＝a[1][1]－[1][2]＝6－7＝－1， b[2]＝a[2][2]－[2][1]＝11－10＝1， b[3]＝a[3][3]－[3][1]＝16－13＝3。所以主函数中打印y数组元素的值为A)选项。
【解析】字符串的输入不能使用scanf("%s"，s)；而应该使用gets(s)。
【解析】根据题目中的定义可以知道sizeof(p)，计算的是数组p中所有元素所占用的字节数，而不是char型数据所占字节数。
【解析】p是指向二维字符数组第二行OneDream！的数组指针，所以长度是10，打印输出的也是该字符串。
C
A
C
B
D
B
B
A
C
C
D
D
A
D
B
A应该是double
C应该是int
D应该是char
D
C
D
B
B
C
A
D
【解析】
选D。A中<>这个运算符C中没有。
B选项if(!a)只有当a=0时执行下面语句。
C选项是赋值表达式令a=0。
D选项if(a)表示当a不等于0时执行下面语句。
D
D
A
B
A
A
D
C
A
B
D
D
A
A
B
B
C
D
A
D
D
A
D
A
C
D
A
A
C
A
D
C
A
B
A
A
C
A
B
C
B
B
D
D
B
C
B
A
C
B
A
C
D
D
B
D
A
A
C
D
B
A
D
这段程序有两个地方是有问题的
1、一个明显的地方是else后面的printf缺少分号（增加这个明显错误主要是第2点不易发觉，很多同学长期以来被误导了）
2、void main按标准来说是错误的，正确的定义是int main，很多同学误认为如果主函数不需要返回值就可以用void，但这样是不对的，所以同学们可以发现有的编译器用void main能编译通过，有的编译器会报错，是因为这个语法不是标准的语法导致的。
C
C
C
C
B
C
B
B
D
B
C
B
D
D
B
D
C
B
C
A
D
D
B
C
C
B
B
A
B
D
C
D
D
A
D
D
解析：0是非正非负数
D
C
解释：y是float类型，且除数是浮点数形式
解释（1）：等价于（（0&&1）||0）==》0||0==》0
解释（2）：等价于（（0&&1）||1）==》0||1==》1
解释（3）：等价于（（（（1&&0）||0）&&1）||1）==》（（（0||0）&&1）||1）==》（（0&&1）||1）==》（0||1）==》1
解释（4）：等价于（1||（1&&0））==》（1||0）==》1
总结：&&优先级大于||；&&于||结合性为做到右
解析：优先级相同时，由结合性判断。负号与自减优先级相同，且它们的结合性为右到左，因此k = -m-- 等价于k = -（m--），由于自减在变量右侧，因此得到 k = -m = -1
A
若函数的形参为一维数组，则形参数组可以不指定大小。
在函数的说明和定义时若没有指出函数的类型，则系统自动地认为函数的类型为整型。
对
若调用一个函数，且此函数中没有 return 语句，则该函数返回一个不确定的值。
若使用一维数组名作函数参数，则在被调函数中，不需要考虑形参数组的大小。
在 C 语言中，形参的缺省存储类是auto
C 语言中，函数的隐含存储类别是extern
7
B
解析：
A:不一定就必须要有一条return语句，如果自定义的返回类型为空的话，那么就不需要return语句。
B：虽然在函数中遇到return 语句就会结束，但是并没有规定自定义函数中只能有一条return语句，所以B正确。
C：定义为void类型的函数就不需要return语句了。
D：错误的说法，函数的调用从main函数开始，也从main函数结束的。
解析：对宏的具体定义是：
#define 标识符 字符串
宏替换只是字符替换。
C 语言字符数组可以存放字符串。
对
若函数有返回值，必须通过 return 语句返回。
C 语言中唯一一个不能被别的函数调用的函数是main函数。
C语言中，关键字及编译预处理命令用小写字母书写。
由float x=3e-6,y=3e-6;不能得到x==y的逻辑值为真。
C
解析：八进制和十六进制数前面是不可带负号（原始数值是十进制，以10进制为运算基准）
因为十进制数是负数时，如-16、-99其二进制负号位为1 ，则将二进制转换为八进制或十六进制时负号位参与数值运算，因此算出的八进制或十六进制不含负号位。
（注：一般来说，负号是人为规定地加在十进制数上，其他进制无负号概念，因为负号在二进制最前位体现，且参与进制转换）
B
解析：在用静态static与外部extern定义变量时，系统立刻给其分配内存，而定义自动类auto与强制放入寄存器register类型变量时，只有当使用时才分配内存。
B
解析：
(3,2,1,0)是逗号表达式
3/2/1/0 将提示：被零除或对零求模
* 4*
1,3,2,3
x=0, y=5, z=2
B
D
B
（#include命令的包含文件可以带目录，并且目录的书写格式必须符合操作系统的习惯，由于它不是C语言的字符串，不能用“\\”来表示“\”）
结果为：123ok!
结果：2（注意运算符优先级高低）
C
在函数里，指针p又重新定位成num的地址空间，所以在函数中的自减是修改num的值；而当在main函数中的p指针依然指向 i 的地址空间，在func中没有被修改，那么值不变；
如果函数去掉num，如下：
void func(int *p)
{
(*p)--;
}
此时，就是修改 main函数中 i 的值了。
详细分析：
如上图，当调用函数的时候，形参指针p会指向实参指针p 所指向的地址空间；
在题目的 func 函数中，形参指针p 指向了新的地址空间num，如下图：
那么此时修改形参p 所指向地址空间的值，是不会影响 实参指针p和i 的值。
B
输入3 4后，分别赋值给了a和b,然后a的值给了s，此时a=3 b=4 s=3。If语句中由于判断条件a<b成立，所以b的值赋给了s，此时s=4，然后执行s=s*s等价于s=4*4，s的值变成了16，最后通过printf语句将s的值打印出来。
A
对于条件表达式，首先判断x<y的值为0，则将表达式y++的值作为整个条件表达式的值，y++的含义是取y的值作为条件表达式的值后，再将y的值加1.所以整个条件表达式的值就是1，而y最终值为2.
A
首先确定内层循环是用来找 1 ~ i 中偶数出现次数的.
其中1 ~ N的偶数出现次数大概如下表所示:
| N | 偶数出现次数 |
|---|---|
| 1 | 0 |
| 2 | 1 |
| 3 | 1 |
| 4 | 2 |
| 5 | 2 |
| 6 | 3 |
| 7 | 3 |
| ...... | |
| N | n/2 |
题目求1 ~ 1 + 1 ~ 2 + 1 ~ 3 + ... + 1 ~ N的偶数出现次数.
可以发现最后结果是1+1+2+2+3+3+...+n/2(还得判断n是否为偶数,为偶数只有一个n/1,为奇数有两个n/2,具体情况可看上表得知)
因为题目中n=100,为偶数,则n/2只出现一次
将式子化简为 ,则可以运用等差公式:
这时将得到的2450加上之前得到的n/2=50,即2450+50 = 2500
A
int *p[4]; //表示指针数组，有四个元素，每个元素都是整型指针。
int (*p)[4]; //表示行指针，所指对象一行有四个元素。
int *p(void); //表示函数，此函数无参，返回整型指针。
int(*P)(void) ;//表示函数指针，可以指向无参，且返回值为整型指针的函数。
D
选D。考察的是对函数的调用，涉及到调用时的实参和函数定义时的形参匹配问题。
根据题目：函数定义fun第一个参数为char类型，第二个为float数组类型。
- 选项A：“abc”属于字符串，与定义函数参数不匹配，所以A错误。
- 选项B：fun函数为void没有返回值，所以无法赋值给t；所以B错误。
- 选项C：第二个参数2.8属于double类型，float类型后面需加上f，即2.8f。因此和定义函数参数类型不匹配，所以C错误。
B
在此结构体中，所有数据类型在32位主机或者64位主机上无影响，另外#pragma pack(4)指定字节对齐为4；
数据类型 字节数 字节对齐
int 4 4
char 1 4
int 4 4
float 4 4
char 1 4
float 4 4
故sizeof的值应为24；
A
>>是位移符号。可以理解为每次除以2.
从k=2000直到k=1，共需10次位移操作
选C。考察的是宏定义编译前作替换， 在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。即：y*y+3*y表达式去置换所有的宏名M。
- 宏定义M的字符串： #define M y*y+3*y
- 表达式：s=3*M+4*M+y*M
- 替换后：s=3*y*y+3*y+4*y*y+3*y+y*y*y+3*y
定义宏没有括号，所以A、B、D错误。
选D。
本题主要考察内存中堆区域的操作函数。
1> malloc，作用是开辟一个给定字节大小的堆区域空间，并且返回该内存空间的首地址。
void *malloc(unsigned int size);因此A项正确。
2> calloc,作用是分配n个size⼤⼩的空间,并且把该内存上的所有字节清零。
void *calloc(unsigned n,unsigned size);
3> realloc,作用是按给定的地址以及给定的⼤小重新分配。
void *realloc(void *, unsigned newSize);
分配时有两种情况：
1.如果原有空间地址后面还有足够的空闲空间用来分配,则将先前空间释放,然后以先前地址为开始地址按newSize大小重新分配。因此B项正确。
2.如果原有空间地址后面没有足够的空闲空间用来分配,那么从堆中另外找一块newsize⼤小的内存,并把先前内存空间中的数据复制到新的newSize⼤小的空间中,然后将之前空间释放。因此C项正确。
4> free函数，作用是释放内存,内存释放是标记删除, 只会修改当前空间的所属状态,并不会清除空间内容。free函数并不会清除空间内容。因此D项描述错误。
综上，选D。
B
小端存储：和常用习惯一样——低地址存低位
大端存储：高地址存低位
大小端存储要以系统而定，小端的话应该是33
B
作用域为当前文件，从定义/声明位置到文件结尾。动态全局变量可以通过extern关键字在外部文件中使用，但静态全局变量不可以在外部文件中使用。静态全局变量相当于限制了动态全局变量的作用域。
A
解析：
|1Byte|1Byte|1Byte|1Byte|
| short | char | char |
| long |
| char | 填充| 填充| 填充|
| int |
共计4 * 4 = 16 Byte，选A
原因：
1. 在32位机中，
char 1字节
short 2字节
int 4字节
long 4字节
2. 数据在计算机中按“边界对齐”方式存储，支持按字寻址、按半字寻址、按字寻址，
半字地址必为2的整数倍，字地址必为4的整数倍，
所以半字长和一个字长的数据在存储时，就算前面有“空位”，为了保持地址的“一致性”，机器会对空位进行填充。
3. 比如：
|1Byte|1Byte|1Byte|1Byte|
| char | char | char | 填充 |
| short | short |
| short | 填充 |
| int |
| long |
选C。考察的是结构体以及结构体变量的初始化。（题干p1处后半括号应该改为“ } ”）
结构是 C 编程中另一种用户自定义的可用的数据类型，允许存储不同类型的数据项。
- 选项A：传统的依次初始化每一个成员，所以A正确。
- 选项B：默认初始化第一个成员name，所以B正确。
- 选项C：语法错误
- 选项D：等同于选项A，属于相同结构体下的变量之间的赋值。所以D正确。
D
C
0x开头为16进制，0xf对应的二进制数为1111。
^为异或操作，若参加运算的两个二进制位值相同则为0，否则为1；
a与0xf做异或操作，可以实现低四位的翻转。
如果是| 按位或 ，则将低四位数全变成1.
如果是& 按位与，则结果不变。
其他的位运算符号：
& 按位与 如果两个相应的二进制位都为1，则该位的结果值为1，否则为0
| 按位或 两个相应的二进制位中只要有一个为1，该位的结果值为1
^ 按位异或 若参加运算的两个二进制位值相同则为0，否则为1
~ 取反 ~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0
<< 左移 用来将一个数的各二进制位全部左移N位，右补0
>> 右移 将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0
C
C标准规定为 Implementation Defined（由实作环境决定）。
举个栗子：
arm-linux-gcc 规定 char 为 unsigned char
vc 编译器、x86上的 gcc 规定 char 为 signed char
缺省情况下，编译器默认数据为signed类型，但是char类型除外。
选B。考察的是指针的概念。
指针是一个变量，其值为另一个变量的地址，即内存位置的直接地址。
声明形式：
type *var-name; //type 是指针的基类型，var-name 是指针变量的名称
- 选项A：变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL，称为空指针
- 选项B：指针是一个用数值表示的地址，两个地址相加没有意义。所以B错误。
- 选项C：指针是一个用数值表示的地址，因此可以对指针执行算术运算，当前位置向前后移动相应的位置。
- 选项D：程序中使用指针代替数组，因为变量指针可以递增。同样地，对指针进行递减运算，即把值减去其数据类型的字节数。
C
4,3这个是逗号表达式的问题，
逗号表达式从左往右执行，最后显示最右边的那个。
即（a,b）相当于b，如果是
printf("%d,%d",(++a,++b）,(++b,++a）)；
输出为6，5
选D。
&&表示逻辑与，当运算符两边都为true，结果为true。并且还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。
- a&&b 结果为1
- c<'B' 结果为1
- 最终表达式结果为 1
B
有个定律叫德摩根律
!(A && B) == !A || !B
!(A || B) == !A && !B
D
int printf ( const char * format, ... );返回值：
正确返回输出的字符总数，错误返回负值，与此同时，输入输出流错误标志将被置值，可由指示器ferror来检查输入输出流的错误标志。
选D。该题考察的是通过scanf函数的调用对结构体数据类型进行初始化。
scanf("输入控制符", 输入参数);
功能：将从键盘输入的字符转化为“输入控制符”所规定格式的数据，然后存入以输入参数的值为地址的变量中。
- scanf输入时，要将值放到地址里，所以要加上&，所以B、C正确。
- name属于字符数组的数组名，相当于数组的首地址，所以A正确。
- pa->age属于输出语句获取值的形式，所以D错误。
B
特殊法：分别令a = 0.0; b = 0; 代入其中，循环条件不成立，返回n,即返回1，看选项，0做底数没意义，排除，A,D，C结果等于0,选B
B
D
逗号表达式值为逗号右边的值，先算括号里的x=20，括号内的逗号表达式的值为100，但整个表达式的值是20+25=45
D
print('a');//对应97，b,1
print(5,8);//对应5，退格符号，1 如果在print中输出a,b,c的话，会得到1，因为退格会删除5
print(5,'#');//对应5，#，1
print(5,'#',2);//对应5，#，2
D
题目解析：
a 为 int 型数组首地址，数组长度为 5，a + 1 表示 a[1] 的地址。
&a 可以理解为表示一个列数为 5 的 int 型二维数组的首地址，那么 &a + 1 表示列为 5 的 int 型二维数组第 1 行首地址，
然后转为 int 型指针赋值给 ptr，可以理解为 ptr 为 a[5] 的地址（可以这么理解，实际不存在 a[5]），
ptr - 1 即为 a[4] 的地址。因此正确答案为 D。
A
注意与sizeof(str)本身性质区分：此处并非是求整个str数组的大小（即答案100的误区）
p.s 数组名是首元素的大小地址：（只有两个例外）1.sizeof(数组名) - 数组名为整个地址
2. & 数组名 - 数组名表示整个数组
对于定义函数中出现以数组形式的形式参数，编译器会把它解释成相对应类型的指针（数组传参时候，会退化成指针）此处为char *，又考虑在32位系统，故其指针大小为4.
C
C语言中|是按位或的意思，a可以表示为00001000,1表示为00000001，因此b为00001001,＞＞表示右移一位，因此b为00000100，即为4
答案选择：C.-20
本题考察了#define，也就是宏定义的用法。
宏定义就是在开始代码之前声明一段代码(为了方便表示，我们记作代码①)，而在代码①后面又会有一段代码(我们记作代码②)，代码①的意思就是代码②。
为了方便理解，我们举一个例子：
#define sqr(x) (x) * (x)
这一段代码的意思是说：sqr(x)的意思就是x的平方，而以后出现的sqr(x)就都变成了(x) * (x)。
回到题目：
已知SUB(a)的意思是(a)-(a)。
变量a值为2，变量b值为3，变量c值为5。
变量d的值为SUB(a+b)*c，将SUB(a+b)的意思代入得到：。
分别将a=2、b=3、c=5代入得：
故答案为:C.-20
B
x+=x-=x-x c++primer中提及过+= -= 是一个操作
x(+=)x(-=)x-x;
从右往左看
x(+=)x(-=)0
x+=x
2x = 20
答案：C
解析：A中ftell() 函数用于得到文件位置指针当前位置相对于文件首的偏移字节数；
B中fseek()函数用于设置文件指针的位置；
C中rewind()函数用于将文件内部的位置指针重新指向一个流(数据流/文件)的开头；
D中ferror()函数可以用于检查调用输入输出函数时出现的错误。
A
&&左边是0 则不运行右边的
A
后缀++ 和-- 操作符本质上比前缀一目操作的优先级高, 因此*p++ 和*(p++) 等价, 它自增p 并返回p 自增之前所指向的值。
要自增p 指向的值, 使用(*p)++, 如果副作用的顺序无关紧要也可以使用++*p。
D
逗号运算级别很低，int i = (j=4,k=8,l=16,m=32) ，加了括号就是取最后一个值，所以i=32；如果没加加括号就该是i=4.
C
a:头文件
b字符串函数
c数学函数
d字符函数
【解释】if语句中的表达式不局限于哪种类型的表达式，只要表达式非零时，表达式
的值就为真，否则就是假，所以正确答案是D。
B
输出结果为：6 5 4 4
对字符串进行sizeof操作的时候，会把字符串的结束符"\0"计算进去的，进行strlen操作求字符串的长度的时候，不计算\0的。
数组作为函数参数传递的时候，已经退化为指针了，Func函数的参数str_arg只是表示一个指针，那个100不起任何作用的。
C
我们说，所有的成员在分配内存时都要与所有成员中占内存最多的数据类型所占内存空间的字节数对齐。假如这个字节数为 N，那么对齐的原则是：理论上所有成员在分配内存时都是紧接在前一个变量后面依次填充的，但是如果是“以 N 对齐”为原则，那么，如果一行中剩下的空间不足以填充某成员变量，即剩下的空间小于某成员变量的数据类型所占的字节数，则该成员变量在分配内存时另起一行分配。
下面再来举一个例子，大家觉得下面这个结构体变量data占多少字节？
struct STUDENT
{
char a;
char b;
char c;
char d;
char e;
int f;
}data;
首先最长的数据类型占 4 字节，所以是以 4 对齐。然后 a 占 1 字节，b 接在 a 后面占 1 字节，c 接在 b 后面占 1 字节，d 接在 c 后面占 1 字节，此时满 4 字节了，e 再来就要另起一行。f 想紧接着 e 后面分配，但 e 后面还剩 3 字节，小于 int 类型的 4 字节，所以 f 另起一行。即该结构体变量分配内存时如下：
选C。
根据题干void f4(int **p); f4的参数为指向指针的指针，即p为一个指针的地址。指向指针的指针是一种多级间接寻址的形式。
- 选项A f4(a)，参数为一维数组名，即首元素的地址&a[0]。
- 选项B f4(b)，参数为二维数组名，及首元素的地址。
- 选项C f4(q)，参数q为一个指针数组，元素为int类型的指针，数组名为首元素b[0]的地址。
- 选项D f4(&a)，参数转化为&a[0]。等同于选项A。
选C。该题考察的是指针和二维数组的关系。
数组名 b 在表达式中也会被转换为指针。
- A选项b[i][j]：通过下标的方式，所以A正确。
- B选项*(b[i]+j) ：b[i]相当于二维数组的i行,加上j，就相当于i行j列，然后取地址。所以B正确。
- C选项*(*b+i)+j：数组名b相当于指针，*b+i为b[0][i]，取地址加j相当于b[j][i]。所以C错误。
- D选项(*(b+i))[j]：b+i为第i行地址，在使用*表示第i行首元素内容合并[j]下标，即b[i][j]，所以D正确。
D
strlen 是函数，sizeof 是运算符。
strlen 测量的是字符的实际长度，以'\0' 结束，也就是说不算最后的'\0';
而sizeof 测量的是字符的分配大小,包括最后的'\0';
帮助记忆的话，可以理解成运算符更加底层一下，会输出真实的内存占用情况，而函数有封装，会处理成用户想要看到的内容。
【解释】表达式x>=y&&ch<’B’&&!y等价于(x>=y)&&(ch<’B’)&&(!y)，(x>=y)
的值为真，（ch<'B’)的值也为真（因’A'<’B’），而y=0，所以(!y)的值也为真，所以整个表
达式的值为真，即为1.正确答案为C。
选A。
ASCII 码使用指定的7 位或8 位二进制数组合来表示128 或256 种可能的字符。
- BCD码（Binary-Coded Decimal）亦称二进码十进数或二-十进制代码。用4位二进制数来表示1位十进制数中的0~9这10个数码。是一种二进制的数字编码形式。
- 内码是指汉字系统中使用的二进制字符编码。
- 十进制码面向的是开发人员，经过转化对应的编码给计算机使用。
x=4
从上往下 首先执行!a那一行 x变为34
因为!a执行 所以else if不执行
再往下 if(c) 不执行 执行else x=4 所以最后x=4
条件判断里 如果是0则代表false 如果非0则代表true
【解释】a是数组名，是一地址常量，++a是非法的，所以答案B错误；因为数组a的
大小为11，执行strcpy(a,st);，st字符串的结尾符’\0’无法存放到数组a中，所以答案C也是
错误的；答案D中定义数组a时未指定大小，所以也是错误的；对于答案A来说，执行strcpy
(p=a+1,&st[4]);，首先将数组a的第二个元素a[1]的地址赋给指针变量p，然后将st第5个
元素开始直到字符串结束为止的字符复制到p所指向的内存单元中，所以选择答案是A。
B
由这个for循环循环n次，且在满足条件时才输出i,可知，输出m个不同值的要求已满足，因为每次输出的都是i值，而i值每次都是不一样的，m--保证了程序在输出了m个值后就停止循环。
在i=0时，rand()%(n-i)的取值范围为0到n-1，共n个数，此时要输出0只需要rand()%(n-i)小于m，故i=0被输出的概率为m/n;
在i=1时，rand()%(n-i)的取值范围为0到n-2，共n-1个数，若i=0没有被输出，则m--未被执行，此时i=1被输出的概率为m/(n-1)，若i=0已经被输出了，则m变为m-1，此时i=1被输出的概率为(m-1)/(n-1)；由概率论的知识，可知此时i=1被输出的概率为
P=(1-m/n)*(m/(n-1))+m/n*((m-1)/(n-1))=m/n；以此类推，可知每个数被输出的概率都为m/n
D
题目解析：
struct {
char type; ===>占一个字节
int num; ===>占四个字节，但考虑字节对齐，int num不会紧跟着type，对齐的最终结果是char type和int num共占8字节
char name[10]; ===>虽然数组个数是10个，占10个字节，但考虑字节对齐，最后回对齐到12字节，所以该结构体总占字节为8+12 = 20
} rec;
B
C语言中，字符串默认每个占用1字节，末尾还有'\0'，所以一共是4字节
B
C中在预处理阶段：展开头文件、宏替换、条件编译、去掉注释。到编译阶段时是没有注释的。
选B。
tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。
struct tag {
member-list
member-list
member-list
...
} variable-list ;
结构类型无法将自己的类型作为其成员的类型，因为自己的类型定义尚不完整，要在结束的大括号（}）后才算定义完整。所以A正确。
基于内存的对齐原则，一个结构体变量定义完之后，其在内存中的存储并不等于其所包含元素的宽度之和。从结构体存储的首地址开始，每一个元素放置到内存中时，它都会认为内存是以它自己的大小来划分的，因此元素放置的位置一定会在自己宽度的整数倍上开始（以结构体变量首地址为0计算），所以B错误。
结构类型和其他基本类型或数组类型类似的用法，可以定义在函数之中或函数之外。所以C、D正确。
C
字符集为每个字符分配了唯一的编号，每个字符除了用它本身的实体表示外，还可以用转义字符来表示
转义字符以\开始，如果是\x(注意是小写，C语言是区分大小写的)开头，后面接16进制数，如果以\开头，后面接八进制数。
转移字符表示的数据范围有限，因此对\x开头的 ，只能是\xxx(后面两位表数据)这种格式的，意思是只能接两位数据,最大值为\x7f
对\开头的，后面可以接三位数据，即\xxx(后三位均为数)，最大值为\177
另外，还有其他几个常见的转义字符，
\t ,\n,\a,\b,\r,\f,\v
D
题目解析：
f 就是一个函数指针，所指向的函数接收两个 int 指针作为参数，返回值为空。
函数指针是void(*f)()() 指针函数是返回类型为指针的函数(void*)f()()
D
1.main函数里的s没有初始化就在fun函数里使用s，编译器会报警告，运行时会报错（局部变量未初始化）。答案选D。
2.就算s初始化了，在fun函数里，局部变量t的大小为7，而strcpy函数会复制example末尾的\0
所以example+'\0'一共8个字节空间，会溢出，程序会崩溃。
3.就算局部变量t的大小足够大，在fun函数运行结束后，局部变量t的内存空间会被释放掉，此时s成为野指针；返回main函数后，也不会输出example。
对于栈中内存如果没有初始化，则会出现“烫烫烫烫烫烫”。对于堆中内存如果没有初始化，则会出现“屯屯屯屯屯”
D
题目解析：
数组中 [ 里面数不能超过或等于最大 ] 如 D 、 a[0][4] ，其中 4 已经等于或超出
A
&&逻辑与运算，先执行n=b<a，得n=0，赋值表达式的返回值为赋值符号右边的值，即0，逻辑与运算结束，不执行m=a。m未被赋值，仍为0。
C
str还是指向NULL，并未给str分配空间，所以执行时会出现段错误。
C
1.指针和void*可以相互转化
2.指针大小和系统位数有关，16位系统是2个字节，32位系统是个4字节，64位系统是8个字节
3.指针有安全隐患
B
\40是八进制 换算成二进制就是32 也就是空格
D
题目解析：
本题采用了递归的方式，其递归过程：Fun（2） = 2 * Fun（2 + 1） = 2 * （2 * Fun（3 + 1）） = 2 * 2 * 2 * Fun（4 + 1） = 2 * 2 * 2 * 2 = 16，因此本题正确选项是D
D
题目解析：
32 位机器上int为 4 字节、char 为 1 字节、float 为 4 字节。union 大小为 union 内最大元素的字节数。
D
浮点数的存储:图片说明
S(1bit)符号位
E(8bit)指数位（-127~128）
M(23bit)有效数字 (1<= M <2)
float的值为(-1)^S*M*2^E
C
当解析器遇到了||时，只要前面的++x为真，后面的语句就不执行了
A：数组指针
B：指针数组
C：强制类型转换
D：定义错误
所以选A
【解释】for循环常用于循环次数已知的循环中，但也可以用于循环次数未知的循环
中;for循环是先判断表达式，根据表达式的值来决定是否循环：在for循环中如果要中
途退出循环，可以使用brcak语句来实现。所以A、B、C都是错误的，正确答案是D。
C
题目解析：
C++ 如果将整型值作为 if 的判断条件，那么 0 为假，非 0 为真。
因此题目中当 j 为 0、2、4 时， j%2 为 0 ，执行 sum++，因此 sum 最后值为 3。
D
x = 500时，x-1=499，用二进制表示
111110100
x-1为
111110011
当他们执行&运算并赋值给x，结果x为
111110000
x-1
111101111
x
111100000
如此类推到结果为000000000，应该发现x = x&(x-1)就是将x二进制位1变为0。x为500时二进制为1的位有6个，所以结果为6
C
'a'是个常数，不能赋值
D
[解析]
A，正确，#define定义的宏是在预处理阶段进行替换的，const常量是在编译、运行阶段进行使用的。
注意是仅仅的字符串替换，并不会检查其合法性。
预处理阶段做了的任务：
1:将头文件中的内容(源文件之外的文件)插入到源文件中
2:进行了宏替换的过程（简单的字符串替换），定义和替换了由#define指令定义的符号
3:删除掉注释的过程，注释是不会带入到编译阶段
4:条件编译
B，正确，所有的宏替换只是简单的字符串替换，注意是字符串替换，所以并不会检查其合法性，而const定义的常量依然是内置类型等，所以会对其进行类型安全检查。
C，正确，宏定义在程序中使用了几次在预处理阶段就会被展开几次，并不会增加内存占用，但是宏定义每展开一次，代码的长度就要发生变化（所以有利必有弊啊！），而const常量也会为其分配内存（如果是动态申请空间肯定就是堆中了）。
D，错误，const定义的常量只有一次拷贝没毛病，而define定义的变量在内存中并没有拷贝，因为所有的预处理指令都在预处理时进行了替换。
A
1.void fun(int x, int *y){*x *= *y;}
解析：x为整形，不是指针，所以用*取值错误。
2.void fun(int *x, int y){*x += y;}
解析：x为int型指针，*对x地址取值后 *x = *x+y，表达式正确；
3.int * fun(int *x, int y){return x += y;}
解析：fun返回值为int指针， return x += y可以转化为 地址位移y个int大小，将位移后的值再付给x， x作为函数返回。故正确
4.void fun(int x, int *y){x *= *y;}
解析：x*=*y；-> x=x*(*y); 因为y是int指针，*取值和int相乘，表达式正确；
故题1错误。
B
----------------------
int t;
t=*a;*a=*b;*b=t;
----------------------
----------------------
double y=1;
int i;
for(i=1; i<=m; i++)
{y+=1.0/(2*i+1); }
return(y);
----------------------
----------------------
int i,j,k=0;
for(i=0;i<N;i++)
for(j=N-1-i;j<N;j++)
k=k+a[i][j];
return(k);
----------------------
----------------------
int sum;
int i,j;
sum=1;
for(i=0;i<3;i++)
sum=sum*a[i][i];
return sum;
----------------------
----------------------
int n=0;
int i,j;
for(i=2;i<=lim;i++)
{for(j=2;j<i;j++)
if(i%j==0) break;
if(j==i) aa[n++]=i;
}
return n;
----------------------
----------------------
int i;
float y=0;
for(i=0;i<n;i++)
y+=a[i];
y=y/n;
return y;
----------------------
----------------------
int n=0;int i=1;
while(w>10)
{n=n+i*(w%10);
w/=10;
i*=10;}
return n;
----------------------
----------------------
int k,s=0;
do
{s=s+m%10;
m=m/10;
}while(m!=0);
if(s%7==0)k=1;
else k=0;
return(k);
----------------------
----------------------
float s=0;
int i;
for(i=1;i<=n;i=i+2)
s=s+i*i;
return(s);
----------------------
----------------------
int i,k,s=0;
for(i=2;i<=m;i++)
{for(k=2;k<i;k++)
if(i%k==0)break;
if(k==i)s=s+i;
}
return s;
----------------------
----------------------
int max,i,j;
max=array [0][0];
Row=0;
Col=0;
for(i=0;i<N;i++)
{for(j=0;j<M;j++)
if(max<array [i][j])
{max=array [i][j];
Row=i;
Col=j;}
}
return(max);
----------------------
----------------------
int d,k,s=0;
while (n>0)
{d=n%10;
s+=d*d*d;
n/=10;
}
return s;
----------------------
----------------------
int i,amax=-1;
for(i=0;i<n;i++)
if(a[i]%2==0)
if (a[i]>amax) amax=a[i];
return amax;
----------------------
----------------------
int i,k=1;
if(m<=1) k=0;
for(i=2;i<m;i++)
if(m%i==0) k=0;
return k;
----------------------
分析：C语言是介于汇编语言和高级语言之间的一种语言，由于它可以直接访问物理地址，对硬件操作，所以C语言既可以编写应用程序，又可以开发系统软件，而且C程序可移植性好于汇编语言，程序清晰具有模块化的特点。本题正确答案为C。
分析：C语言有32个关键字(或称保留字)，它们都有特定的含意，并且由小写字母组成，所以选项A是错的，选项B不是保留字，选项D是return的错误拼写。本题正确答案为C。
分析：标识符规定只能由26个英文字母（大小写均可），数字0~9和下划线组成，且不能以数字开头，题中的3cd不符合规定。
本题正确答案为C。
【答案】A
【解析】A项是赋值表达式和算术表达式的结合，符合C语言语法；B项中，’%’是模运算符，要求运算符两侧均为整数，x为double，显然错误；C项是赋值表达式，要求赋值运算符的左侧是变量，3=2部分显然错误；D项，强制类型转换运算符使用错误，应为y=（float）i
【答案】C
【解析】char *s ="abcde"，声明s是一个字符串指针，并且将字符数组"abcde"的首地址赋值给了s，s+=2，即是在原来的s地址上向前推进两个字节，又因为数组是在连续空间上存储的一组数据，且一个字符占一个字节，那么也就等价于由数组的第一个字节地址推进到第三个字符的地址，即字符c的地址。答案为c
【答案】C
【解析】赋值运算符是自右向左运算的。A项是将a的值赋给了b，又将b的值赋给了a，与题意不符；B项和C项都是逻辑运算，且都自左向右运算，它们的区别是：或运算是先计算左边表达式的值，若为真，则结束运算，若为假，继续计算右边表达式,所以，如果a=c为真（只需要a>0），那么b=c语句不会执行，即不能完成c给b的赋值；与运算则是两边的表达式都要计算，所以，a=c和b=c都能得到执行，C为正确答案；D项是将b的值赋给了c和a
【答案】B
【解析】表达式x--&++y中，逻辑运算符‘&’的优先级最低，应该先计算它两边的表达式。x-- ：x参与逻辑运算后，x的值再自减1，那么x—参与逻辑表达式的值为1；++y：y自增1后再参与逻辑运算，那么++y参与逻辑表达式的值为-1+1=0。x--&++y即为1&0，值为0，答案为B。
【答案】A
【解析】字符是以ASCII码的形式存储的，表达式’A’+’6’-’3’的运算实际就是对应ASCII码的算数运算，加减运算是同一优先级的，所以’A’+’6’-’3’=65+54-51=68，即D的ASCII的值。此处定义c2是字符型，所以，c2的值是D；如果c2定义为整型，则c2的值是68。
分析：题目中"/"、"*"、"！"的运算对象既可以整数，也可以是实数，只有取余数运算符"%"要求运算对象必须是整数。本题正确答案为C。
分析：赋值号左端不能为表达式，选项A)是错的；赋值号不能将字符串赋给某个变量，选项B)也是错的；增量运算符“++”不能用于表达式，选项C)也是错的。本题正确答案为D。
分析：不同类型数据混合运算的转换规律是：运算前float型数据会自动转换为double型，char型数据会自动转换为int型。运算时int型数据和double型数据要先化为相同类型，即double型，运算结果也为double型。本题正确答案为C。
【答案】：B
【解析】：scanf函数称为格式输入函数，即按用户指定的格式从键盘上把数据输入到指定的变量之中。scanf函数的一般形式为：
scanf(“格式控制字符串”，地址表列);
地址是由地址运算符“&”后跟变量名组成的，故选B。
【答案】：A
【解析】：B的错误在于赋值语句的左侧只能为一个简单变量，如：n=3*(n=18); C的错误在于%运算符只能适用于整型数据，D的错误在于作类型转换时，应将类型加上括号，即为：y=(float)m
【答案】：D
【解析】：A getchar（）输入单个字符，但这样不能满足U,V,W之间的空格，C同样不能输出空格，只有D满足条件满足scanf格式输入函数，而且又可以满足题意。
B
C
D
C语言的运算符包括单目运算符、双目运算符、三目运算符，优先级如下：
第1优先级：各种括号，如()、[]等、成员运算符 . ；
第2优先级：所有单目运算符，如++、–、!、~等；
第3优先级：乘法运算符*、除法运算符/、求余运算符%；
第4优先级：加法运算符+、减法运算符-；
第5优先级：移位运算符<<、>>；
第6优先级：大于运算符>、大于等于运算符>=、小于运算符<、小于等于运算符<=；
第7优先级：等于运算符==、不等于运算符!=；
第8优先级：按位与运算符&；
第9优先级：按位异或运算符^；
第10优先级：按位或运算符|；
第11优先级：逻辑与运算符&&；
第12优先级：逻辑或运算符||；
第13优先级：三目条件运算符 ?: ；
第14优先级：各种赋值运算符，如=、+=、-=、*=、/= 等；
第15优先级：逗号运算, 。
分析：多重if_else嵌套时，else总是与它上面最近的并且未配对过的if配对。
本题正确答案为B。
分析：选项C)中的第一个printf语句后面丢了分号，所以是错误的。
本题正确答案为C。
分析：因为条件表达式e1？e2：e3的含义是e1为真时，取表达式e2的值，否则取表达式e3的值，"为真"的意思就是不等于0。
本题正确答案为C。
【答案】C
【答案】A switch后面的表达式不能为浮点型表达式，一般为整型或字符型，B,Dswitch后面有；不满足switch的规则，只有C,default可以在case前也可以在其后，故选C。
C
【答案】D
【解析】do…while结构的循环：第一次循环，b=b-a=9;a=a+1=2;条件b--<0不成立(先进行逻辑运算，再自减得b值为8)，结束循环；b的值为8，选D
【答案】B
【解析】for循环初值，j=10，进行第一次循环：j%3=1，if语句为真，j自减为9，之后两次自减，j值变为7，打印输出，得第一次输出为7，第一次循环结束；j再一次自减，值为6，j满足for循环条件j>3，继续第二次循环，6%3=0，if语句为假，之后两次自减，j值变为4，打印输出，得第二次输出为4，第二次循环结束；j再一次自减，值为3，循环条件j>3不再满足，循环结束。答案为B
【答案】C
【解析】i=1，此时比较的仍是i=1，此时i=1<4，判断成立，进行下次循环，并且i执行一次加1得2
i=2，此时比较的仍是i=2，此时i=2<4，判断成立，进行下次循环，并且i执行一次加1得3
i=3，此时比较的仍是i=3，此时i=3<4，判断成立，进行下次循环，并且i执行一次加1得4
i=4，此时比较的仍是i=4，此时i=4=4，判断不成立，不进行下次循环，但i执行一次加1得5
C
D
D
D
D
D
C
注：但定义数组时，其数组下标的数据类型必须是整型常量，不能是变量、表达式或其它的数据类型
B
B
解析：对数组的引用要注意两个问题，一是变量名代表变量的首地址，这里要考虑地址偏移的问题，二是下标的问题，下标不能越界，B的表示不妥，A的下标越界，int a[10]定义10个整型数组，数组名为a，数组的每个元素分别是a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]和a[9]，显然a[10]超过了界限，指到了第10个元素以后的其他元素；C中的a[9]=10，形式就是a[10]，下标越界，D中a[4]=4，4+4=8，实际上就是a[8]。答案：D
解析：选择式D中a+i，a代表首地址， i代表偏移量，这里的偏移量随变量的数据类型的不同而不同，char i的偏移量为1，int i 的偏移量为2，float i的偏移量为4，double i的偏移量为8，所以在计算地址的时候除了要考虑首地址和第几个元素外，还要考虑所声明的变量类型，选择式B中共要循环6次，而double a[5]只声明了5个元素，所以出错。
答案：C
解析：对于下标的要求，一是不能越界，二是只能是常量表达式，三是首地址从0开始，结束n-1，答案A、D正确；对于数组的初始化，有两种情况，即全部赋值或部分赋值，对于全部赋值的情况，可以不必指明数组元素的个数，答案C正确；选择式B中2N+2的2N不合法。
答案：B
解析：字符串在存储的时候，除了要存放数组元素外，还必须有一个空间来存放结构元素标记\0,char所声明的变量是字符类型数据，偏移量为1，共10个字符，另外加上1个\0。
答案：C
A
B
形参不能是表达式
A
A
A
B
D
B
C
答案：A
注解：该函数调用语句中，含有的实参分别是rec1，rec2+rec3表达式计算后的值和（rec4，rec5）逗号表达式计算后值。
【答案】D。
【解析】：本题考查字符数组的赋值。C语言中不允许通过赋值语句给字符数组赋值，所以选项A、B、C都不对！
【答案】：A
【解析】： 除了给指针变量赋地址值外，还可以给指针变量赋NULL值，由于NULL的代码值为0，所以，指针变量名=NULL；等同于变量名=′＼0′；或变量名=0；，指针变量并不是指向一个地址为0的存储单元，而是具有一个空值。注意：指针变量赋地址值的方式可以是通过求地址运算获得地址值、通过指针变量获得和通过标准函数获得地址值。
【答案】：B
【解析】：因为s是数组名，只代表数组的首地址，数组名也被成为指针变量，其值是不可改变的。所以不能给s赋其他值。
【答案】：D
【解析】：所谓指针是一种特殊的变量，它存放的是另一个简单变量、数组等的地址。由计算机组成原理可知，内存的每一个存储单元都对应一个地址，CPU正是通过这个地址来访问每个存储单元的。而变量名最终仍要翻译成地址，才能找到所对应的真正的存储单元，进行读/写操作。当定义了一个指针后，对这个指针变量进行使用时，可以简单的理解为：加*后，对应一个数（变量值），不加*，对应一个地址。所以：当由如下定义：
int a, *p, *q, b;
可以进行如下的赋值操作，类型才能兼容。如：
p=&a; q=p; *q=5; q=&b; a=b; b=*p;
本题中，x为简单变量，p为指向一个变量的指针，类型不兼容。应为：q=&x;
【答案】：C
【解析】：A.不等价的原因在于后一组语句“char *s; *s="girl";”， 其中s是指针变量，在引用一个指针变量之前，应对其赋一个初值，即将一个字符串的地址赋给它。指针变量前不加“*”，代表地址；加“*”代表该地址对应的字符，本题中“*s="girl"”语句的目的是给该指针赋初值（地址），故应该去掉s前的“*”,两组语句方等价。B.的错误在于后一组语句“char s[10]; s[10]={"girl"};”数组可以在定义的同时赋初值，或者通过strcpy函数赋值，但绝对不可以使用赋值语句赋值。D.的错误在于后一组语句“char s[4]=t[4]="boy";”，C语言规定在对多个变量赋以同一个值时，不可以使用连等的方式，必须分别赋值。
B
B
B
题目解析：A中因为p存放的是内存的地址，&a表示的是地址的地址，C中因为数组a表示的是常量地址，常量地址是不能赋值的。D错在*p2=a，*p2表示的是内存地址中的值，而a是常量地址，类型不匹配
B
C
【答案】A
【解析】在位运算中，左移运算符（<<）的优先级高于按位异或运算符（^），所以先进行b<<2运算。B的值是6，左移两位就等于乘4，所以b<<2的值是24；然后进行异或运算，异或运算的规则是：参与运算的两个数中相对应的二进制位上，若数相同，则该位的结果为0；数不同，则该位的结果为1。经过异或后的值为11011。所以选项A是正确的。
#include<stdio.h>
main()
{
FILE *fp;
char ch;
if((fp=fopen("d:\\example\\c1.txt","rt"))==NULL)
{
printf("\nCannot open file strike any key exit!");
getch();
exit(1);
}
ch=fgetc(fp);
while(ch!=EOF)
{
putchar(ch);
ch=fgetc(fp);
}
fclose(fp);
}
【解析】本例程序的功能是从文件中逐个读取字符，在屏幕上显示。程序定义了文件指针fp,以读文本文件方式打开文件“d:\\example\\c1.txt”，并使fp指向该文件。如打开文件出错，给出提示并退出程序。程序第12行先读出一个字符，然后进入循环，只要读出的字符不是文件结束标志(每个文件末有一结束标志EOF)就把该字符显示在屏幕上，再读入下一字符。每读一次，文件内部的位置指针向后移动一个字符，文件结束时，该指针指向EOF。执行本程序将显示整个文件。
#include<stdio.h>
main()
{
FILE *fp;
char ch;
if((fp=fopen("d:\\example\\string","wt+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("input a string:\n");
ch=getchar();
while (ch!='\n')
{
fputc(ch,fp);
ch=getchar();
}
rewind(fp);
ch=fgetc(fp);
while(ch!=EOF)
{
putchar(ch);
ch=fgetc(fp);
}
printf("\n");
fclose(fp);
}
【解析】程序中第6行以读写文本文件方式打开文件string。程序第13行从键盘读入一个字符后进入循环，当读入字符不为回车符时，则把该字符写入文件之中，然后继续从键盘读入下一字符。每输入一个字符，文件内部位置指针向后移动一个字节。写入完毕，该指针已指向文件末。如要把文件从头读出，须把指针移向文件头，程序第19行rewind函数用于把fp所指文件的内部位置指针移到文件头。第20至25行用于读出文件中的一行内容。
#include<stdio.h>
main(int argc,char *argv[])
{
FILE *fp1,*fp2;
char ch;
if(argc==1)
{
printf("have not enter file name strike any key exit");
getch();
exit(0);
}
if((fp1=fopen(argv[1],"rt"))==NULL)
{
printf("Cannot open %s\n",argv[1]);
getch();
exit(1);
}
if(argc==2) fp2=stdout;
else if((fp2=fopen(argv[2],"wt+"))==NULL)
{
printf("Cannot open %s\n",argv[1]);
getch();
exit(1);
}
while((ch=fgetc(fp1))!=EOF)
fputc(ch,fp2);
fclose(fp1);
fclose(fp2);
}
【解析】本程序为带参的main函数。程序中定义了两个文件指针fp1和fp2，分别指向命令行参数中给出的文件。如命令行参数中没有给出文件名，则给出提示信息。程序第18行表示如果只给出一个文件名，则使fp2指向标准输出文件(即显示器)。程序第25行至28行用循环语句逐个读出文件1中的字符再送到文件2中。再次运行时，给出了一个文件名，故输出给标准输出文件stdout，即在显示器上显示文件内容。第三次运行，给出了二个文件名，因此把string中的内容读出，写入到OK之中。
#include<stdio.h>
main()
{
FILE *fp;
char str[11];
if((fp=fopen("d:\\jrzh\\example\\string","rt"))==NULL)
{
printf("\nCannot open file strike any key exit!");
getch();
exit(1);
}
fgets(str,11,fp);
printf("\n%s\n",str);
fclose(fp);
}
【解析】本例定义了一个字符数组str共11个字节，在以读文本文件方式打开文件string后，从中读出10个字符送入str数组，在数组最后一个单元内将加上'\0'，然后在屏幕上显示输出str数组。输出的十个字符正是例13.1程序的前十个字符。
对fgets函数有两点说明：
在读出n-1个字符之前，如遇到了换行符或EOF，则读出结束。
fgets函数也有返回值，其返回值是字符数组的首地址。
#include<stdio.h>
struct stu
{
char name[10];
int num;
int age;
char addr[15];
}boya[2],boyb[2],*pp,*qq;
main()
{
FILE *fp;
char ch;
int i;
pp=boya;
qq=boyb;
if((fp=fopen("d:\\jrzh\\example\\stu_list","wb+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("\ninput data\n");
for(i=0;i<2;i++,pp++)
scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);
pp=boya;
fwrite(pp,sizeof(struct stu),2,fp);
rewind(fp);
fread(qq,sizeof(struct stu),2,fp);
printf("\n\nname\tnumber age addr\n");
for(i=0;i<2;i++,qq++)
printf("%s\t%5d%7d %s\n",qq->name,qq->num,qq->age,qq->addr);
fclose(fp);
}
【解析】本例程序定义了一个结构stu,说明了两个结构数组boya和boyb以及两个结构指针变量pp和qq。pp指向boya,qq指向boyb。程序第16行以读写方式打开二进制文件“stu_list”，输入二个学生数据之后，写入该文件中，然后把文件内部位置指针移到文件首，读出两块学生数据后，在屏幕上显示。
正确答案：B
本题考点：运算符的优先级
知识点1：优先级顺序
基本的优先级需要记住：
！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符
知识点2：运算符种类
算术运算符： + - * / % ···
关系运算符(6个)： == != > >= < <=
赋值运算符： = += -= *= /= %= ···
逻辑运算符：&& ||
正确答案：C
解题步骤
x=43，ch='A’,y=0； ( x>=y && ch<’B’ && !y )
面对不同优先级的运算符：
按照运算符的优先级：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符
step1. 计算 !y 为真
step2. 此时按优先级计算关系运算符 x>=y 和 ch<‘B’ 皆为真
step3. 此时计算逻辑运算符 ||，由于存在两个||，优先级相同，此时按照结合性进行运算（左结合）
step4. 从左向右进行计算
（x>=y) && (ch<'B') && (!y)
计算顺序: ------> -----> ------>
真&&真&&真————>1
正确答案：7
解题步骤
int sum = pad = 5;
pAd = ++sum, pAd++, ++pad;
逗号运算符的结合性是左结合，从左向右计算后，分别得到：
step1.计算 pAd = ++sum ，得到 pAd = 6 ； sum = 6
step2.计算 pAd++ ，得到 pAd = 7；
step3.计算 ++pad， 得到 pad = 6；
逗号运算的最终结果：最后一个表达式的值，即 ++pad 的值，为6
但由于本题逗号运算过程中，没有用到括号，因此逗号运算得到的最终结果没有赋值给pAd
所以pAd的值应当为 step2 中计算所得，pAd = 7
6
逗号运算+括号模型 ：将逗号运算的最终结果赋值给了pAd，逗号运算的结果取决于逗号连接的最后一个表达式的值，即将++pad的值赋值给了pAd。
正确答案：B
解题步骤
根据运算符的优先级判断：! > 算术运算符 > 关系运算符 > && > || > 赋值运算符
step1.算术运算符‘*’优先级最高，先进行乘法运算 x*x = 36
step2.由于 += 与 -= 都是赋值运算符，因此依据结合性，从右向左计算
step3.先计算 x -= x * x ：
x = x - x * x ;
x = 6 - 6 * 6 = -30;
此时x被赋值为 -30
step4.此时再计算 x += x
x += x;
x = x + x;
由于step3中计算出来最新的x值为-30，因此最后计算结果如下：
x = -30 + -30 =-60
正确答案：C
解题步骤
int z, x = 5, y = -10, a = 4, b = 2;
z = x++ - --y * b / a;
step1.首先计算自增自减运算符，先计算 x++ 和 --y。
x++ ：先使用x再对x进行++ ——>5
--y ：先对y--再使用y的值 ——>-11
step2. “ * ”、“ / ”位于优先级第三级，“ - ” 位于优先级第四级，所以先进行乘除运算，算术运算符采取左结合，因此自左向右计算。
--y * b / a;
-11 * 2 / 4; -22/4 == -5.5
但是由于采用“ / "，所以会趋零截断得到 -5
（--y * b / a ）== -5
step3.最后计算 “ - ”，采用左结合，自左向右计算。
先对x进行减法运算，再对x进行++
z = x++ - (--y * b / a);
z = 5 -（-5）= 10
计算完z = 10后，再对x进行++，最后x的值为6
正确答案：正确
解题步骤
step1.判断优先级：（）是一级优先级；！与 ++ 是二级优先级
step2.先计算括号内（ c > j ) 为真 ——> 1
step3.计算 ！与 ++ ：
(c > j)为真——>! (c > j)为假——>0 ;
step4. &&具有短路特性，左操作数为假，不会再计算右操作数，即此时
j = !(c > j)&&(不计算i++）；
j = 0；
i不进行++，因此i仍等于1
BC
解题步骤
优先级顺序：! > 算术运算符 > 关系运算符 > && > || > 赋值运算符
A. a=a+b=b++
对于选项A，我们先按优先级计算 ++ ，然后计算 + ，最后计算赋值运算符 =
但当我们计算完 + 后，发现这时 a+b = b++ 出现错误
B. w%(int)(a+b)
对于选项B，先对()进行运算，即计算(a+b)的值，再强制转换为int型，最后进行取余运算
C. (c+w)%(int)a
对于选项C，先对括号进行运算，即计算（c+w）的值 ；同时进行对a强制转换为int型
最后进行取余运算
D. w=a==b;
对于选项D，D的最后有“；”，D是语句不是表达式
如果D是表达式的话，它先进行关系运算符 == 的计算，判断 a与b的值是否相等，相等返回1，不同返回0
然后将判断后的返回值赋值给w
3
编译器的贪心法
什么是编译器的贪心？
编译器将程序分解成符号的方法是，从左到右一个字符一个字符地读入，如果该字符可能组成一个符号，那么再读入下一个字符，判断已经读入的两个字符组成的字符串是否可能是一个符号的组成部分；如果可能，继续读入下一个字符，重复上述判断，直到读入的字符组成的字符串已不再可能组成一个有意义的符号。这个处理策略有时被称为“贪心法”。当然，这与算法中的贪心法不同。
#include<stdio.h>
int main()
{
int i = 1, j = 2;
printf("%d", i+++j);//+++之间没有空格,编译器读到+后，贪心往后多读一位，读成i++
}//结果输出3
#include<stdio.h>
int main()
{
int i = 1, j = 2;
printf("%d", i+ ++j);//+++有空格,编译器读到+后，贪心多读一位，没有读到多余符号，单纯加号
}//结果输出4
解题步骤
例如我们需要交换 a 和 b 的值
第一步：a = a ^ b; b保持不变
第二步：b = a ^ b;//这时b = a ^ b ^ b = a ^ 0 = a, 此时a的值赋值给了b
第三步：a = a ^ b;//这时a = a ^ b ^ a = b ^ 0 = b, 此时b的值赋值给了a
具体程序实现如下：
int main()
{
int a = 3;
int b = 5;
printf("交换前：a=%d b=%d\n", a, b);
a = a ^ b;
b = a ^ b;//a^b^b=a
a = a ^ b;//a^b^a=b
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}
解题细节：
1.如果该整数与1相&的结果为1，说明二进制位有一个1，但是这仅比较了该整数的最后一位
2.将该整数右移1位，然后继续与1相&，如果结果为1，说明二进制位还有一个1，反之
3.一直将该整数右移至其最终变为0
int main()
{
int a = 0;
int count = 0;
printf("输入一个整数：\n");
scanf("%d", &a);
while(a!=0) //当这个整数变为0时，退出循环
{
if ((a & 1) == 1) //如果该整数与1相与的结果为1，说明二进制位有一个1
{
count++; //这个整数中的1的个数+1
}
a>>= 1; //将这个整数右移1位
}
printf("该数二进制中1的个数为%d", count);
}
正确答案： B
解题步骤
前置++：先加1，后使用，即先使用变量中内容，然后给结果加1
后置++：先使用变量中内容，整个表达式结束时，给变量加1
逗号表达式：取最后一个表达式的值作为逗号表达式运算的结果
step1.将常量5赋值给变量a
a = 5;
a==5
step2. 先对a++，a变为6；再将计算后的a赋值给c，此时c=6
c = ++a;
a==6 ; c==6
step3.由于逗号运算符的性质，此时优先级从高到低顺序是：++ 、 = 、 ，
①先计算 ++c，得到c=7，然后由于 = 的优先级高于","，因此先将++c的值赋值给b，b变为7
②此时 b = ++c 和后边的 c++ 、++a、a++构成逗号表达式，从左向右依次计算
③c++使 c变为8 ；++a 和 a++ 使a最后变为 8
b = ++c, c++, ++a, a++;
a==8 ; b==7 ; c==8
step4.优先级从高到低顺序是：++ 、 + 、 +=
①因此先计算a++，再计算加法，由于此处是后置++，先使用a再对a++，因此先进行a+c的加法运算，此时a+c的值为16。
②进行复合赋值的运算：该值通过复合赋值给b，即b=b+16=7+16=23
③此时a的值使用完毕，最后对a+1，a的值变为9。
b += a++ + c;
a==9 ; b==23 ; c==8
正确答案：
解题步骤
step1.由于赋值运算符是右结合的性质，因此10最先赋值给c，然后将c赋值给b，最后将b赋值给a，使得a、b、c均赋值为10
int a,b,c;
a=b=c=10;
实质:a=(b=(c=10))
step2.由于运算符的结合性：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符
因此先进行关系运算，即b==c，然后再进行赋值运算：
a=b==c;
实质：a=(b==c)
printf("a=%d b=%d c=%d\n",a,b,c);
由于b、c均在前面步骤中赋值为10，因此b==c，关系表达式成立，关系表达式值为1，然后将表达式的值赋值给a，因此a的值最后为1；但b、c的值没有发生变化，还都是10。
输出：a=1 b=10 c=10;
step3.由于运算符的结合性：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符
先进行关系运算，即b>c>=100，由于此时优先级相同，依靠其结合性进行运算：自左向右运算，b>c 不成立，关系表达式的值为0；然后比较 (b>c)>=100，即 0>=100 不成立，关系表达式的值为0；最后将0赋值给a，a的值为0；但b、c的值依旧没有发生变化，都是10
a=b>c>=100;
实质：a=((b>c)>=100);
printf("a=%d b=%d c=%d\n",a,b,c);
输出：a=0 b=10 c=10;
正确答案：
#include <stdio.h>
int main() {
int year;
printf("请输入年份：");
scanf("%d",&year);
if(year%4==0&&year%100!=0||year%400==0)
printf("是闰年\n");
else
printf("不是闰年\n");
}
Q1：为什么 if(year%4==0&&year%100!=0||year%400==0) 里面的判断条件可以不打括号？
A1：因为这是由于运算符的优先级 ：
！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符
因此，由于优先级，运算顺序是确定的，不需要使用括号来提部分运算的优先级。
A
在C语言中，一个整型（int）通常占用4个字节（这取决于编译器和机器，但4个字节是最常见的），而一个短整型（short int）通常占用2个字节。
假设数组A是一个存放短整型的一维数组，每个元素将占用2个字节。如果我们知道数组的首地址是P，要找到第i个元素的地址，我们需要从首地址开始，跳过（i-1）个元素，每个元素占用2个字节。因此，需要跳过的字节数是 (i-1) * 2。
所以，第i个元素的地址将是 P + (i-1) * 2。
因此，正确答案是 B. P+(i-1)*2。
答案是C。
"double(*p1)[N]"是一个指向一维数组的指针，这个数组由N个double类型元素组成。也可以说它是一个指向N个double元素的指针数组的指针。
正确答案是C．对函数func的原型说明。
在C程序中，语句"char *func(int x,int y);"是函数原型声明，它声明了一个名为func的函数，该函数接受两个整型参数x和y，并返回一个字符指针。
D
strlen()函数用于计算字符串的长度，但不包括末尾的空字符'\0'。因此，对于字符串"hello!"，其长度为6个字符，不包括末尾的空字符'\0'。因此，输出结果为6。
#include<stdio.h>
#include <math.h>
int main()
{
float p, r, n;
r = 0.07;
n = 10;
p = pow(1 + r, n);
printf("p=%f\n", p);
return 0;
}
题目解析:
理解题意很关键，其次就是利用数学库math中pow函数进行幂次方计算
#include<stdio.h>
#include <math.h>
int main()
{
float r5, r3, r2, r1, r0, p, p1, p2, p3, p4, p5;
p = 1000;
r5 = 0.0585;
r3 = 0.054;
r2 = 0.0468;
r1 = 0.0414;
r0 = 0.0072;
p1 = p*((1 + r5) * 5); // 一次存5年期
p2 = p*(1 + 2 * r2)*(1 + 3 * r3); // 先存2年期，到期后将本息再存3年期
p3 = p*(1 + 3 * r3)*(1 + 2 * r2); // 先存3年期，到期后将本息再存2年期
p4 = p*pow(1 + r1, 5); // 存1年期，到期后将本息存再存1年期，连续存5次
p5 = p*pow(1 + r0 / 4, 4 * 5); // 存活期存款。活期利息每一季度结算一次
printf("p1=%f\n", p1); // 输出按第1方案得到的本息和
printf("p2=%f\n", p2); // 输出按第2方案得到的本息和
printf("p3=%f\n", p3); // 输出按第3方案得到的本息和
printf("p4=%f\n", p4); // 输出按第4方案得到的本息和
printf("p5=%f\n", p5); // 输出按第5方案得到的本息和
return 0;
}
题目解析:
该题的关键主要是利用数学函数库中的log函数进行求解，然后月份要求按照小数点后一位进行四舍五入进行处理，只需要在输出时进行格式控制即可。
#include<stdio.h>
#include <math.h>
int main()
{
float d = 300000, p = 6000, r = 0.01, m;
m = log10(p / (p - d*r)) / log10(1 + r);
printf("m = %3.1f\n", m);
return 0;
}
此题主要考察格式化输入，整形输入a和b时，必须按照a=3b=7的格式输入，浮点数输入时，%e代表科学记数法输入，字符输入c1和c2时，中间不能有任何空格
题目解析:
密码转换的关键在于相应字符的ascii加4进行赋值修改原来的字符即可，修改完成后即为相应的密码，在使用putchar和printf进行相应输出即可。
#include<stdio.h>
int main()
{
char c1 = 'C', c2 = 'h', c3 = 'i', c4 = 'n', c5 = 'a';
c1 = c1 + 4;
c2 = c2 + 4;
c3 = c3 + 4;
c4 = c4 + 4;
c5 = c5 + 4;
//使用putchar输出
printf("使用putchar输出: ");
putchar(c1);
putchar(c2);
putchar(c3);
putchar(c4);
putchar(c5);
printf("\n");
//使用printf输出
printf("使用putchar输出: %c%c%c%c%c\n", c1, c2, c3, c4, c5);
return 0;
}
题目解析:
此题主要理解圆柱的各种求法，其次要求取小数点后两位，只需在打印时进行格式控制即可。
#include<stdio.h>
int main()
{
float h, r, l, s, sq, vq, vz;
float pi = 3.141526;
printf("请输入圆半径r，圆柱高h∶");
scanf("%f %f", &r, &h); //要求输入圆半径r和圆柱高h
l = 2 * pi*r; //计算圆周长l
s = r*r*pi; //计算圆面积s
sq = 4 * pi*r*r; //计算圆球表面积sq
vq = 3.0 / 4.0*pi*r*r*r; //计算圆球体积vq
vz = pi*r*r*h; //计算圆柱体积vz
printf("圆周长为: l=%6.2f\n", l);
printf("圆面积为: s=%6.2f\n", s);
printf("圆球表面积为: sq=%6.2f\n", sq);
printf("圆球体积为: v=%6.2f\n", vq);
printf("圆柱体积为: vz=%6.2f\n", vz);
return 0;
}
题目解析:
(1) 变量cl和c2应定义为字符型、整型还是二者皆可?
答：c1和c2 应定义为整形，因为定义为字符有可能返回的整数会超出字符的存储范围
(2) 要求输出cl和c2值的ASCII码,应如何处理?用putchar函数还是printf函数?
答：需要使用printf函数，打印是以整形形式打印
(3) 整型变量与字符变量是否在任何情况下都可以互相代替
答：不是，因为两者的存储范围不同，如果整数超出了字符的存储范围，则不能相互替换
代码示例:
int main()
{
int c1, c2;
printf("请输入两个字符c1,c2:");
c1 = getchar();
c2 = getchar();
printf("用putchar语句输出结果为:");
putchar(c1);
putchar(c2);
printf("\n");
printf("用printf语句输出结果为:");
printf("%c %c\n", c1, c2);
return 0;
}
解析： 3+4>5 优先3+4得到结果7，因此7>5结果为真； 4==5为假，一真一假逻辑与最终结果为假。
答案： 0
#include <stdio.h>
int main()
{
int a = 3, b = 4, c = 5;
printf("%d\n", a || b + c && b - c);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解析： 优先算术运算4+5得到7，非0则为真，4-5得到-1，非0则为真，接下来逻辑与判断，最终逻辑或判断
答案： 1
#include <stdio.h>
int main()
{
int a = 3, b = 4, c = 5;
printf("%d\n", a || b + c && b - c);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解析 ： ！优先级最高，!(3>4)最终结果为真，!5为假； 其次 &&，真&&假得到假，最终||，1为真，假或真为真
答案： 1
#include <stdio.h>
int main()
{
int a = 3, b = 4, c = 5;
printf("%d\n", !(a > b) && !c || 1);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解析： 这里&&优先级最低是最后一个逻辑运算，因此不管如何，最终&&0，则肯定为假
答案： 假-0
#include <stdio.h>
int main()
{
int a = 3, b = 4, c = 5;
int x, y;
printf("%d\n", !(x = a) && (y = b) && 0);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解析： 在vs中优先对（a+b）取非得到0,0+5-1结果为4，因此最终为真（此题涉及不同平台结果不同的问题，因为在有的平台下编译器会优先算术运算，则最终取非得到结果为假）
答案： 1
#include <stdio.h>
int main()
{
int a = 3, b = 4, c = 5;
printf("%d\n", !(a + b) + c - 1);
printf("%d\n", !(a + b) + c - 1 && b + c / 2);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解题思路： 首先判断输入的数字是否大于1000且是正数，然后使用sqrt函数对数据进行取平方根，最主要的是最终在输出是调整输出格式，小数部分为0位，只需要正数部分，且整数部分不会超过4位，
答案：
#include <stdio.h>
#include <math.h>
int main()
{
float a, b;
scanf_s("%f", &a);
if (a >= 1000 || a < 0) {
printf("请输入小于1000的正数\n");
scanf_s("%f", &a);
b = sqrt(a);
}
else {
b = sqrt(a);
}
printf("a=%4.0f, b=%4.0f\n", a, b);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解题思路： 根据输入的不同x值进行条件判断，不同的条件采用不同的表达式进行计算即可
答案：
#include <stdio.h>
int main()
{
int x, y;
scanf_s("%d", &x);
if (x < 1) {
y = x;
}
else if (x >= 1 && x < 10) {
y = 2 * x - 1;
}
else {
y = 3 * x - 11;
}
printf("y = %d\n", y);
system("pause");//这一句是为了让控制台不退出
return 0;
}
解题思路： 根据不同的阶段成绩区间作为成绩的判断条件，属于哪个区间则输出对应等级即可
答案：
#include <stdio.h>
int main()
{
int score;
printf("enter score:");
scanf_s("%d", &score);
if (score >= 90) {
printf("A\n");
}else if (score >= 80 && score < 90) {
printf("B\n");
}else if (score >= 70 && score < 80) {
printf("C\n");
}else if (score >= 60 && score < 70) {
printf("D\n");
}else {
printf("E\n");
}
system("pause");
return 0;
}
①求出它是几位数;
解题思路： 大于10000就是5位，否则大于1000就是四位，否则大于100是三位…
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的正数\n");
return -1;
}
if (num >= 10000) {
printf("5\n");
}else if (num >= 1000) {
printf("4\n");
}else if (num >= 100) {
printf("3\n");
}else if (num >= 10) {
printf("2\n");
}else {
printf("1\n");
}
system("pause");
return 0;
}
②分别输出每一位数字;
解题思路： 99999除以10000则输出9；9999除以1000则输出9，…
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的数字\n");
return -1;
}
if (num / 10000 > 0) {//取出万位数字
printf("%d ", num / 10000);
}
if (num%10000 >= 1000) {//取余10000则可以取出低四位的数据，除以1000则得到千位的数字
printf("%d ", (num % 10000) / 1000);
}
if (num%1000 >= 100) {//取余1000则可以取出低三位的数据，除以100则得到百位的数字
printf("%d ", (num % 1000) / 100);
}
if (num%100 >= 10) {//取余100则可以取出低两位的数据，除以10则得到十位的数字
printf("%d ", (num % 100) / 10);
}
if (num%10 >= 0) {//取余10则取出个位数字
printf("%d ", num % 10);
}
printf("\n");
system("pause");
return 0;
}
③按逆序输出各位数字，例如原数为321,应输出123。
解题思路： 思路与第二题相同，只不过将整个过程逆序即可
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的数字\n");
return -1;
}
if (num % 10 >= 0) {
printf("%d ", num % 10);
}
if (num % 100 >= 10) {
printf("%d ", (num % 100) / 10);
}
if (num % 1000 >= 100) {
printf("%d ", (num % 1000) / 100);
}
if (num % 10000 >= 1000) {
printf("%d ", (num % 10000) / 1000);
}
if (num / 10000 > 0) {
printf("%d ", num / 10000);
}
printf("\n");
system("pause");
return 0;
}
(1) 使用if语句编写程序。
解题思路： 先将每一档的最大奖金算出来，在某一个区间时，则那小于这一档的奖金加上多出部分的奖金即可，例如：
先列出100000档的奖金是10000，则180000就是10000 + （180000-100000） * 0.075；
列出200000档的奖金是第一档加上多出100000部分的7.5%得到17500，则300000就是17500 + （300000-200000）*0.05；
答案：
#include <stdio.h>
int main()
{
double I, salary = 0;
printf("enter performance:");
scanf_s("%lf", &I);
if (I < 0) {
printf("请输入一个正数\n");
system("pause");
return -1;
}
double salary1 = 100000 * 0.1;//10万的奖金
double salary2 = (200000 - 100000) * 0.075 + salary1;//20万的奖金
double salary3 = (400000 - 200000) * 0.05 + salary2;//40万的奖金
double salary4 = (600000 - 400000) * 0.03 + salary3;//60万的奖金
double salary5 = (1000000 - 600000) * 0.015 + salary4;//100万的奖金
if (I <= 100000) {
salary = I * 0.1;//小于100000按10%提成
}else if (I > 100000 && I <= 200000) {
salary = salary1 + (I - 100000) * 0.075;//多出10万的按比例计算，加上10w的奖金
}else if (I > 200000 && I <= 400000) {
salary = salary2 + (I - 200000) * 0.05;//多出20万的按比例计算，加上20w的奖金
}else if (I > 400000 && I <= 600000) {
salary = salary3 + (I - 400000) * 0.03;//多出40万的按比例计算，加上40w的奖金
}else if (I > 600000 && I <= 1000000) {
salary = salary4 + (I - 600000) * 0.015;//多出60万的按比例计算，加上60w的奖金
}else if (I > 1000000){
salary = salary5 + (I - 1000000) * 0.01;//多出100万的按比例计算，加上100w的奖金
}
printf("salary:%f\n", salary);
system("pause");
return 0;
}
(2) 使用switch语句编写程序。
解题思路： 与第一题思路没有太大差别，区别在于switch语句的case子句中需要是一个常量整数，并且switch中若子句中没有break将循序向下执行，直到遇到break才会跳出switch语句，如果这时候将利润除以10w，则得到09的数字，其中0表示小于10w，1表示介于1020w，2、3表示介于2040w，4、5表示介于4060w，6、7、8、9表示介于60~100w，否则就是大于100w
答案：
#include <stdio.h>
int main()
{
double I, salary = 0;
printf("enter performance:");
scanf_s("%lf", &I);
if (I < 0) {
printf("请输入一个正数\n");
system("pause");
return -1;
}
double salary1 = 100000 * 0.1;//大于100000时0~100000的奖金
double salary2 = (200000 - 100000) * 0.075 + salary1;//大于200000时0~20万的奖金
double salary3 = (400000 - 200000) * 0.05 + salary2;//大于400000时0~40万的奖金
double salary4 = (600000 - 400000) * 0.03 + salary3;//大于600000时0~60万的奖金
double salary5 = (1000000 - 600000) * 0.015 + salary4;//大于1000000时0~100万的奖金
int grade = I / 100000;
switch(grade) {
case 0:
salary = I * 0.1; break;
case 1:
salary = salary1 + (I - 100000) * 0.075; break;
case 2://会顺序执行到下一个break处
case 3:
salary = salary2 + (I - 200000) * 0.05; break;
case 4:
case 5:
salary = salary3 + (I - 400000) * 0.03; break;
case 6:
case 7:
case 8:
case 9:
salary = salary4 + (I - 600000) * 0.015; break;
default:
salary = salary5 + (I - 1000000) * 0.01; break;
}
printf("salary:%f\n", salary);
system("pause");
return 0;
}
解题思路： 四个数中先找到最小的，剩下的三个数中找到第二小的，剩下的两个数中找到第三小的。
答案：
#include <stdio.h>
int main()
{
int a, b, c, d;
int max_num;
scanf_s("%d %d %d %d", &a, &b, &c, &d);
int tmp;
//找到最小的数
if (a > b) {
tmp = a; a = b; b = tmp; // a>b两个数据交换,则给a存储小的b
}
if (a > c) {
tmp = a; a = c; c = tmp;
}
if (a > d) {
tmp = a; a = d; d = tmp;
}
//找到第二小的数，不需要和最小的数比较
if (b > c) {
tmp = b; b = c; c = tmp;
}
if (b > d) {
tmp = b; b = d; d = tmp;
}
//找到第三小的数据，不需要和第一和第二小比较
if (c > d) {
tmp = c; c = d; d = tmp;
}
printf("%d %d %d %d\n", a, b, c, d);
system("pause");
return 0;
}
解题思路： 塔的半径为1m，则x坐标小于-3或者大于3，以及y坐标大于3或者小于-3则都是0m的建筑；其余则判断输入的坐标是否在各个圆塔的圆形范围内。该点到各个圆心的距离是否大于1，小于则是10m建筑，否则为0m建筑。
math.h中提供了fabs(double)求一个浮点数的绝对值，输入x,y坐标
fabs(fabs(x) - 2)得到输入坐标距离圆心的横轴距离；
fabs(fabs(y) - 2)得到舒服坐标距离圆心的纵轴距离；
三角形两个直角边长平方相加，然后开平方根得到第三边长，若大于1，则不再圆塔范围内。
答案：
#include <stdio.h>
#include <math.h>
void main()
{
int h;
double x, y, m, n, r;
printf("Please input a coordinate (x,y):");
scanf_s("%lf,%lf", &x, &y);
if (fabs(x) > 3 || fabs(y) > 3) {
h = 0;
printf("The height of the coordinate(%f,%f):h=%d\n", x, y, h);
return 0;
}
m = fabs(x) - 2; n = fabs(y) - 2;
r = sqrt(m * m + n * n);
if (r > 1)
h = 0;
else
h = 10;
printf("The height of the coordinate(%f,%f):h=%d\n", x, y, h);
system("pause");
return 0;
}
答案解析：
该题可以调用getchar函数，从stdin流中读入一个字符，当输入多个字符时，getchar()再执行时就会直接从缓冲区中读取了。等同于getc(stdin)。所以，我们循环调用getchar，直到将标准输入的内容读到换行符\n为止。同时判断，读取到的字符是英文字母、空格、数字或者其他字符，并计数；
#include <stdio.h>
int main()
{
char c;
//定义eng_char为英文字母的个数，初始值为0
//定义space_char为空格字符的个数，初始值为0
//定义digit_char为数字字符的个数，初始值为0
//定义other_char为其他字符的个数，初始值为0
int eng_char = 0, space_char = 0, digit_char = 0, other_char = 0;
printf("请输入一行字符：");
while ((c = getchar()) != '\n')
{
if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')
{
eng_char++;
}
else if (c == ' ')
{
space_char++;
}
else if (c >= '0' && c <= '9')
{
digit_char++;
}
else
{
other_char++;
}
}
printf("英文字母数量:%d\n空格数量:%d\n数字数量:%d\n其他字符数量:%d\n", eng_char, space_char, digit_char, other_char);
return 0;
}
答案解析：
该题目可以将数字拆分为 a * 10^n + 前一个数字，例如:
2 = 2 * 10^0 + 0 : 默认2的前一个数字为0，也就是没有任何值
22 = 2 * 10^1 + 2 ： 22的前一个数字为2
222 = 2*10^2 + 22 ：222的前一个数字为22
以此类推…
所以，在每次循环的时候，需要保存下，上一次结果的值，方便下一次计算
还需要使用到C库当中使用的pow函数，来计算某个数的n次方，我们在该题目当中使用的是10的n次方，n随着循环的次数，以此递增。
#include <stdio.h>
#include <math.h>
int main()
{
//n为a的个数
int n;
double a, prev_sum = 0.0, total_sum = 0.0;
printf("请输入a的值以及n的值: ");
scanf("%lf %d", &a, &n);
//循环n次求总和
for (int i = 0; i < n; i++)
{
prev_sum += a * pow(10, i);
total_sum += prev_sum;
}
printf("总和为：%lf\n", total_sum);
return 0;
}
答案解析：
该题需要从1循环到20，依次求出每一个数字阶乘的结果。所以在代码当中需要有两个循环，大循环从1到20，保证1到20个数字都被循环到，小循环里计算N阶乘，累加求和。注意：对于20的阶乘已经超出了int类型能过表示的数字范围，所以在代码当中使用double类型
#include<stdio.h>
int main()
{
double total_sum = 0;
for(int i = 1; i <= 20; i++)
{
double single_sum = 1;
for (int j = i; j > 0; j--)
{
single_sum *= j;
}
total_sum += single_sum;
}
printf("1~20每个数字阶乘总和为：%lf\n",total_sum);
return 0;
}
答案解析：
因子：整数a除以整数b(b≠0) 的商正好是整数而没有余数，我们就说b是a的因子。整数n除以m，结果是无余数的整数，那么我们称m就是n的因子。 需要注意的是，唯有被除数，除数，商皆为整数，余数为零时，此关系才成立。因子是不包括自身的
举一个例子：20 = 4 * 5，则4和5就是20的因子，也被称之为因子
#include<stdio.h>
int main()
{
int data, fator, sum; /* data表示要判断的数，fator表示因子，sum表示因子之和*/
for (data = 2; data <= 1000; data++)
{
//1是所有整数的因子，所以因子之和从1开始
sum = 1;
for (fator = 2; fator <= data / 2; fator++)
{
/* 判断data能否被fator整除，能的话fator即为因子 因子不包括自身 */
if (data % fator == 0)
{
sum += fator;
}
}
// 判断此数是否等于因子之和 */
if (sum == data)
{
printf("%d its factors are 1, ", data);
for (fator = 2; fator <= data / 2; fator++)
{
if (data % fator == 0)
{
printf("%d, ", fator);
}
}
printf("\n");
}
}
return 0;
}
答案解析：
从题目当中可以看出来，下一个分式当中的分子为上一个分式中分子和分母的和，分母为上一个分式的分子。通过这个规律不难推出下一个分式的分子和分母，需要注意的是，保存分式的结果不能使用到整数，因为有可能会有小数的存在，所以我们需要选用浮点数double
#include <stdio.h>
//定义循环次数
#define COUNT 20
int main()
{
//定义第一个分式的分子为a, 值为2; 定义分母为b，值为1
//定义相加的和为sum，初始值为0
double a = 2, b = 1, sum = 0;
double temp;
for (int i = 0; i < COUNT; i++)
{
sum += a / b;
//记录前一项分子
temp = a;
//前一项分子与分母之和为后一项分子
a = a + b;
//前一项分子为后一项分母
b = temp;
}
printf("前%d项之和为:sum=%9.7f\n", COUNT, sum);
return 0;
}
答案解析：
该题目需要循环10次，在每一循环的时候，需要将下落的高度和回弹的高度加起来。需要注意的点，第10次下落不需要在计算回弹的距离了，所以需要特殊处理下。在计算每次高度的时候，会有小数存在，所以需要选用浮点数
#include <stdio.h>
int main()
{
//总高度
double total_m = 100.0;
//小球经历的米数
double total_sum = 0.0;
for (int i = 0; i < 10; i++)
{
total_sum += total_m;
total_m /= 2;
total_sum += total_m;
}
//不需要计算第10次的反弹高度，所以减去
total_sum -= total_m;
printf("小球总共经历%lf米, 第10次反弹%lf米\n", total_sum, total_m);
return 0;
}
答案解析：
从题面上来看，可以推出，后一天的桃子数量 = 前一天桃子数量 / 2 - 1。所以，该公式也可以写成前一天的桃子数量 = (后一天桃子数量+1) * 2。所以我们知道了第10天剩余桃子的数量，则可以依次推算出桃子的前一天桃子的总数。需要注意的点，猴子只是吃了9天，所以，我们只需要遍历9次就可以了。
#include <stdio.h>
int main()
{
int day = 9;
int prev_day_count;
int cur_day_count = 1;
while (day > 0)
{
prev_day_count = (cur_day_count + 1) * 2;
cur_day_count = prev_day_count;
day--;
}
printf("total count : %d\n", cur_day_count);
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
float a, x0, x1;
printf("请输入一个正数: ");
scanf("%f", &a);
x0 = a / 2;
x1 = (x0 + a / x0) / 2;
do
{
x0 = x1;
x1 = (x0 + a / x0) / 2;
} while (fabs(x0 - x1) >= 1e-5);
printf("[%f] 的平方根为 [%f]\n", a, x1);
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
double x1, x0, f, f1;
x1 = 1.5;
do
{
x0 = x1;
f = ((2 * x0 - 4) * x0 + 3) * x0 - 6;
f1 = (6 * x0 - 8) * x0 + 3;
x1 = x0 - f / f1;
} while (fabs(x1 - x0) >= 1e-5);
printf("方程在1.5附近的根为：%lf\n", x1);
return 0;
}
答案解析：
将区间划分为两部分，记录区间左右端点，得到中点。每次运算将中点带入方程进行运算，求得结果，进行分析：
结果 > 0：将中位数赋值给右端点
结果 < 0：将中位数赋值给左端点
以此类推…
fabs函数是一个求绝对值的函数，求出x的绝对值，和数学上的概念相同;
le-5：10^(-5) ，即0.00001
#include<stdio.h>
#include<math.h>
int main()
{
double left = -10, right = 10, mid;
double temp = 10;
while (fabs(temp) > 1e-5)
{
mid = (left + right) / 2;
//((2x - 4)*x + 3) * x - 6 ==> 2x^3 - 4x^2 + 3x -6
temp = ((2 * mid - 4) * mid + 3) * mid - 6;
if (temp > 0)
{
right = mid;
}
else if (temp < 0)
{
left = mid;
}
}
printf("在(-10,10)的根为：%lf", mid);
return 0;
}
答案解析：
该题目需要关心当前行对应的从最左边到第一颗*的空格数量以及星星数量。将该题分为两个部分，前面4行和后面3行来进行拆分。
前4行中：
第一行：行号为0， 空格数为3，星星数量为1；
第二行：行号为1， 空格数为2， 星星数量为3；
第三行：行号为2， 空格数为1， 星星数量为5；
第四行：行号为3， 空格数为0，星星数量为7；
则我们可以推出两组关系，即行号和空格数量关系为：空格数 = 3 - 行号 。行号与星星的关系为：星星数 = 2 * 行号 + 1
后三行中：
第一行：行号为0，空格数为1，星星数量为5；
第二行：行号为1， 空格数为2， 星星数量为3；
第三行：行号为2， 空格数为3，星星数量为1；
则我们推出两组关系，即行号与数量的关系：空格数 = 行号 + 1。行号与星星的关系：星星数 = 7 - 2 * （行号+1）
基于上面的关系，我们写出如下代码：
#include <stdio.h>
int main()
{
int cur_row, space_count, start_count;
//输出前4行内容
for (cur_row = 0; cur_row < 4; cur_row++)
{
//计算当前行空格数量，并且进行打印
for (space_count = 3 - cur_row; space_count > 0; space_count--)
{
printf(" ");
}
//计算当前行*数量，并且进行打印
for (start_count = 2 * cur_row + 1; start_count > 0; start_count--)
{
printf("*");
}
printf("\n") ;
}
//输出后三行
for (cur_row = 0; cur_row < 3; cur_row++)
{
for (space_count = cur_row + 1; space_count > 0; space_count--)
{
printf(" ");
}
for (start_count = 7 - 2 * (cur_row + 1); start_count > 0; start_count--)
{
printf("*");
}
printf("\n");
}
return 0;
}
答案解析：
从题面上得知，每队为3人，则隐含条件为队内三人是不能比赛的，并且A一定不会和X比，C一定不会X和Z比；则我们不难写出判断条件：
如果A和X比 或者 C和X比 或者 C和Z比 或者 A和B比 或者 A和C比 或者 B和C比，都是不可以的；所以我们只要穷举A比赛对象，B比赛对象，C比赛对象，判断上述条件就可以了；
#include <stdio.h>
int main()
{
int A_battle, B_battle, C_battle;
//如果A对战的对象从“X”到“Z”
for (A_battle = 'X'; A_battle <= 'Z'; A_battle++)
{
//如果B对战的对象从“X”到“Z”
for (B_battle = 'X'; B_battle <= 'Z'; B_battle++)
{
//如果C对战的对象从“X”到“Z”
for (C_battle = 'X'; C_battle <= 'Z'; C_battle++)
{
//去除限制条件
if (A_battle == 'X' || C_battle == 'X' || C_battle == 'Z' || B_battle == A_battle || B_battle == C_battle || A_battle == C_battle)
{
continue;
}
printf("A对%c,B对%c,C对%c", A_battle, B_battle, C_battle);
}
}
}
return 0;
}
【答案解析】
矩阵：即二维数组，矩阵行和列相等的二维数组称为方阵。
1 2 3
4 5 6
7 8 9
左上角到右下角对角线上数字：行下标和列下标相等
右上角到左下角对角线上数字：列下标减1 行下标加一
通过两个循环来取到对角线上的元素，并对其求和即可。
#include<stdio.h>
int main()
{
int array[3][3];
int sumLT2RB = 0; // 标记左上角到右下角对角线元素之和
int sumRT2LB = 0; // 标记右上角到左下角对角线元素之和
printf("请输入3行3列的矩阵：\n");
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
scanf("%d", &array[i][j]);
}
// 左上角到右下角对角线
for (int i = 0; i < 3; ++i)
sumLT2RB += array[i][i];
for (int i = 0, j = 2; i < 3; ++i, j--)
sumRT2LB += array[i][j];
printf("左上角到右下角对角线元素之和: %d\n", sumLT2RB);
printf("右上角到左下角对角线元素之和: %d\n", sumRT2LB);
return 0;
}
【答案解析】
该题为数组的逆置，具体处理方式如下：
如果begin < end时，则循环进行一下操作
- 给定两个下标begin和end，begin放在数组起始的位置，end放在数组最后一个元素的位置
- 交换begin和end位置的元素
- begin往后移动，end往前移动
#include<stdio.h>
int main()
{
int array[5] = {8,6,5,4,1};
int begin = 0, end = 4;
printf("逆序之前数组为：");
for (int i = 0; i < 5; ++i)
printf("%d ", array[i]);
printf("\n");
// 逆序：begin在数组最左侧，end在数组最右侧
// 只要begin < end，将begin和end位置元素进行交换
// 然后begin往后移动一步，end往前移动一步
while (begin < end)
{
int temp = array[begin];
array[begin] = array[end];
array[end] = temp;
begin++;
end--;
}
printf("逆置之后数组为：");
for (int i = 0; i < 5; ++i)
printf("%d ", array[i]);
printf("\n");
return 0;
}
【答案解析】
仔细观察杨慧三角可以看到：
第0列和对角线上的数据全部为1，其余位置上的数据为上一行正对数据与上一行正对前一个数据之和。
比如：a[4][2] = a[3][2] + a[3][1]
#include<stdio.h>
int main()
{
int array[10][10];
for (int i = 0; i < 10; ++i)
{
for (int j = 0; j <= i; ++j)
{
// 对角线和第0列上全部为1
if (i == j || 0 == j)
array[i][j] = 1;
else
array[i][j] = array[i - 1][j] + array[i - 1][j - 1];
}
}
// 打印杨慧三角的前10行
for (int i = 0; i < 10; ++i)
{
for (int j = 0; j <= i; ++j)
{
printf("%5d", array[i][j]);
}
printf("\n");
}
return 0;
}
【答案解析】
| 17 | 24 | 1 | 8 | 15 |
--------------------------
| 23 | 5 | 7 | 14 | 16 |
--------------------------
| 4 | 6 | 13 | 20 | 22 |
--------------------------
| 10 | 12 | 19 | 21 | 3 |
--------------------------
| 11 | 18 | 25 | 2 | 9 |
仔细观察上述矩阵，可以看到以下规律：
魔方阵的生成方法为：在第0行中间置1，对从2开始的其余n^2-1个数依次按下列规则存放：
将1放在第1行的中间一列。
从2开始直到n*n止，各数依次按此规律存放：每一个数存放的行比前一个数的行数减1，列数加1。
如果上一行的行数为1，则下一个数的行数为n(指最下一行）。
当上一个数的列数为n时，下一个数的列数应该为1。
如果按上面规律确定的位置有数，或者上一个数是第1行第n列时，则把下一个数放在上一个数的下面。
#include <stdio.h>
int main()
{
int a[15][15], n, i, j, k;
while (1)
{
printf("请输入n(1~15):");
scanf("%d", &n);
if (n != 0 && n <= 15 && n % 2 != 0)
break;
else
{
printf("请输入奇数\n");
}
}
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
a[i][j] = 0;
}
j = n / 2 + 1;
a[1][j] = 1;
i = 1;
for (k = 2; k <= n*n; k++)
{
i -= 1;
j += 1;
if (i<1 && j>n)
{
i += 2;
j -= 1;
}
else if (i<1)
{
i = n;
}
else if (j>n)
{
j = 1;
}
if (a[i][j] == 0)
{
a[i][j] = k;
}
else
{
i += 2;
j -= 1;
a[i][j] = k;
}
}
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
printf("%5d", a[i][j]);
printf("\n");
}
return 0;
}
【答案解析】
鞍点是行上最大，列上最小的元素，因此对数组的第i元素进行如下操作：
找到该行上最大元素，用max标记，并标记该元素所在列colindex
找colindex列上最小的元素，用min标记，并标记该元素所在行号rowindex
如果max和min相等，并且最小的元素刚好是在第i行，则为鞍点
如果所有行找完了，没有输出则没有鞍点
#include<stdio.h>
#define M 3
#define N 4
int main()
{
int max, min, rowindex, colindex, flag = 0;
int array[M][N];
printf("请输入%d行%d列的数组:\n", M, N);
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
scanf("%d", &array[i][j]);
}
for (int i = 0; i < M; ++i)
{
// 找到i行上最大的元素,记录该元素在列号colindex
max = array[i][0];
for (int j = 0; j < N; ++j)
{
if (array[i][j] > max)
{
max = array[i][j];
colindex = j;
}
}
// 找max所在列colindex上最小的元素，并记录其所在的行
min = array[0][colindex];
for (int j = 0; j < M; ++j)
{
if (array[j][colindex] < min)
{
min = array[j][colindex];
rowindex = j;
}
}
// 如果最小元素与最小元素相同，并且最小元素也在第i行，则为鞍点
if (max == min && i == rowindex)
{
flag = 1;
printf("鞍点为：%d行%d列的元素%d", rowindex, colindex, max);
break;
}
}
if (0 == flag)
printf("没有鞍点");
return 0;
}
【答案解析】
二分查找是一个非常高效简单的查找算法，笔试和面试中非常喜欢考察。
折半查找又叫二分查找，查找的前提是序列中元素必须有序，假设区间使用[left, right)标记，待查找元素为key，具体查找的方式如下：当区间[left, right)有效时循环进行一下操作
找到[left， right)区间中间位置
如果key等于中间位置元素，则找到，返回该元素在数组中的下标
如果key小于中间位置元素，到数组的左半侧继续二分查找
如果key大于中间位置元素，到数组的右半侧继续二分查找
如果循环结束时还没有找到，则不存在该元素。
#include<stdio.h>
int main()
{
int array[15] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int left = 0;
int right = sizeof(array) / sizeof(array[0]);
int key = 0;
printf("请输入要查找的数字: ");
scanf("%d", &key);
// 二分查找
while (left < right)
{
// 找到中间位置
int mid = left + ((right - left) >> 1);
if (key == array[mid])
{
printf("%d\n", mid);
break;
}
else if (key < array[mid])
{
right = mid;
}
else
{
left = mid + 1;
}
}
if (left >= right)
printf("无此数\n");
return 0;
}
【答案解析】
获取文章中的3行文本，并对每行文本进行以下操作
定义保存结果变量：upp、low、digit、space、other
遍历每行文本中的字符
如果该字符ch：ch >= ‘a’ && ch <=‘z’，则该字符是小写字母，给low++
如果该字符ch：ch >= ‘A’ && ch <=‘Z’，则该字符是小写字母，给up++
如果该字符ch：ch >= ‘0’ && ch <=‘9’，则该字符是小写字母，给digit++
如果该字符ch：ch == ’ '，则该字符是小写字母，给space++
否则为其他字符，给other++
输入统计结果
#include <stdio.h>
int main()
{
int upp = 0, low = 0, digit = 0, space = 0, other = 0;
char text[3][80];
for (int i=0; i<3; i++)
{
// 获取一行文本
printf("please input line %d:\n",i+1);
gets(text[i]);
// 统计该行文本中小写字母、大写字母、数字、空格、其他字符的个数
for (int j=0; j<80 && text[i][j]!='\0'; j++)
{
if (text[i][j]>='A'&& text[i][j]<='Z') // 大写字母
upp++;
else if (text[i][j]>='a' && text[i][j]<='z') // 小写字母
low++;
else if (text[i][j]>='0' && text[i][j]<='9') // 数字
digit++;
else if (text[i][j]==' ') // 控制
space++;
else
other++; // 其他字符
}
}
printf("\nupper case: %d\n", upp);
printf("lower case: %d\n", low);
printf("digit : %d\n", digit);
printf("space : %d\n", space);
printf("other : %d\n", other);
return 0;
}
【答案解析】
该题非常简单，观察图形可以看出：
- 每行中*的个数相等，都是4个
- 每行中空格的个数在递增2个
- 每行先输出空格，然后输出*
按照以上方式通过循环来控制每行的输出内容即可
#include<stdio.h>
int main()
{
for (int i = 0; i < 5; ++i)
{
// 输出空格
for (int j = 0; j < i; ++j)
printf(" ");
// 输出*
printf("* * * *\n");
}
return 0;
}
【答案解析】
从题目给的实例中可以看到，编码规则非常简单，就是将从前往后数的第i个字母转化为从后往前数的第i个字母。
那解压时直接反过来转换即可：
即’Z’—>‘A’ ‘z’—>‘a’
‘Y’—>‘B’ ‘y’—>‘b’
‘X’—>‘C’ ‘x’—>‘c’
假设如果当前拿到的是小写字母，转换方式如下：
先用s[i] - 'a’计算出s[i]是26个字母中从前往后数的第几个
再用26 - (s[i]- ‘a’) - 1 转换为26个字母中从后往前数的第几个
在2的结果上加上’a’，即转换为对应从后往前的第几个字母
大写字母转换方式与上述相同，将上述每条中的’a’换为‘A’即可。
#include<stdio.h>
int main()
{
char s[1024] = {0};
scanf("%s", s);
int len = strlen(s);
// 转换
for (int i = 0; i < len; ++i)
{
// 如果是小写字母(大写字母出来类似)：
// 1. 先用s[i] - 'a'计算出s[i]是26个字母中从前往后数的第几个
// 2. 再用26 - (s[i]- 'a') - 1 转换为26个字母中从后往前数的第几个
// 3. 在2的结果上加上'a'，即转换为对应从后往前的第几个字母
if (s[i] >= 'a' && s[i] <= 'z')
s[i] = 'a' + 26 - (s[i]-'a')-1;
else if (s[i] >= 'A' && s[i] <= 'Z')
s[i] = 'A' + 26 - (s[i] - 'A')-1;
}
printf("%s", s);
return 0;
}
【答案解析】
直接将s2中的字符逐个拷贝到s1的末尾即可，用户需要保证s1中能存的下s2中的字符
- 获取s1末尾的位置
- 将s2中的字符逐个拷贝到s1中
#include<stdio.h>
int main()
{
char s1[100] = {0};
char s2[50] = { 0 };
int index1 = 0, index2 = 0;
printf("请输入字符串s1：");
scanf("%s", s1);
printf("请输入字符串s2：");
scanf("%s", s2);
printf("将s2拼接在s1之后: ");
// 1. 找到s1的末尾
while ('\0' != s1[index1])
index1++;
// 2. 将s2中的字符逐个往s1之后拼接
while (s1[index1++] = s2[index2++]);
printf("%s\n", s1);
return 0;
}
【答案解析】
字符串比较规则：从前往后逐个字符进行比较，相等时继续往后，不相等时返回该位置两个字符差值。
#include <stdio.h>
int main()
{
int ret = 0;
int index = 0;
char s1[100] = { 0 };
char s2[100] = { 0 };
printf("请输入s1:");
gets(s1);
printf("请输入s2:");
gets(s2);
// 将s1和s2中的字符从前往后逐个进行比较，相等继续往后，
// 不相等时ret中结果不为0，!ret则为0 循环结束
// 如果一个走到末尾，一个未走到末尾 ret也不为0， !ret为0，循环结束
// 如果两个字符串相等，同时达到末尾，循环结束
while (!(ret = s1[index] - s2[index]) && '\0' != s1[index] && '\0' != s2[index])
{
++index;
}
printf("%d\n", ret);
return 0;
}
【答案解析】
首先必须保证s1能否放的下s2中的字符，然后将s2中的每个字符逐个搬移到s1中即可。
#include<stdio.h>
int main()
{
char s1[100] = { 0 };
char s2[50] = { 0 };
int index1 = 0, index2 = 0;
printf("请输入字符串s2：");
scanf("%s", s2);
printf("将s2拷贝到s1中, s1现在为: ");
// 将s2[index2]位置字符拷贝到s1[index]位置，
// 然后以s1[index1]的值作为循环条件判断是否拷贝到s2的末尾
while (s1[index1++] = s2[index2++]);
printf("%s\n", s1);
return 0;
}
题目解析
根据disc = b^2 - 4ac 的值来决定如何求根，题目本身编程不难，不过需要同学们复习一下高中的数学知识哦。
#include<stdio.h>
#include<math.h>
//x1为第一个根，x2为第二个根
float x1, x2, disc, p, q;
void greater_than_zero(float a, float b)
{
float m = sqrt(disc);
x1 = (-b + sqrt(disc)) / (2 * a);
x2 = (-b - sqrt(disc)) / (2 * a);
}
void equal_to_zero(float a, float b)
{
x1 = x2 = (-b) / (2 * a);
}
void smaller_than_zero(float a, float b)
{
p = -b / (2 * a);
q = sqrt(-disc) / (2 * a);
}
int main()
{
int a, b, c;
printf("请输入 a b c:");
scanf("%d %d %d", &a, &b, &c);
printf("表达式为: %d*x^2+%d*x+%d = 0\n", a, b, c);
disc = b*b - 4 * a*c;
if (disc > 0)
{
greater_than_zero(a, b);
printf("disc>0的根为: x1=%f x2=%f\n", x1, x2);
}
else if (disc == 0)
{
equal_to_zero(a, b);
printf("disc==0的根为:x1=%f x2=%f\n", x1, x2);
}
else
{
smaller_than_zero(a, b);
printf("disc<0的根为:x1=%f+%f x2=%f-%f\n", p, q, p, q);
}
return 0;
}
题目解析：
进行数组的行列互换，其关键在于数组互换的表达式 ar[i] [j] = ar[j] [i];其次在循环的时候，内层循环不能到达最大列，需要根据此时是第几行的交换来决定循环的次数，否则有可能数组行列交换之后最后又交换回原来的形状了。
#include<stdio.h>
void PrintArray(int ar[3][3])
{
for(int i=0; i<3; ++i)
{
for(int j=0; j<3; ++j)
{
printf("%d ", ar[i][j]);
}
printf("\n");
}
}
void ReverseArray(int ar[3][3])
{
int tmp;
for(int i=0; i<3; ++i)
{
for(int j=0; j<i; ++j)
{
if(i != j) //中间数不发生变化
{
//交换两个数
tmp = ar[i][j];
ar[i][j] = ar[j][i];
ar[j][i] = tmp;
}
}
}
}
int main()
{
int array[3][3] =
{
{1,2,3},
{4,5,6},
{7,8,9}
};
printf("转置前：\n");
PrintArray(array);
//进行数组转置
ReverseArray(array);
printf("转置后：\n");
PrintArray(array);
return 0;
}
题目解析及答案：
-
要把一个字符串反序存放，其实就是对字符串做一个逆序操作，操作过程为收尾字符交换，直到把所有字符全部交换完毕。
#include<stdio.h>
void ReverseString(char str[])
{
int start, end;
char tmp;
start = 0;
end = strlen(str)-1; //字符数组小标从0开始，所以-1
while(start < end)
{
tmp = str[start];
str[start] = str[end];
str[end] = tmp;
start++;
end--;
}
}
int main()
{
char str[100] = {0};
printf("请输入一个字符串:>");
scanf("%s", str);
printf("原始字符串为:> %s\n", str);
ReverseString(str);
printf("反序字符串为:> %s\n", str);
return 0;
}
题目解析:
该题的重点在于元音字母的判断，通过或条件，凡是元音字母都进行拷贝
#include<stdio.h>
void cpy(char s[], char c[])
{
int i, j;
for (i = 0, j = 0; s[i] != '\0'; i++)
{
//判断元音字母
if (s[i] == 'a' || s[i] == 'A' || s[i] == 'e' || s[i] == 'E' ||
s[i] == 'i' ||s[i] == 'I' || s[i] == 'o' || s[i] == 'O' ||
s[i] == 'u' || s[i] == 'U')
{
c[j] = s[i];
j++;
}
}
c[j] = '\0';
}
int main()
{
char str[80], c[80];
printf("input string:");
gets(str);
cpy(str, c); //将str中的元音字母拷贝到c中
printf("The vowel letters are:%s\n", c);
return 0;
}
题目解析:
对字符串进行遍历输出，没输出一个字符，后面就跟着输出一个空格，关键点在于如果输出的是最后一个字符，则不能在输出字符，所以要对是否是最后一个字符的输出进行判断。
#include<stdio.h>
void OutString(char str[])
{
int i = 0;
while(str[i] != '\0')
{
printf("%c", str[i]);
if(str[i+1] == '\0') //清除最后一个空格不输出
break;
printf("%c", ' ');
i++;
}
printf("\n");
}
int main()
{
char str[5] = {0};
printf("input four digits:");
scanf("%s", str);
OutString(str);
return 0;
}
题目解析及答案:
单词以空格进行分隔，因此寻找空格出现的位置即为关键，每次从单词的起始到空格出现的位置即为一个单词，此时计算单词的长度，如果比当前最大的还长，就进行跟新最长单词信息，当整个字符串遍历完成，word即保存最长字符串。
#include<stdio.h>
#include<string.h>
void LongestWord(char str[], char word[])
{
int max_len = 0;
int len = 0;
int i = 0;
while(str[i] != '\0')
{
if(str[i] == ' ')
{
str[i] = '\0';
len = strlen(str);
if(len > max_len)
{
max_len = len;
strcpy(word, str);
str = str + len + 1;
}
}
i++;
}
}
int main()
{
char line[100] = {0};
char word[100] = {0};
printf("input one line:\n");
gets(line);
LongestWord(line, word);
printf("The longest word is : %s\n", word);
return 0;
}
题目解析及答案:
该题主要是对冒泡排序的理解，外层循环控制排序的趟数，内层循环主要是进行每一趟排序的比较，如果前面的字符大于后面的字符，就进行交换，每做一趟排序，就把一个最大字符排在最后，以及每做一趟排序就需要少比较一个字符。
#include<stdio.h>
#include<string.h>
void BubbleSort(char str[])
{
int i, j;
char tmp;
int len = strlen(str);
for(i=0; i<len-1; ++i)
{
for(j=0; j<len-i-1; ++j)
{
if(str[j] > str[j+1])
{
tmp = str[j];
str[j] = str[j+1];
str[j+1] = tmp;
}
}
}
}
int main()
{
int i;
char str[11] = {0};
printf("请输入10个字符:>");
for(i=0; i<10; ++i)
scanf("%c", &str[i]);
BubbleSort(str);
printf("string sorted: %s\n", str);
return 0;
}
题目解析及答案:
利用二分查找的关键在于数据一定要先有序，所以在查找前我们需要对数据进行排序。
#include<stdio.h>
#define N 10
void input(int num[], char name[N][8])
{
int i;
for (i = 0; i < N; i++)
{
printf("input NO.: ");
scanf("%d", &num[i]);
printf("input name: ");
getchar();
gets(name[i]);
}
}
void sort(int num[], char name[N][8])
{
int i, j, min, templ;
char temp2[8];
for (i = 0; i < N - 1; i++)
{
min = i;
for (j = i; j<N; j++)
if (num[min]>num[j]) min = j;
templ = num[i];
strcpy(temp2, name[i]);
num[i] = num[min];
strcpy(name[i], name[min]);
num[min] = templ;
strcpy(name[min], temp2);
}
printf("\n result:\n");
for (i = 0; i < N; i++)
printf("\n %5d%10s", num[i], name[i]);
}
void search(int n, int num[], char name[N][8])
{
int top, bott, mid, loca, sign;
top = 0;
bott = N - 1;
loca = 0;
sign = 1;
if ((n<num[0]) || (n>num[N - 1]))
loca = -1;
while ((sign == 1) && (top <= bott))
{
mid = (bott + top) / 2;
if (n == num[mid])
{
loca = mid;
printf("NO. %d , his name is %s.\n", n, name[loca]);
sign = -1;
}
else if (n < num[mid])
bott = mid - 1;
else
top = mid + 1;
}
if (sign == 1 || loca == -1)
printf("%d not been found.\n", n);
}
int main()
{
int num[N], number, flag = 1, c;
char name[N][8];
input(num, name);
sort(num, name);
while (flag == 1)
{
printf("\ninput number to look for:");
scanf("%d", &number);
search(number, num, name);
printf("continue ot not(Y/N)?");
getchar();
c = getchar();
if (c == 'N' || c == 'n')
flag = 0;
}
return 0;
}
题目解析：
该题直接使用“辗转相除法”来求解最大公约数和最小公倍数
最大公约数找出两数中的最小值，然后直接相模，当能够同时被两数整除时，则为最大公约数。
最小公倍数找出两数中的最大值，然后直接进入死循环，直到找到一个数能够同时被两数整除时，则为最小公倍数
#include<stdio.h>
//最大公约数
size_t GCD(size_t a, size_t b)
{
size_t gcd;
gcd = a > b ? b : a;
while(gcd > 1)
{
if((a % gcd == 0) && (b % gcd == 0))
return gcd;
gcd--;
}
return gcd;
}
//最小公倍数
size_t LCM(size_t a, size_t b)
{
size_t lcm;
lcm = a > b ? a : b;
while(1)
{
if((lcm % a==0) && (lcm % b==0))
break;
lcm++;
}
return lcm;
}
int main()
{
size_t a, b, result;
printf("请输入两个整数:>");
scanf("%d %d", &a, &b);
result = GCD(a, b);
printf("%d和%d的最大公约数为:%d\n", a, b, result);
result = LCM(a, b);
printf("%d和%d的最小公倍数为:%d\n", a, b, result);
return 0;
}
题目解析：
素数是一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做素数
该题可以使用概念直接判断法求解，不过不需要判断所有的数据，只需要判断数据的一半即可，因为偶数不可能为素数（除了2）,所以只需判断该数的一半即可的到答案
#include<stdio.h>
#include<stdbool.h>
bool IsPrime(int value)
{
for(int i=2; i<value/2; ++i)
{
if(value % i == 0) //说明除了1和本身之外，还能被其他数整除
return false;
}
return true;
}
int main()
{
int value;
bool flag;
printf("请输入 value :>");
scanf("%d", &value);
flag = IsPrime(value);
if(flag)
printf("%d 是素数.\n", value);
else
printf("%d 不是素数.\n", value);
return 0;
}
题目解析及答案:
单词以空格进行分隔，因此寻找空格出现的位置即为关键，每次从单词的起始到空格出现的位置即为一个单词，此时计算单词的长度，如果比当前最大的还长，就进行跟新最长单词信息，当整个字符串遍历完成，word即保存最长字符串。
#include<stdio.h>
#include<string.h>
void LongestWord(char str[], char word[])
{
int max_len = 0;
int len = 0;
int i = 0;
while(str[i] != '\0')
{
if(str[i] == ' ')
{
str[i] = '\0';
len = strlen(str);
if(len > max_len)
{
max_len = len;
strcpy(word, str);
str = str + len + 1;
}
}
i++;
}
}
int main()
{
char line[100] = {0};
char word[100] = {0};
printf("input one line:\n");
gets(line);
LongestWord(line, word);
printf("The longest word is : %s\n", word);
return 0;
}
题目解析及答案:
递归法求解主要要有结束条件，此题为n/10 == 0时就直接输出，其次本题还要考虑如果整数位负数的情形，此时需要输出一个字符串的负号。
#include<stdio.h>
void Convert(int n)
{
int i;
if ((i = n / 10) != 0)
Convert(i);
putchar(n % 10 + '0');
}
int main()
{
int number;
printf("input an integer: ");
scanf("%d", &number);
printf("output: ");
if (number < 0)
{
putchar('-'); //先输出一个负号'-'
number = -number;
}
Convert(number);
printf("\n");
return 0;
}
题目解析:
此题采用枚举法进行每月天数的累加，其中关键点注意需要判断年份是否为闰年，如果是还需要多累加1天。
#include <stdio.h>
#include<stdio.h>
/* 函数sum_day:计算日期 */
int sum_day(int month, int day)
{
int day_tab[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int i;
for (i = 1; i < month; i++)
day += day_tab[i]; /* 累加所在月之前天数 */
return day;
}
/* 函数leap:判断是否为闰年 */
int leap(int year)
{
int leap;
leap = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
return leap;
}
int main()
{
int year, month, day, days;
printf("input date(year,month,day):");
scanf("%d %d %d", &year, &month, &day);
printf("%d/%d/%d ", year, month, day);
days = sum_day(month, day); /* 调用函数sum_day */
if (leap(year) && month >= 3) /* 调用函数leap */
days = days + 1;
printf("is the %dth day in this year.\n", days);
return 0;
}
#include <stdio.h>
#define NAMLEN 20
#define STUCNT 10
typedef struct student_t{
int num;
char name[NAMLEN];
int score[3];
} student;
int main(){
student students[STUCNT];
int maxi = 0, maxsum = 0;
double aver_0 = 0, aver_1 = 0, aver_2 = 0;
for (int i = 0; i < STUCNT; i++){
scanf("%d%s%d%d%d", &students[i].num, students[i].name, &students[i].score[0], &students[i].score[1], &students[i].score[2]);
int sum = students[i].score[0] + students[i].score[1] + students[i].score[2];
if (sum > maxsum){
maxsum = sum;
maxi = i;
}
aver_0 += students[i].score[0];
aver_1 += students[i].score[1];
aver_2 += students[i].score[2];
}
aver_0 /= STUCNT;
aver_1 /= STUCNT;
aver_2 /= STUCNT;
printf("%lf %lf %lf\n", aver_0, aver_1, aver_2);
printf("%d %s %d %d %d %lf\n", students[maxi].num, students[maxi].name, students[maxi].score[0], students[maxi].score[1], students[maxi].score[2],
(students[maxi].score[0] + students[maxi].score[1] + students[maxi].score[2]) / 3.0);
return 0;
}
解题思路及答案：
创建一个环形链表，给链表中的每一个节点从1~13编号，然后开始淘汰过程，对于淘汰的节点，序号置为0，淘汰完成之后，找到序号不为0的即为最后留下的。
#include <stdio.h>
#define NUM 13
typedef struct people
{
int num;
struct people *next;
} people;
int main()
{
int count = NUM;
people p[NUM];
people *head;
head = p; //head 指向p[0]
//1~13编号
for (int i = 0; i < NUM; i++)
{
head->num = i + 1;
head->next = &p[i + 1];
head = head->next;
}
//最后一个元素指向第一个元素 ， 形成环
p[NUM - 1].next = p;
int i = 1;
head = p;
while (count > 1)
{
//跳过已经被淘汰的节点
if (head->num == 0)
{
head = head->next;
continue;
}
if (i == 3)
{
//被淘汰的节点，num置为0
printf("第 %d 位置被淘汰\n", head->num);
head->num = 0;
count--;
}
head = head->next;
i++;
if (i > 3)
{
i = 1;
}
}
printf("--------------\n");
while (head->num == 0)
{
//非0节点即为最后留下的
head = head->next;
if (head->num != 0)
{
printf("留到最后的是 %d \n", head->num);
}
}
return 0;
}
解题思路及答案：
首先合并两个链表，然后采用选择排序，给合并之后的链表进行排序。
#include <stdio.h>
typedef struct student
{
int num;
double grade;
struct student *next;
} student;
student *merge(student *a, student *b)
{
//先合并，后排序
student *head = a;
while (a->next != NULL)
{
a = a->next;
}
a->next = b;
//选择排序，每次选最小的，放在未排序的链表头部
student *pre;
pre = head;
while (pre->next != NULL)
{
a = pre->next;
while (a != NULL)
{
if (pre->num > a->num)
{
int num = pre->num;
double grade = pre->grade;
pre->num = a->num;
pre->grade = a->grade;
a->num = num;
a->grade = grade;
}
a = a->next;
}
pre = pre->next;
}
return head;
}
int main()
{
student a[3] = {{1, 79}, {4, 36}, {5, 79}};
for (int i = 0; i < 2; i++)
{
a[i].next = &a[i + 1];
}
student b[2] = {{2, 38}, {6, 98}};
for (int i = 0; i < 1; i++)
{
b[i].next = &b[i + 1];
}
student *combine = merge(a, b);
while (combine != NULL)
{
printf("%d -> %.2lf\n", combine->num, combine->grade);
combine = combine->next;
}
return 0;
}
解题思路及答案：
对于b链表中的每一个节点，都从a链表的表头开始查找，如果可以找到，直接删除，如果找不到，继续从a链表表头找下一个b的节点。
#include <stdio.h>
typedef struct student
{
int num;
double grade;
struct student *next;
} student;
student *del(student *a, student *b)
{
student *pre, *current, *head;
head = a;
while (b != NULL)
{
//重置指针指向a链表的头部
pre = head;
current = head->next;
//a 链表的头等于b
if (pre->num == b->num)
{
pre->next = NULL;
pre = current;
current = current->next;
//更新表头
head = pre;
}
else
{
while (pre->next != NULL)
{
if (current->num == b->num)
{
//找到就删除
pre->next = current->next;
break;
}
else
{
//否则继续遍历
pre = pre->next;
current = current->next;
}
}
}
b = b->next;
}
return head;
}
void printList(student *root)
{
printf("----\n");
int i = 0;
while (root != NULL)
{
printf("student %d -> %d -> %.2lf\n", i, root->num, root->grade);
root = root->next;
i++;
}
}
int main()
{
student a[3] = { { 1, 79 }, { 4, 36 }, { 5, 79 } };
for (int i = 0; i < 2; i++)
{
a[i].next = &a[i + 1];
}
a[2].next = NULL;
printf("链表a:\n");
printList(&a[0]);
student b[2] = { { 5, 38 }, { 4, 98 } };
for (int i = 0; i < 1; i++)
{
b[i].next = &b[i + 1];
}
b[1].next = NULL;
printf("链表b:\n");
printList(&b[0]);
student *combine = del(a, b);
printf("删除之后：\n");
while (combine != NULL)
{
printf("%d -> %.2lf\n", combine->num, combine->grade);
combine = combine->next;
}
return 0;
}
#include <stdio.h>
#include <stdio.h>
typedef struct student
{
int num;
char sex[10];
char name[100];
int age;
struct student *next;
} student;
void printList(student *root)
{
printf("----\n");
while (root != NULL)
{
printf("num:%d, sex: %s, name: %s, age: %d\n", root->num, root->sex, root->name, root->age);
root = root->next;
}
}
int main()
{
student a[] = { { 1, "woman", "apple", 12 }, { 4, "woman", "banbana", 36 }, { 5, "man", "candy", 79 }, { 5, "man", "danny", 36 }, { 4, "man", "enjoy", 98 } };
for (int i = 0; i < 4; i++)
{
a[i].next = &a[i + 1];
}
a[4].next = NULL;
printList(&a[0]);
int n;
printf("请输入要删除的年龄：\n");
scanf("%d", &n);
student *pre = a, *current = a->next, *head;
head = a;
while (current != NULL)
{
//如果头结点需要删除，则更新头结点
if (head->age == n)
{
pre->next = NULL;
pre = current;
current = current->next;
head = pre;
}
else
{
//删除节点，重新链接
if (current->age == n)
{
pre->next = current->next;
}
pre = current;
current = current->next;
}
}
printList(head);
return 0;
}
C
B
C
D
C
C
A
C
C
C
非执行的语句不转换：例如//和/**/是注释的意思
D
字母，数字，下划线组成，但是不能以数字开头
C
算法可以没有输入输入，但是一定不能没有输出
C
B
C
B
C
D
B
B
双引号“”包括起来的整体是字符串
D
D
C
D
赋值语句=左边必须为变量，不能为常量。B选项等式两边均为变量
B
B
#include <stdio.h>
int main(void)
{
int x=1,y=0;
if(!x)
y++;
else if(x==0)//这里不满足，直接就结束了
if(x)
y+=2;
else//这个else只和最近的if生效
y+=3;
printf("%d\n",y);
return 0;
}
D
C
A
可以自己调用自己：eg：递归函数
D
B
A
这是结构体，就是看着有点复杂
D
D
C
字符串以\0结束，占用一个字节，但是如果计算机的话不会算\0
C
main
;
分支结构
//或者/**/
float double
1
左结合
0124
K=3的时候不输出直接continue，开始下一个k=4，然后输出k=4
double
0
a=9；a=a-9;a=0;a=a+0;a=0
5,-2
(y>=x)&&(y<=z)
6
逻辑 与 运算符&&，当左边不成立时，右边直接不看，b的赋值直接不执行，还是b=6；
4
计算机并不会加上\0
(0<x)&&(x>10)
按行存放
;
分号一定要是英文的哦
A
A
A
A
A
这个高级的意思并不是优先级高（并不是等级高的意思），而是相较机器语言那一种低级语言语言来说是高级语言。
A
A
数组中必须要求是同一类型
A
A
A
A
B
还有算数表达式
B
A
A
B
B
printf里面的%f改为%10.2f
10表示宽度，2表示两位小数，若没有限制宽度只限制二位小数则把%f改为%0.2f
printf里面的%f改为%.2f
同样也可以使用两次if-else语句，先将a的值赋给max，然后依次与b，c比较，最后将最大的值赋给max，如何输出
这是最直接的用数组表示斐波那契数列，同时也可以写递归调用函数来表示
答案：D
答案：A
答案：B
答案：A
答案：A
答案：A
答案：D
答案：C
A
答案：D
答案：A
答案：A
答案：A
答案：A
答案：C
答案：A
答案：A
答案：D
答案：A
答案：A
答案：C
答案：B
答案：A
答案：D
答案：A
答案：A
答案：B
答案：C
答案：A
答案：A
答案：A
答案：A
答案：D
答案：A
答案：C
答案：A
答案：A
答案：C
答案：A
答案：A
答案：A
答案：A
答案：B
答案：C
答案：A
答案：A
答案：A
答案：D
答案：A
答案：B
答案：D
答案：A
答案：A
答案：B
答案：A
答案：A
答案：B
答案：D
答案：A
答案：C
答案：A
答案：C
答案：D
答案：A
答案：A
答案：A
答案：C
答案：A
答案：B
答案：A
答案：A
答案：C
答案：A
答案：D
答案：A
答案：A
答案：A
答案：A
答案：D
答案：D
答案：A
答案：B
答案：A
答案：B
答案：A
答案：A
答案：D
答案：A
答案：A
答案：B
答案：A
答案：D
答案：A
答案：D
答案：A
答案：A
答案：C
答案：D
答案：A
答案：A
#include <stdio.h>
#include <math.h>
int main()
{
float a,b,c,x1,x2,d;
printf("输入方程的三个系数:");
scanf("%f %f %f",&a,&b,&c);
if(a!=0)
{
d=sqrt(b*b-4*a*c);
x1=(-b+d)/(2*a);
x2=(-b-d)/(2*a);
if(x1<x2)
printf("%0.2f %0.2f\n",x2,x1);
else
printf("%0.2f %0.2f\n",x1,x2);
}
return 0;
}
使用嵌套 for 循环输出九九乘法口诀表
#include<stdio.h>
int main(){
//外层循环变量,控制行
int i = 0;
//内层循环变量,控制列
int j = 0;
for(i=1;i<=9;i++){
for(j=1;j<=i;j++){
printf("%dx%d=%d\t",j,i,i*j);
}
//每行输出完后换行
printf("\n");
}
}
递归实现方式
#include <stdio.h>
void func(int i, int j)
{
if(i>j)
return;
printf("%dx%d=%d\t", i, j, i*j);
func(i+1, j);
}
void f(int n)
{
if(n==1)
printf("1x1=1\n");
else
{
f(n-1);
func(1, n);
putchar('\n');
}
}
int main()
{
f(9);
return 0;
}
方法一：
#include <stdio.h>
int main()
{
int n, i;
unsigned long long factorial = 1;
printf("输入一个整数: ");
scanf("%d",&n);
// 如果输入是负数，显示错误
if (n < 0)
printf("Error! 负数没有阶乘jiechen");
else
{
for(i=1; i<=n; ++i)
{
factorial *= i; // factorial = factorial*i;
}
printf("%d! = %llu", n, factorial);
}
return 0;
}
方法二使用递归：
#include <stdio.h>
long int multiplyNumbers(int n);
int main()
{
int n;
printf("输入一个整数: ");
scanf("%d", &n);
printf("%d! = %ld", n, multiplyNumbers(n));
return 0;
}
long int multiplyNumbers(int n)
{
if (n >= 1)
return n*multiplyNumbers(n-1);
else
return 1;
}
#include <stdio.h>
int main()
{
long long n;
int count = 0;
printf("输入一个整数: ");
scanf("%lld", &n);
while(n != 0)
{
// n = n/10
n /= 10;
++count;
}
printf("数字是 %d 位数。", count);
}
方法一： 使用 while
#include <stdio.h>
int main()
{
int base, exponent;
long long result = 1;
printf("基数: ");
scanf("%d", &base);
printf("指数: ");
scanf("%d", &exponent);
while (exponent != 0)
{
result *= base;
--exponent;
}
printf("结果：%lld", result);
return 0;
}
方法二：使用 pow() 函数
#include <stdio.h>
#include <math.h>
int main()
{
double base, exponent, result;
printf("基数: ");
scanf("%lf", &base);
printf("指数: ");
scanf("%lf", &exponent);
// 计算结果
result = pow(base, exponent);
printf("%.1lf^%.1lf = %.2lf", base, exponent, result);
return 0;
}
方法三：递归
#include <stdio.h>
int power(int n1, int n2);
int main()
{
int base, powerRaised, result;
printf("基数: ");
scanf("%d",&base);
printf("指数(正整数): ");
scanf("%d",&powerRaised);
result = power(base, powerRaised);
printf("%d^%d = %d", base, powerRaised, result);
return 0;
}
int power(int base, int powerRaised)
{
if (powerRaised != 0)
return (base*power(base, powerRaised-1));
else
return 1;
}
参考方法：
#include<stdio.h>
int main()
{
int i,a,b;
unsigned long c=1;
printf("请输入基数:");
scanf("%d",&a);
printf("请输入指数");
scanf("%d",&b);
for(i=1;i<=b;i++)
{
c *= a;
}
printf("%lu",c);
return 0;
}
include <stdio.h>
int main()
{
int n, reversedInteger = 0, remainder, originalInteger;
printf("输入一个整数: ");
scanf("%d", &n);
originalInteger = n;
// 翻转
while( n!=0 )
{
remainder = n%10;
reversedInteger = reversedInteger*10 + remainder;
n /= 10;
}
// 判断
if (originalInteger == reversedInteger)
printf("%d 是回文数。", originalInteger);
else
printf("%d 不是回文数。", originalInteger);
return 0;
}
参考方法：
#include <stdio.h>
#include<string.h>
int main()
{
int a=12021;
char s[10]={'\0'},s1[10]={'\0'};
sprintf(s,"%d",a); // 将整数转换为字符串
int n=strlen(s);
int j=0;
for(int i=n-1;i>=0;i--)
{
s1[j++]=s[i];
}
//s[j]='\0';
printf("%s %s\n",s,s1);
if(!strcmp(s,s1))
printf("整数%d是回文串",a);
else
printf("整数%d不是回文串",a);
return 0;
}
#include <math.h>
#include <stdio.h>
int main()
{
int sum=0;
int n,x,y;
int s=0;
printf("请输入一个数字\n");
scanf("%d",&n);
y=x=n;
do
{
n=n/10;
s++;
}while(n!=0);
printf("%d 是 %d 位数\n",x,s);
int num[s];
for(int i=s-1;i>=0;i--)//将输入数字的每位数字进行存储
{
num[i]=x%10;
x=x/10;
}
/*printf("将输入的数字从数组输出以便验证数组存储的是否正确\n");
for(int i=0;i<s;i++)
{
printf("%d ",num[i]);
}
printf("\n");*/
for(int i=0;i<s;i++)
{
sum+=pow(num[i],s);/*pow C 库函数 double pow(double x, double y) 返回 x 的 y 次幂，
即 x^y。需要C 标准库 - <math.h>*/
}
if(sum==y)
{
printf("%d 是阿姆斯壮数",y);
}else
{
printf("%d 不是阿姆斯壮数",y);
}
return 0;
}
#include <stdio.h>
int main()
{
int number, i;
printf("输入一个整数: ");
scanf("%d",&number);
printf("%d 的因数有: ", number);
for(i=1; i <= number; ++i)
{
if (number%i == 0)
{
printf("%d ",i);
}
}
return 0;
}
#include <stdio.h>
int main()
{
int num1, num2, i;
printf("输入两个数，使用空格分隔:");
scanf("%d %d", &num1, &num2);
for (i = 1; i <= (num1 > num2 ? num2 : num1) ; ++i)
{
if (num1%i == 0 && num2%i == 0)
{
printf("%d ", i);
}
}
return 0;
}
#include <stdio.h>
int main()
{
int i, j, rows;
printf("行数: ");
scanf("%d",&rows);
for(i=1; i<=rows; ++i)
{
for(j=1; j<=i; ++j)
{
printf("* ");
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int main()
{
int i, space, rows, k=0;
printf("Enter number of rows: ");
scanf("%d",&rows);
for(i=1; i<=rows; ++i, k=0)
{
for(space=1; space<=rows-i; ++space)
{
printf(" ");
}
while(k != 2*i-1)
{
printf("* ");
++k;
}
printf("\n");
}
return 0;
}
#include <stdio.h>
int checkPrime(int n);
int main()
{
int n, i, flag = 0;
printf("输入正整数: ");
scanf("%d", &n);
for(i = 2; i <= n/2; ++i)
{
// 检测判断
if (checkPrime(i) == 1)
{
if (checkPrime(n-i) == 1)
{
printf("%d = %d + %d\n", n, i, n - i);
flag = 1;
}
}
}
if (flag == 0)
printf("%d 不能分解为两个素数。", n);
return 0;
}
// 判断素数
int checkPrime(int n)
{
int i, isPrime = 1;
for(i = 2; i <= n/2; ++i)
{
if(n % i == 0)
{
isPrime = 0;
break;
}
}
return isPrime;
}
#include <stdio.h>
#include <math.h>
int convertBinaryToDecimal(long long n);
int main()
{
long long n;
printf("输入一个二进制数: ");
scanf("%lld", &n);
printf("二进制数 %lld 转换为十进制为 %d", n, convertBinaryToDecimal(n));
return 0;
}
int convertBinaryToDecimal(long long n)
{
int decimalNumber = 0, i = 0, remainder;
while (n!=0)
{
remainder = n%10;
n /= 10;
decimalNumber += remainder*pow(2,i);
++i;
}
return decimalNumber;
}
#include <stdio.h>
#include <math.h>
long long convertDecimalToBinary(int n);
int main()
{
int n;
printf("输入一个十进制数: ");
scanf("%d", &n);
printf("十进制数 %d 转换为二进制位 %lld", n, convertDecimalToBinary(n));
return 0;
}
long long convertDecimalToBinary(int n)
{
long long binaryNumber = 0;
int remainder, i = 1, step = 1;
while (n!=0)
{
remainder = n%2;
printf("Step %d: %d/2, 余数 = %d, 商 = %d\n", step++, n, remainder, n/2);
n /= 2;
binaryNumber += remainder*i;
i *= 10;
}
return binaryNumber;
}
#include <stdio.h>
#include <math.h>
int convertDecimalToOctal(int decimalNumber);
int main()
{
int decimalNumber;
printf("输入一个十进制数: ");
scanf("%d", &decimalNumber);
printf("十进制数 %d 转换为八进制为 %d", decimalNumber, convertDecimalToOctal(decimalNumber));
return 0;
}
int convertDecimalToOctal(int decimalNumber)
{
int octalNumber = 0, i = 1;
while (decimalNumber != 0)
{
octalNumber += (decimalNumber % 8) * i;
decimalNumber /= 8;
i *= 10;
}
return octalNumber;
}
#include <stdio.h>
#include <math.h>
long long convertOctalToDecimal(int octalNumber);
int main()
{
int octalNumber;
printf("输入一个八进制数: ");
scanf("%d", &octalNumber);
printf("八进制数 %d 转换为十进制为 %lld", octalNumber, convertOctalToDecimal(octalNumber));
return 0;
}
long long convertOctalToDecimal(int octalNumber)
{
int decimalNumber = 0, i = 0;
while(octalNumber != 0)
{
decimalNumber += (octalNumber%10) * pow(8,i);
++i;
octalNumber/=10;
}
i = 1;
return decimalNumber;
}
#include <stdio.h>
#include <math.h>
int convertBinarytoOctal(long long binaryNumber);
int main()
{
long long binaryNumber;
printf("输入一个二进制数: ");
scanf("%lld", &binaryNumber);
printf("二进制数 %lld 转换为八进制为 %d", binaryNumber, convertBinarytoOctal(binaryNumber));
return 0;
}
int convertBinarytoOctal(long long binaryNumber)
{
int octalNumber = 0, decimalNumber = 0, i = 0;
while(binaryNumber != 0)
{
decimalNumber += (binaryNumber%10) * pow(2,i);
++i;
binaryNumber/=10;
}
i = 1;
while (decimalNumber != 0)
{
octalNumber += (decimalNumber % 8) * i;
decimalNumber /= 8;
i *= 10;
}
return octalNumber;
}
#include <stdio.h>
#include <math.h>
long long convertOctalToBinary(int octalNumber);
int main()
{
int octalNumber;
printf("输入一个八进制数: ");
scanf("%d", &octalNumber);
printf("八进制数 %d 转二进制为 %lld", octalNumber, convertOctalToBinary(octalNumber));
return 0;
}
long long convertOctalToBinary(int octalNumber)
{
int decimalNumber = 0, i = 0;
long long binaryNumber = 0;
while(octalNumber != 0)
{
decimalNumber += (octalNumber%10) * pow(8,i);
++i;
octalNumber/=10;
}
i = 1;
while (decimalNumber != 0)
{
binaryNumber += (decimalNumber % 2) * i;
decimalNumber /= 2;
i *= 10;
}
return binaryNumber;
}
#include <stdio.h>
void reverseSentence();
int main()
{
printf("输入一个字符串: ");
reverseSentence();
return 0;
}
void reverseSentence()
{
char c;
scanf("%c", &c);
if( c != '\n')
{
reverseSentence();
printf("%c",c);
}
}
或
#include <stdio.h>
#include <string.h>
int main()
{
char c[40];
int i=1;
printf("请输入字符串：");
scanf("%s",c);
int j=strlen(c);
do{
printf("%c",c[j-i]);
++i;
} while(i<=j);
return 0;
}
#include <stdio.h>
int main() {
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int sum, loop;
float avg;
sum = avg = 0;
for(loop = 0; loop < 10; loop++) {
sum = sum + array[loop];
}
avg = (float)sum / loop;
printf("平均值为 %.2f", avg);
return 0;
}
#include <stdio.h>
int main() {
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int loop, largest;
largest = array[0];
for(loop = 1; loop < 10; loop++) {
if( largest < array[loop] )
largest = array[loop];
}
printf("最大元素为 %d", largest);
return 0;
}
#include <stdio.h>
int main() {
int array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int even[10], odd[10];
int loop, e, d;
e = d = 0;
for(loop = 0; loop < 10; loop++) {
if(array[loop]%2 == 0) {
even[e] = array[loop];
e++;
}else {
odd[d] = array[loop];
d++;
}
}
printf(" 原始数组 -> ");
for(loop = 0; loop < 10; loop++)
printf(" %d", array[loop]);
printf("\n 偶数 -> ");
for(loop = 0; loop < e; loop++)
printf(" %d", even[loop]);
printf("\n 奇数 -> ");
for(loop = 0; loop < d; loop++)
printf(" %d", odd[loop]);
return 0;
}
#include <stdio.h>
int main() {
int array[10];
int even[5] = {0, 2, 4, 6, 8};
int odd[5] = {1, 3, 5, 7, 9};
int loop, index, e_len, o_len;
e_len = o_len = 5;
index = 0;
for(loop = 0; loop < e_len; loop++) {
array[index] = even[loop];
index++;
}
for(loop = 0; loop < o_len; loop++) {
array[index] = odd[loop];
index++;
}
printf("\n偶数 -> ");
for(loop = 0; loop < e_len; loop++)
printf(" %d", even[loop]);
printf("\n奇数 -> ");
for(loop = 0; loop < o_len; loop++)
printf(" %d", odd[loop]);
printf("\n合并后 -> ");
for(loop = 0; loop < 10; loop++)
printf(" %d", array[loop]);
return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
char line[100];
int i,j,len;
printf("输入一个字符串: ");
scanf("%s",line);
len = strlen(line);
for(i=0;i<len+1;i++)
{
if((line[i]>='a'&&line[i]<='z') || (line[i]>='A'&&line[i]<='Z'))
continue;
for(j=i;j<len;j++)
{
line[j] = line[j+1];
}
len--;
i--;
}
//line[len]='\0';
printf("%s\n",line);
return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
char s1[100], s2[100];
printf("输入第一个字符串: ");
scanf("%s", s1);
printf("输入第二个字符串: ");
scanf("%s", s2);
int len1 = strlen(s1);
int len2 = strlen(s2);
//printf("%d %d", len1, len2);
for (int i = 0; i <= len2; i++)
{
s1[i + len1] = s2[i];
}
printf("%s\n", s1);
// system("pause");
return 0;
}
#include <stdio.h>
int main()
{
char str[1000], ch;
int i, frequency = 0;
printf("输入字符串: ");
fgets(str, (sizeof str / sizeof str[0]), stdin);
printf("输入要查找的字符: ");
scanf("%c",&ch);
for(i = 0; str[i] != '\0'; ++i)
{
if(ch == str[i])
++frequency;
}
printf("字符 %c 在字符串中出现的次数为 %d", ch, frequency);
return 0;
}
#include <stdio.h>
int main()
{
char line[150];
int i, vowels, consonants, digits, spaces;
vowels = consonants = digits = spaces = 0;
printf("输入一个字符串: ");
scanf("%[^\n]", line);
for(i=0; line[i]!='\0'; ++i)
{
if(line[i]=='a' || line[i]=='e' || line[i]=='i' ||
line[i]=='o' || line[i]=='u' || line[i]=='A' ||
line[i]=='E' || line[i]=='I' || line[i]=='O' ||
line[i]=='U')
{
++vowels;
}
else if((line[i]>='a'&& line[i]<='z') || (line[i]>='A'&& line[i]<='Z'))
{
++consonants;
}
else if(line[i]>='0' && line[i]<='9')
{
++digits;
}
else if (line[i]==' ')
{
++spaces;
}
}
printf("元音: %d",vowels);
printf("\n辅音: %d",consonants);
printf("\n数字: %d",digits);
printf("\n空白符: %d", spaces);
return 0;
}
#include<stdio.h>
#include <string.h>
int main()
{
int i, j;
char str[10][50], temp[50];
printf("输入10个单词:\n");
for(i=0; i<10; ++i) {
scanf("%s[^\n]",str[i]);
}
for(i=0; i<9; ++i) {
for(j=i+1; j<10 ; ++j)
{
if(strcmp(str[i], str[j])>0)
{
strcpy(temp, str[i]);
strcpy(str[i], str[j]);
strcpy(str[j], temp);
}
}
}
printf("\n排序后: \n");
for(i=0; i<10; ++i)
{
puts(str[i]);
}
return 0;
}
#include <stdio.h>
typedef struct complex
{
float real;
float imag;
} complex;
complex add(complex n1,complex n2);
int main()
{
complex n1, n2, temp;
printf("第一个复数 \n");
printf("输入实部和虚部:\n");
scanf("%f %f", &n1.real, &n1.imag);
printf("\n第二个复数 \n");
printf("输入实部和虚部:\n");
scanf("%f %f", &n2.real, &n2.imag);
temp = add(n1, n2);
printf("Sum = %.1f + %.1fi", temp.real, temp.imag);
return 0;
}
complex add(complex n1, complex n2)
{
complex temp;
temp.real = n1.real + n2.real;
temp.imag = n1.imag + n2.imag;
return(temp);
}
#include <stdio.h>
struct TIME
{
int seconds;
int minutes;
int hours;
};
void differenceBetweenTimePeriod(struct TIME t1, struct TIME t2, struct TIME *diff);
int main()
{
struct TIME startTime, stopTime, diff;
printf("输入开始时间: \n");
printf("输入小时、分钟、秒：");
scanf("%d %d %d", &startTime.hours, &startTime.minutes, &startTime.seconds);
printf("输入停止时间: \n");
printf("输入小时、分钟、秒: ");
scanf("%d %d %d", &stopTime.hours, &stopTime.minutes, &stopTime.seconds);
// 计算差值
differenceBetweenTimePeriod(startTime, stopTime, &diff);
printf("\n差值: %d:%d:%d - ", startTime.hours, startTime.minutes, startTime.seconds);
printf("%d:%d:%d ", stopTime.hours, stopTime.minutes, stopTime.seconds);
printf("= %d:%d:%d\n", diff.hours, diff.minutes, diff.seconds);
return 0;
}
void differenceBetweenTimePeriod(struct TIME start, struct TIME stop, struct TIME *diff)
{
if(stop.seconds > start.seconds){
--start.minutes;
start.seconds += 60;
}
diff->seconds = start.seconds - stop.seconds;
if(stop.minutes > start.minutes){
--start.hours;
start.minutes += 60;
}
diff->minutes = start.minutes - stop.minutes;
diff->hours = start.hours - stop.hours;
}
答案：A
A
答案：A
答案：B
答案：A
答案：C
答案：A
答案：D
答案：A
答案：A
答案：D
答案：A
答案：A
答案：A
答案：A
答案：B
答案：A
答案：B
答案：A
答案：A
答案：A
答案：A
答案：B
答案：A
答案：A
答案：A
答案：A
答案：C
答案：A
答案：B
答案：C
答案：D
答案：B
答案：B
答案：A
答案：C
答案：D
答案：A
答案：B
答案：A
答案：C
答案：B
答案：D
答案：A
答案：D
答案：A
答案：D
答案：A
答案：C
答案：B
答案：C
答案：A
答案：C
函数名: cos
头文件：<math.h>
函数原型: double cos(double x);
功 能: 余弦函数
参 数： double x 要操作的弧度
返回值： 返回x弧度的余弦值
公 式： 1°=π/180°弧度
注 意：cos() 是已知一个角的弧度值 x，求该角的余弦值 y
程序例: 求60度角的余弦值,并输出结果
#include<math.h>
#include<stdio.h>
#define PI 3.14159265
int main(void){
double result;
double x = 60*PI/180; //将60度角转换为弧度
result = cos(x);
printf("The cosine of %lf is %lf\n", x, result);
return 0;
}
答案：B
答案：C
答案：C
答案：B
答案：A
答案：D
答案：C
答案：A
答案：D
答案：A
答案：C
答案：C
答案：C
答案：A
答案：B
答案：B
答案：D
答案：A
答案：C
答案：C
答案：C
答案：B
答案：C
答案：A
答案：B
答案：D
答案：C
答案：A
答案：A
答案：D
答案：A
答案：B
答案：C
答案：A
答案：B
答案：A
答案：C
答案：D
答案：A
答案：A
答案：C
答案：A
答案：D
答案：B
答案：A
#include <stdio.h>
#include <stdlib.h> /* exit() 函数 */
int main()
{
char sentence[1000];
FILE *fptr;
fptr = fopen("noobdream.txt", "w");
if(fptr == NULL)
{
printf("Error!");
exit(1);
}
printf("输入字符串:\n");
fgets(sentence, (sizeof sentence / sizeof sentence[0]), stdin);
fprintf(fptr,"%s", sentence);
fclose(fptr);
return 0;
}
#include<stdio.h>
int c = 0;
int i = 1;
int j = 0;
int a[30] = { 0 };
int b[30] = { 0 };
int main()
{
while (i<=31)
{
if (i == 31)
{
i = 1;
}
else if (c == 15)
{
break;
}
else
{
if (b[i] != 0)
{
i++;
continue;
}
else
{
j++;
if (j != 9)
{
i++;
continue;
}
else
{
b[i] = 1;
a[i] = j;
j = 0;
printf("第%d号下船了\n", i);
i++;
c++;
}
}
}
}
}
#include <stdio.h>
int main(){
int n,x,j,k,l,m;
for(n=5;;n++){
j=4*(n-1)/5;
k=4*(j-1)/5;
l=4*(k-1)/5;
m=4*(l-1)/5;
if(n%5==1&&j%5==1&&k%5==1&&l%5==1&&m%5==1){
printf("至少合伙捕鱼：%d条\n",n);
printf("分别见到鱼的条数：%d %d %d %d\n",j,k,l,m);
break;
}
}
return 0;
}
程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列
#include<stdio.h>
int main()
{
int i,j,k;
printf("\n");
for(i=1;i<5;i++) { // 以下为三重循环
for(j=1;j<5;j++) {
for (k=1;k<5;k++) { // 确保i、j、k三位互不相同
if (i!=k&&i!=j&&j!=k) {
printf("%d,%d,%d\n",i,j,k);
}
}
}
}
}
程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。
#include<stdio.h>
int main()
{
double i;
double bonus1,bonus2,bonus4,bonus6,bonus10,bonus;
printf("你的净利润是：\n");
scanf("%lf",&i);
bonus1=100000*0.1;
bonus2=bonus1+100000*0.075;
bonus4=bonus2+200000*0.05;
bonus6=bonus4+200000*0.03;
bonus10=bonus6+400000*0.015;
if(i<=100000) {
bonus=i*0.1;
} else if(i<=200000) {
bonus=bonus1+(i-100000)*0.075;
} else if(i<=400000) {
bonus=bonus2+(i-200000)*0.05;
} else if(i<=600000) {
bonus=bonus4+(i-400000)*0.03;
} else if(i<=1000000) {
bonus=bonus6+(i-600000)*0.015;
} else if(i>1000000) {
bonus=bonus10+(i-1000000)*0.01;
}
printf("提成为：bonus=%lf",bonus);
printf("\n");
}
优化如下:
#include <stdio.h>
#define WAN 10000
int main()
{
double I = 0; // 利润
double B = 0; // 奖金
scanf("%lf", &I);
I /= WAN;
if (I > 100 * WAN)
{
B += ((I - 100) * 0.01);
I = 100;
}
if (I > 60)
{
B += ((I - 60) * 0.015);
I = 60;
}
if (I > 40)
{
B += ((I - 40) * 0.03);
I = 40;
}
if (I > 20)
{
B += ((I - 20) * 0.05);
I = 20;
}
if (I > 10)
{
B += ((I - 10) * 0.075);
I = 10;
}
B += (I * 0.1);
printf("%lf", B);
}
使用循环优化代码的适用性：
#include<stdio.h>
int main()
{
int i;
double lirun;
double jiangjin = 0;
float fanwei[] = {100000, 200000, 400000, 600000, 1000000};
float ticheng[] = {0.1, 0.075, 0.05, 0.03, 0.015, 0.01};
printf("您好，请问您的净利润是多少？\n");
scanf("%lf", &lirun);
for (i=0;i<5;i++)
{
if (lirun < fanwei[i])
{
jiangjin += lirun * ticheng[i];
break;
}
else
{
jiangjin += fanwei[i] * ticheng[i];
lirun -= fanwei[i];
}
}
printf("奖金是%.2lf\n", jiangjin);
return 0;
}
利用 switch 的击穿现象
#include <stdio.h>
int main(){
double d;
int money = 100000;
float res=0.0;
int flag;
scanf("%lf",&d);
flag = (int)(d/money);
flag = flag >10?10:flag;
switch(flag){
case 10:
res += (d-10*money)*0.01;
d = 10*money;
case 9:
case 8:
case 7:
case 6:
res += (d-6*money)*0.015;
d = 6*money;
case 5:
case 4:
res+= (d-4*money)*0.03;
d = 4*money;
case 3:
case 2:
res += (d-2*money)*0.05;
d = 2*money;
case 1:
res += (d-money)*0.075;
d = money;
case 0:
res += d *0.1;
}
printf("%.2f\n",res);
return 0;
}
程序分析：
假设该数为 x。
1、则：x + 100 = n2, x + 100 + 168 = m2
2、计算等式：m2 - n2 = (m + n)(m - n) = 168
3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。
5、从 3 和 4 推导可知道，i 与 j 均是大于等于 2 的偶数。
6、由于 i * j = 168， j>=2，则 1 < i < 168 / 2 + 1。
7、接下来将 i 的所有数字循环计算即可。
#include <stdio.h>
int main (void)
{
int i, j, m, n, x;
for (i = 1; i < 168 / 2 + 1; i++)
{
if (168 % i == 0)
{
j = 168 / i;
if ( i > j && (i + j) % 2 == 0 && (i - j) % 2 == 0)
{
m = (i + j) / 2;
n = (i - j) / 2;
x = n * n - 100;
printf ("%d + 100 = %d * %d\n", x, n, n);
printf ("%d + 268 = %d * %d\n", x, m, m);
}
}
}
return 0;
}
程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天
#include <stdio.h>
int main()
{
int day,month,year,sum,leap;
printf("\n请输入年、月、日，格式为：年,月,日（2015,12,10）\n");
scanf("%d,%d,%d",&year,&month,&day); // 格式为：2015,12,10
switch(month) // 先计算某月以前月份的总天数
{
case 1:sum=0;break;
case 2:sum=31;break;
case 3:sum=59;break;
case 4:sum=90;break;
case 5:sum=120;break;
case 6:sum=151;break;
case 7:sum=181;break;
case 8:sum=212;break;
case 9:sum=243;break;
case 10:sum=273;break;
case 11:sum=304;break;
case 12:sum=334;break;
default:printf("data error");break;
}
sum=sum+day; // 再加上某天的天数
if(year%400==0||(year%4==0&&year%100!=0)) {// 判断是不是闰年
leap=1;
} else {
leap=0;
}
if(leap==1&&month>2) { // *如果是闰年且月份大于2,总天数应该加一天
sum++;
}
printf("这是这一年的第 %d 天。",sum);
printf("\n");
}
程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小
#include <stdio.h>
int main()
{
int x,y,z,t;
printf("\n请输入三个数字:\n");
scanf("%d%d%d",&x,&y,&z);
if (x>y) { /*交换x,y的值*/
t=x;x=y;y=t;
}
if(x>z) { /*交换x,z的值*/
t=z;z=x;x=t;
}
if(y>z) { /*交换z,y的值*/
t=y;y=z;z=t;
}
printf("从小到大排序: %d %d %d\n",x,y,z);
}
程序分析：可先用'*'号在纸上写出字母C，再分行输出
#include "stdio.h"
int main()
{
printf("用 * 号输出字母 C!\n");
printf(" ****\n");
printf(" *\n");
printf(" * \n");
printf(" ****\n");
}
程序分析：分行与列考虑，共 9 行 9 列，i 控制行，j 控制列
#include<stdio.h>
int main()
{
int i,j,result;
printf("\n");
for (i=1;i<10;i++)
{
for(j=1;j<=i;j++)
{
result=i*j;
printf("%d*%d=%-3d",i,j,result); /*-3d表示左对齐，占3位*/
}
printf("\n"); /*每一行后换行*/
}
}
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。
#include <stdio.h>
int main()
{
int i,j;
int count=0;
for (i=101; i<=200; i++)
{
for (j=2; j<i; j++)
{
// 如果j能被i整出在跳出循环
if (i%j==0)
break;
}
// 判断循环是否提前跳出，如果j<i说明在2~j之间,i有可整出的数
if (j>=i)
{
count++;
printf("%d ",i);
// 换行，用count计数，每五个数换行
if (count % 5 == 0)
printf("\n");
}
}
return 0;
}
程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....，即下个月是上两个月之和（从第三个月开始）。
#include<stdio.h>
int main()
{
int f1=1,f2=1,i;
for(i=1;i<=20;i++)
{
printf("%12d%12d",f1,f2);
if(i%2==0) printf("\n");
f1=f1+f2;
f2=f1+f2;
}
return 0;
}
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
- (1)如果这个质数恰等于（小于的时候，继续执行循环）n，则说明分解质因数的过程已经结束，另外 打印出即可。
- (2)但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n.重复执行第二步。
- (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
#include<stdio.h>
int main()
{
int n,i;
printf("请输入整数：");
scanf("%d",&n);
printf("%d=",n);
for(i=2;i<=n;i++)
{
while(n%i==0)
{
printf("%d",i);
n/=i;
if(n!=1) printf("*");
}
}
printf("\n");
return 0;
}
程序分析：关键是计算出每一项的值。
#include<stdio.h>
int main()
{
int s=0,a,n,t;
printf("请输入 a 和 n：\n");
scanf("%d%d",&a,&n);
t=a;
while(n>0)
{
s+=t;
a=a*10;
t+=a;
n--;
}
printf("a+aa+...=%d\n",s);
return 0;
}
#include<stdio.h>
#define N 1000
int main()
{
int i,j,k,n,sum;
int a[256];
for(i=2;i<=N;i++)
{
sum=a[0]=1;
k=0;
for(j=2;j<=(i/2);j++)
{
if(i%j==0)
{
sum+=j;
a[++k]=j;
}
}
if(i==sum)
{
printf("%d=%d",i,a[0]);
for(n=1;n<=k;n++)
printf("+%d",a[n]);
printf("\n");
}
}
return 0;
}
#include<stdio.h>
int main()
{
float h,s;
h=s=100;
h=h/2; //第一次反弹高度
for(int i=2;i<=10;i++)
{
s=s+2*h;
h=h/2;
}
printf("第10次落地时，共经过%f米，第10次反弹高%f米\n",s,h);
return 0;
}
答案 B
答案：A
答案：C
答案：A
答案：B
答案：A
答案：B
答案：B
答案：A
答案：C
答案：A
答案：C
答案：C
答案：B
答案：A
答案：B
答案：B
答案：A
答案：C
答案：D
答案：A
答案：B
答案：A
答案：A
答案：A
答案：B
答案：C
答案：A
答案：D
答案：A
答案：A
答案：C
答案：D
答案：B
答案：A
答案：B
答案：B
答案：A
答案：A
答案：C
答案：A
答案：B
答案：A
答案：B
答案：A
答案：C
答案：A
答案：B
The road of your choice, you have to go on !
粤ICP备16082171号-1
