1、C程序常见的错误分类不包含:( )
A.编译错误
B.链接错误
C.栈溢出
D.运行时错误
答案解析:
栈溢出是运行时错误的一种,因此C程序不会将栈溢出错误单独列出来,栈溢出包含在运行时错误中。
因此:选择C
2、原码、反码、补码说法错误的是( )
A.一个数的原码是这个数直接转换成二进制
B.反码是原码的二进制符号位不变,其他位按位取反
C.补码是反码的二进制加1
D.原码、反码、补码的最高位是0表示负数,最高位是1表示正数
答案解析
ABC正确
D关于符号位的描述说反了:0表示正数,1表示负数
3、关于大小端字节序的描述正确的是( )
A.大小端字节序指的是数据在电脑上存储的二进制位顺序
B.大小端字节序指的是数据在电脑上存储的字节顺序
C.大端字节序是把数据的高字节内容存放到高地址,低字节内容存放在低地址处
D.小端字节序是把数据的高字节内容存放到低地址,低字节内容存放在高地址处
答案解析
A应为B,CD互相说反了。
小端字节序: 低位放在低地址
大端字节序:高位放在低地址
4、unsigned int a= 0x1234;
unsigned char b = *(unsigned char *)&a;
在32位大端模式处理器上变量b等于( )
A.0x00
B.0x12
C.0x34
D.0x1234
答案解析
大端序中,低地址到高地址的四字节十六进制排列分别为00 00 12 34,
其中第一个字节的内容为00,故选A
5、程序的执行结果为( )
int main()
{
unsigned char a = 200;
unsigned char b = 100;
unsigned char c = 0;
c = a + b;
printf(“%d %d”, a+b,c);
return 0;
}
A.300 300
B.44 44
C.300 44
D.44 300
答案解析
说明:printf在传入参数的时候如果是整形会默认传入四字节,所以a+b的结果是用一个四字节的
整数接收的,不会越界。而c已经在c = a + b这一步中丢弃了最高位的1,所以只能是300-256得到
的44了。
※由于printf是可变参数的函数,所以后面参数的类型是未知的,所以甭管你传入的是什么类型,
printf只会根据类型的不同将用两种不同的长度存储。其中8字节的只有long long、float和double
(注意float会处理成double再传入),其他类型都是4字节。所以虽然a + b的类型是char,实际
接收时还是用一个四字节整数接收的。另外,读取时,%lld、%llx等整型方式和%f、%lf等浮点型方
式读8字节,其他读4字节。
6、下面代码的结果是( )
int main()
{
char a[1000] = {0};
int i=0;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));
return 0;
}
A.1000
B.999
C.255
D.256
答案解析(提交后可在已完成作业列表查看答案)
a是字符型数组,strlen找的是第一次出现尾零(即值为0)的位置。考虑到a[i]其实是字符型,
如果要为0,则需要-1-i的低八位要是全0,也就是问题简化成了“寻找当-1-i的结果第一次出现
低八位全部为0的情况时,i的值”(因为字符数组下标为i时第一次出现了尾零,则字符串长度就
是i)。只看低八位的话,此时-1相当于255,所以i==255的时候,-1-i(255-255)的低八位全
部都是0,也就是当i为255的时候,a[i]第一次为0,所以a[i]的长度就是255了,故选C。
7、猜名次
5位运动员参加了10米台跳水比赛,有人让他们预测比赛结果:
A选手说:B第二,我第三;
B选手说:我第二,E第四;
C选手说:我第一,D第二;
D选手说:C最后,我第三;
E选手说:我第四,A第一;
比赛结束后,每位选手都说对了一半,请编程确定比赛的名次。
考虑到一共五个人,直接模拟推理有些太难,计算机最擅长的遍历此时就会派上用场,将每个人
从第1到第5来一遍,则一共会产生5^5种可能性,这个只需要一个5层循环即可搞定。但是这样会
导致一些不期望出现的结果出现,因为我并没有查重,所以会出现两个人抢名次的情况,也就是
两个人或者更多的人名次相同的情况,例如两个第二,三个第三这样的,所以即使满足了条件,
也要查看一下五个人的名次是否重复,这个交给一个函数来执行,只要五个人名次并列,那就
返回0,否则返回1即可。有了这个思路,就能完成以下代码。
#include <stdio.h>
int checkData(int *p)
{
int tmp[7] = { 0 }; //标记表,实际是哈希表的思路。一开始每个元素都是0。
int i;
for (i = 0; i < 5; i++)
{
if (tmp[p[i]]) //如果这个位置的标记已经是1,则代表重复,直接返回0。
{
return 0;
}
tmp[p[i]] = 1; //如果不是,则给这个位置标记为1。
}
return 1; //全部标记完毕也没有出现重复的情况,代表OK。
}
int main()
{
int p[5]; //0 1 2 3 4分别代表a b c d e
for (p[0] = 1; p[0] <= 5; p[0]++)
{
for (p[1] = 1; p[1] <= 5; p[1]++)
{
for (p[2] = 1; p[2] <= 5; p[2]++)
{
for (p[3] = 1; p[3] <= 5; p[3]++)
{
for (p[4] = 1; p[4] <= 5; p[4]++) //五层循环遍历
{
//这里是五个人的描述,由于比较表达式只有0和1两个结果,如果要两个
//条件有且只有一个为真,则可以用比较表达式的值总和为1的方式直接判定。
//别忘了还要判定不能并列。
if ((p[1] == 2) + (p[0] == 3) == 1 && //B第二,我第三
(p[1] == 2) + (p[4] == 4) == 1 && //我第二,E第四
(p[2] == 1) + (p[3] == 2) == 1 && //我第一,D第二
(p[2] == 5) + (p[3] == 3) == 1 && //C最后,我第三
(p[4] == 4) + (p[0] == 1) == 1 && //我第四,A第一
checkData(p) //不能并列
)
{
for (int i = 0; i < 5; i++)
{
printf("%d ", p[i]);
}
putchar('\n');
}
}
}
}
}
}
return 0;
}
※之后为扩展了解内容。
改进一:
检查是否重复的过程,我们是用一个数组来做的,实际每个标签只有0和1两种可能,
没必要一定要用数组做,可以考虑用一个位来做(哈希中的位图),代码如下:
int checkData(int *p)
{
char tmp = 0;
int i;
for (i = 0; i < 5; i++)
{
tmp |= 1 << p[i];
//tmp每次或上一位1,p[i]如果是1~5都有,则1<<1到1<<5都或上的结果将会是
//00111110,如果有并列,则一定会至少却其中一个1,结果就不会是00111110,
//所以可以判断tmp最终的结果是不是这个数字来判断有没有重复。
}
return tmp == 0x3E;
}
改进二:
循环代码又长又难看,可以考虑改成递归:
void diveRank(int * p, int n)
{
if(n >= 5) //此时的n是用来控制循环层数的。
{
if ((p[1] == 2) + (p[0] == 3) == 1 && //B第二,我第三
(p[1] == 2) + (p[4] == 4) == 1 && //我第二,E第四
(p[2] == 1) + (p[3] == 2) == 1 && //我第一,D第二
(p[2] == 5) + (p[3] == 3) == 1 && //C最后,我第三
(p[4] == 4) + (p[0] == 1) == 1 && //我第四,A第一
checkData(p)) //查重
{
for (int i = 0; i < 5; i++)
{
printf("%d ", p[i]);
}
putchar('\n');
}
return;
}
for(p[n] = 1; p[n] <= 5; p[n]++)
{
diveRank(p, n + 1); //通过递归模拟多层循环,每进一次递归相当于进了一层新的循环。
}
}
int main()
{
int p[5];
diveRank(p, 0);
return 0;
}
改进三:
以上的方法只是让代码简单了点,但还是需要5^5次比较,而如果本来就是做1~5的排列组合
的话只需要5!次比较,能极大的减少遍历所需的次数(复杂度由O(n^n)降低为O(n!)),那是
不是可以用一个递归完成对1~5的全排列呢?当然是可以的,所以我们可以进一步优化遍历的
方式,将遍历用的递归程序改成这样:
#include <stdio.h>
void swapArgs(int * a, int * b) //交换函数
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void diveRank(int * p, int n)
{
if(n >= 5) //此时的n也是用来控制循环层数的。
{
if ((p[1] == 2) + (p[0] == 3) == 1 && //B第二,我第三
(p[1] == 2) + (p[4] == 4) == 1 && //我第二,E第四
(p[2] == 1) + (p[3] == 2) == 1 && //我第一,D第二
(p[2] == 5) + (p[3] == 3) == 1 && //C最后,我第三
(p[4] == 4) + (p[0] == 1) == 1) //我第四,A第一
//由于此时是执行的全排列,所以查重也省了。
{
for (int i = 0; i < 5; i++)
{
printf("%d ", p[i]);
}
putchar('\n');
}
return;
}
int i;
for(i = n; i < 5; i++) //这个递归方式就完成了对1~5的全排列,方法是从后向前不停的
//执行交换。可以参考改进二和原代码,将这个递归程序写回成循环后,可以更好的理解。
{
swapArgs(p + i, p + n);
diveRank(p, n + 1);
swapArgs(p + i, p + n);
}
}
int main()
{
int p[5] = { 1, 2, 3, 4, 5 }; //当然由于是全排列,所以初值必须给好。
diveRank(p, 0);
return 0;
}
至此,遍历速度上达到了一个新的高度,这种遍历大大减少了遍历的次数,极大的提升了效率。
8、猜凶手
日本某地发生了一件谋杀案,警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
以下为4个嫌疑犯的供词:
A说:不是我。
B说:是C。
C说:是D。
D说:C在胡说
已知3个人说了真话,1个人说的是假话。
现在请根据这些信息,写一个程序来确定到底谁是凶手。
参考答案
这个题就是按照正常方式,假设凶手是a,b,c,d其中的一个,看是不是满足题目条件,如果满足就
找出了凶手。
#include<stdio.h>
int main()
{
int killer = 0;
//分别假设凶手是a,b,c,d,看谁是凶手时满足3个人说了真话,一个人说了假话
for (killer = 'a'; killer <= 'd'; killer++)
{
if ((killer != 'a') + (killer == 'c') + (killer == 'd') + (killer != 'd') == 3)
printf("凶手是:%c", killer);
}
return 0;
}
9、杨辉三角
在屏幕上打印杨辉三角。
1
1 1
1 2 1
1 3 3 1
……
参考答案
由于此题要打印整个杨辉三角的数据而非取出某一项,所以不可避免的一定是要填出每一项,
没有偷懒的余地,那就老老实实的根据规律填空即可。按照题设的场景,能发现数字规律为:
d[i][j] = d[i - 1][j] + d[i - 1][j - 1]。所以我们只要按照这个方法填表即可。
void yangHuiTriangle(int n)
{
int data[30][30] = { 1 }; //第一行直接填好,播下种子
int i, j;
for (i = 1; i < n; i++) //从第二行开始填
{
data[i][0] = 1; //每行的第一列都没有区别,直接给1,保证不会越界。
for (j = 1; j <= i; j++) //从第二列开始填
{
data[i][j] = data[i - 1][j] + data[i - 1][j - 1]; //递推方程
}
}
for (i = 0; i < n; i++) //填完打印
{
for (j = 0; j <= i; j++)
{
printf("%d ", data[i][j]);
}
putchar('\n');
}
}
改进:
由于我在填第n行的杨辉三角时,只跟第n-1行的杨辉三角产生联系,不会跟之前的有联系,
所以没必要保存每一行的杨辉三角,填一行打一行就行了,这样能让空间复杂度从n^2降低到n。
但是在填数据的时候不能对之前的数据覆盖,所以需要从后向前填。而填杨辉三角顺序对结果是
没有影响的,所以可以实现。
void yangHuiTriangle(int n)
{
int data[30] = { 1 };
int i, j;
printf("1\n"); //第一行就直接打印了
for (i = 1; i < n; i++) //从第二行开始
{
for (j = i; j > 0; j--) //从后向前填,避免上一行的数据在使用前就被覆盖
{
data[j] += data[j - 1]; //公式同上,由于变成了一维,公式也变简单了。
}
for (j = 0; j <= i; j++) //这一行填完就直接打印了。
{
printf("%d ", data[j]);
}
putchar('\n');
}
}
※这种方法虽然降低了空间复杂度,但只能保存最后一行的数据,不利于反复查询,两个填法
各有各的适用场景。就本题而言,改进后的胜出。