1.输出多少个“=”？

int main()
{
    for(unsigned int i=3;i>=0;i--)
    putchar('=');
}

输出无数个“=”。

循环条件中定义的类型为unsigned int，该类型为无符号整型，无负数形式。即for循环永远成立。

2.下列三种交换整数的方式是如何实现交换的？ 

/* (1) */ int c = a; a = b; b = c;
/* (2) */ a = a - b; b = b + a; a = b - a; 
/* (3) */ a ^= b   ; b ^= a    ; a ^= b; 

（1）通过用中间变量来交换值

（2）利用a与b的差值进行计算，实现交换

（3） 用异或运算将a与b相应位若相同记为0，不同记为1，其值传给a。再将b与a进行异或运算实现b到a的转变，最后用a与b进行异或运算实现a到b的转换。

3.有如下代码段所示的函数 f，当我们执行该函数时，会产生什么样的输出结果？在同一程序中多次执行该函数，输出结果是否一致？ 

void f() { 
    static int a = 0; 
    int b = 0; 
    printf("%d, %d\n", ++a, ++b); 
}

输出为：1,    1

多次执行，b的值不变，而a的值一直递增。

 使用static修饰符定义静态局部变量，它的生命周期是整个应用程序的运行时间，它只会被初始化一次。

4.下面程序段的输出是什么？

int main(void) { 
    printf("%d\n", printf("Xiyou Linux Group2%d", printf(""))); 
}

Xiyou Linux Group2019

 printf的嵌套使用的顺序为：从内向外，从左向右执行。并且该函数的返回值为打印的字符数量，故内层的printf函数中%d输出为0,外层的printf函数中%d输出为19。

5.执行下面的代码段，会输出什么？

int main(int argc, char *argv[]) { 
    char ch = 255; 
    int d = a + 1; 
    printf("%d %d", ch, d); 
}

由于未声明a，编译器会报错。若忽略a，则输出ch的值为-1。 

char占一个字节，其范围是-128～127。255用二进制表示为 1111 1111。因为它是有符号类型，则最前面的1被当作符号位，输出即为-1.

6.执行以下代码段，将产生什么样的输出？

int main(int argc, char *argv[]) { 
    char x = -2, y = 3;
    char t = (++x) | (y++); 
    printf("x = %d, y = %d, t = %d\n", x, y, t); 
    t = (++x) || (y++); 
    printf("x = %d, y = %d, t = %d\n", x, y, t); 
}

x = -1, y = 4, t = -1
x = 0, y = 5, t = 1

 “|”是或运算，++i为先自加，后使用。i++则相反。故  

t=    1111 1111   |   0000 0011   =  1111 1111    

 “||”是“或”。（a）||（b）若a判断为真则不继续判断b的真假，返回为真（即1）。题中  ++x=0  则继续判断y++，同时在做完判断之后使y自加。

 7.下面代码段的输出结果是什么？

#define X a+b
int main(int argc, char *argv[]) { 
    int a = 1, b = 1; 
    printf("%d\n", X*X);
}

 3

C的宏预处理器的工作只是简单的文本搜索和替换，即将代码中的  X*X  替换为  a+b*a+b  ，而不是（a+b）*（a+b）。为防止此类错误发生，可以将宏这样定义：#define X （a+b）

8.请解释下面代码段中每一句的效果。 

int val = 2018; 
int *pi = 2019; 
pi = &val; 
*pi = 0; 

 第一句：声明一个int类型的变量val，并将2018赋值给val。

第二句：声明一个指向int类型的指针，并使该指针指向2019（0x07E3）处。（这样做有风险）

第三句：将val的地址赋值给指针pi。

第四句：将pi所指的地址里的数据修改为0。

9.执行下列程序段，并输入“Xiyou Linux”（不含引号），那么程序的输出结果是什么？

int main(int argc, char *argv[]) { 
     char *p = (char *)malloc(sizeof(char) * 20),
         *q = p; 
     scanf("%s %s", p, q); 
     printf("%s %s\n", p, q); 
}

Linux Linux

 p指向所分配空间的地址，并且声明指针变量q，使其指向p所指的空间。即p，q指向同一个空间。

scanf("%s %s",p,q)在输入Xiyou （以空格结束第一个%s）后改变*p的值，输入Linux （回车）后改变*q的值（其实改变的是同一个地址中的数据），后输入的Linux 覆盖了之前输入的Xiyou，故输出为两个Linux。

10.执行下面的程序段，每次执行的输出结果一致吗？

int main(int argc, char *argv[]) { 
      int a[4] = { 2, 0, 1, 9 }; 
      printf("%p, %p\n", a, &a); 
      printf("%p, %p\n", a + 1, &a + 1); 
}

0x7ffd2ec76b00, 0x7ffd2ec76b00
0x7ffd2ec76b04, 0x7ffd2ec76b10

（本机第一次）

0x7ffe0c0da930, 0x7ffe0c0da930
0x7ffe0c0da934, 0x7ffe0c0da940

（本机第二次）

每次执行输出结果不一致

由于每次执行该程序时，给a分配的内存是动态的，故a的地址一直在变化。

11.斐波那契数列是这样的一串数列：1,1,2,3,5,8,13,......。在这串数列中，第一项、第二项为 1，其他项为前两项之和，该数列的第 x 项可以表示为下面的函数。请根据描述，写出一个程序，使之输入 x 后，能够输出斐波那契数列的第 x 项（其中 x<30)。当你完成之后，你可以尝试使用递归解决这个问题。 

#include<stdio.h>
int f(int n)
{
	if (n <= 2)
		return 1;//当n=1,2时返回值为1，即f(0)=f(1)=f(2)=1
	else
		return f(n - 1) + f(n - 2);//此时n>2，返回前两个数之和
}
int main()
{ 
	int n = 0;
	scanf("%d", &n);
	printf("%d\n", f(n));
	return 0;
}

12.下面代码段是某一种排序算法的简单实现，你知道它是什么吗？请讲解其原理，并尝试改进它。

int main(int argc, char *argv[])
{
    int nums[6] = {6, 3, 2, 4, 5, 1};
    for (int i = 0; i < 6; i++)
    {
        for (int j = i; j < 6; j++)
        {
            if (nums[i] > nums[j])
            {
                int c = nums[i];
                nums[i] = nums[j];
                nums[j] = c;
            }
        }
    }
}

选择排序。 

原理：逐一与后面数字比较，若该数字大于后面另一个数字，则交换。实现了一次循环将最小值放在第一位。第二次循环实现将第二小的数字放在第二位，以此类推。

优化如下：

int main(){
    int len=sizeof(a)/sizeof(int);
    int t;
    /*初始化左端、右端元素下标*/
    int left = 0;
    int right = len - 1;
    while (left < right){
    	/*初始化最小值、最大值元素的下标*/
        int min = left;
        int max = right;
        for (int i = left; i <= right; i++){
        	/*标记每趟比较中最大值和最小值的元素对应的下标min、max*/
            if (a[i] < a[min])
                min = i;
            if (a[i] > a[max])
                max = i;
        }
        /*最大值放在最右端*/
        int t = a[max];
        a[max] = a[right];
        a[right] = t;
        /*此处是先排最大值的位置，所以得考虑最小值（a[min]）在最大位置（right）的情况*/
        if (min == right)
            min = max;
        /*最小值放在最左端*/
        t = a[min];
        a[min] = a[left];
        a[left] = t;
        /*每趟遍历，元素总个数减少2，左右端各减少1，left和right索引分别向内移动1*/
        left++;
        right--;
    }
}

13.请简单叙述两种字节序（大端、小端）的概念，你的机器是什么字节序？试着写一个 C 语言程序来验证。

大端存储模式：是指数据的低位字节序保存在内存的高地址中，而数据的高位字节序保存在内存的低地址中（高位在前）
小端存储模式：是指数据的低位字节序保存在内存的低地址中，而数据的高位字节序保存在内存的高地址中（低位在前）

#include <stdio.h>
int Check()
{
    union Un
    {
        char c;
        int i;
    }un;
    un.i = 1;
    return un.c;
}

int main()
{
    int c=Check();   
    if (1 == c)
    {
        printf("当前模式为小端存储\n");
    }
    else
    {
        printf("当前模式为大端存储\n");
    }
    return 0;
}

    #include<stdio.h>
    int Check()
    {
        int i = 1;
        return (*((char*)&i));
        //返回1表示小端
        //返回0表示大端
    }
    int main()
    {
        int c = Check();
        if (1 == c)
        {
            printf("小端\n");
        }
        else
        {
            printf("小端\n");
        }
        return 0;
    }

14.以下是在某机器下执行 Linux 命令 ls 的部分输出（有删节），参考该输出，你可以说出哪些关于该命令以及其他 Linux的相关知识？ 

[root@xiyoulinux /]# ls -al 
total 36  
drwxr-xr-x  17 root root  4096 Sep 21 23:45 .  
drwxr-xr-x  17 root root  4096 Sep 21 23:45 ..  
lrwxrwxrwx   1 root root     7 Aug 21 22:21 bin -> usr/bin  
drwxr-xr-x   4 root root  2048 Jan  1  1970 boot  
drwxr-xr-x  21 root root  3580 Nov 21 21:16 dev  
drwxr-xr-x  83 root root  4096 Nov 21 22:12 etc  
drwxr-xr-x   4 root root  4096 Sep 22 00:07 home  
drwxr-xr-x   2 root root  4096 Aug 21 22:21 mnt  
drwxr-x---   9 root root  4096 Nov 19 19:15 root  
dr-xr-xr-x  13 root root     0 Nov 21 21:15 sys  
drwxrwxrwt  10 root root   380 Nov 21 22:30 tmp  
drwxr-xr-x   9 root root  4096 Nov 21 22:12 usr  

该命令显示出指定目录下的内容（包括当前目录中文件及其子目录)。

-al 指查看设备是否具有读写权限。

第一列表示文件类型及权限

第二列表示链接数

第三列表示该文件所有者

第四列表示该文件所属群组

第五列表示文件大小（字节）

后面三列是该文件的最后修改时间

最后一列是文件名称