C语言初阶习题

分支语句习题

1.下面代码的执行结果

#include <stdio.h>
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        if (i = 5)
            printf("%d", i);
    }
    return 0;
}

输出：死循环输出5

分析：i=0时，进行循环判断部分i=0<10，执行循环语句，将i赋值为5并打印输出i,进入循环调整部分：i++ ，6 进入循环判断部分 6<10 ，执行循环语句将i赋值为5并打印输出i,进入循环调整部分：i++ ，6，一直这样5,6死循环下去，所以死循环输出5

2.if语句中0表示假，1表示真 

偏颇的不够准确的说法   正确说法：0表示假，非0表示真

3.switch中的default子句可以放到任意位置                正确

分析：顺序的问题。case语句项与default子句（所有的case语句项不能匹配下执行default子句）顺序可以调换  （这里的任意位置并不是指随意乱放，不是指放到Switch外部。在不能打破原有任务的逻辑下任意调换）

switch中case后表达式只能是整形常量表达式             正确

分析：'a' ， char也属于整型的一种 因为字符存储时存的是ascii码值，归类时char也会归类到整型中去

4.下面代码的执行结果

#include <stdio.h>
int fun(int a)
{
    int b;
    switch (a)
    {
    case 1:
        b = 30;
    case 2:
        b = 20;
    case 3:
        b = 10;
    default:
        b = 0;
    }
    return 不;
}
int main()
{
    printf("%d",fun(1));
    return 0;
}

输出： 0

分析：a=1,进入case 1语句项执行b=30因为后面没有遇到break语句，就进入case 2 执行b=20,没有遇到break语句,再进入 case 3执行b=10,没有遇到break语句,再进入default子句执行b=0，执行完最后一条语句退出Switch语句，返回b=0 ,所以输出b=0

5.switch(c) 其中c不可以是什么类型:

A .int  B.long C.char D.float                            答案：D

6.写代码实现： 三个整数从大到小输出

#include <stdio.h>
void swap(int *px, int *py)
{
    int c = 0;
    c = *px;
    *px = *py;
    *py = c;
}
int main()
{ //三个整数从大到小输出
    int a = 0, b = 0, c = 0;
    //输入
    scanf("%d %d %d", &a, &b, &c);
    //调整   其他方法：1.排序 2.swap()
    int tmp = 0;
    if (a < b)
    {
        /* tmp = a;
         a = b;
         b = tmp;*/
        swap(&a, &b);
    }
    if (a < c)
    {
       /*mp = a;
        a = c;
        c = tmp;*/
       swap(&a, &c);
    }
    if (b < c)
    {
        /*tmp = b;
        b = c;
        c = tmp;*/
        swap(&b, &c);
    }
    //输出
    printf("%d %d %d\n", a, b, c);
    return 0;
}

7.写代码实现打印1~100中3的倍数

#include <stdio.h>
int main()
{
    int i = 0;
    for (i = 1; i <= 100; i++) //法一
    {
        if (i % 3 == 0)
        {
            printf("%d ", i);
        }
    }

    for (i = 3; i <= 100; i += 3) //法二
    {
        if (i % 3 == 0)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

8.求两个数的最大公约数

#include <stdio.h>
int main()
{ //最大公约数
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    //求最大公约数：
    //暴力求解： 一个一个试除 不够高效
    // eg；6和9的最大的公约数：不会超过6 找<=6的所有数字
    //从大到小试除直到找到第一个能被这两个数同时整除的数字：最大公约数
    int m = (a < b) ? a : b; //找出较小值

    while (1)
    {
        if (a % m == 0 && b % m == 0)
        {
            break;
        }
        m--;
    }
    printf("%d\n", m);
    //辗转相除法  效率高
    // eg 24和18的最大公约数    a(24)%b(18)=c(6)    a(a=b)(18)%b(b=c)(6)=c(0)   最大公约数：6 即a%b等于0时b的值 速度很快
    // 输入18 24还满足？18%24=18  a=b=24 b=c=18 发现又交换回来了
    int c = 0;
    while (c = a % b) //优化：省略赋值,直到c=0 退出循环
    {
        // int c = a % b;
        a = b;
        b = c;
    }
    printf("%d\n", b);
    return 0;
}
//递归？

引申：最小公倍数 ？  暴力求解：从两个数里面较大值为起点不断加1试 同时整除的第一个数值，

max%a==0&&max%b==0//暴力求解的核心

效率更高的做法：a*b/最大公约数=最小公倍数

循环语句习题

1.

分析：先判断再执行循环体                              答案B

2.以下程序输出的结果是：

#include <stdio.h>
int main()
{
    int a=0,b=0;
    for(a=1,b=1;a<=100;a++)
    {
        if(b>=20) break;
        if(b%3==1)
        {
            b=b+3;
            continue;
        }
        b=b-5;
    }
    printf("%d\n",a);
    return 0;
}

输出：8

分析：先进入for循环初始化部分，再进入for循环判断部分，a<=100，执行循环语句，b%3==1满足进入第二个分支语句，b=4,continue,跳过本次循环后面的代码来到调整部分，a++,a=2,再继续进入for循环判断部分，以此类推，由上分析，b+=3执行完之后才会来到a++部分，又因为b>=20就可以跳出循环，即b=1+3*7时跳出循环，也就说b+=3执行了7次，那么a++也会执行7次1+1*7=8

3.写代码实现:求1~100中所有整数出现多少个数字9？

#include <stdio.h>
int main()
{ // 1~100中整数出现数字9的个数  十位上数字9  个位上数字9
    int i = 0;
    int count = 0; //计数
    for (i = 1; i <= 100; i++)
    {
        if (i % 10 == 9) //个位上是否为数字9
            count++;
        if (i / 10 == 9) //十位上是否为数字9
            count++;
    }
    printf("count = %d", count);//输出count = 20
    return 0;
}

注意：写成 if  else if这种形式只是一个多分支的if语句，只会选择一个分支进去，只会进去一次  i=99,只计了个位的9，十位9不会进去判断了，就会漏值，所以还是写两个if语句，两个都会进去判断，不会出现差漏

4.分数求和，计算：1/1-1/2+1/3-1/4+1/5+......+1/99-1/100

#include <stdio.h>
int main()
{
    int i = 0;
    double sum = 0;
    int flag = 1; //实现正负交替
    for (i = 1; i <= 100; i++)
    {
        sum = sum + flag * (1.0 / i);
        flag = -flag;
    }
    printf("%lf\n", sum);
    return 0;
}

5.求10个整数中的最大值

#include <stdio.h>
int main()
{ //求10个整数中的最大值
    // int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; //初始化预设十个数
    int arr[10] = {0};
    // 写成arr[]={0} 等价于 arr[1]={0}  输入多个数字会出现数组越界
    int j = 0;
    for (j = 0; j < 10; j++)
    {
        scanf("%d", &arr[j]); //输入10个值
    }
    int max = arr[0];
    int i = 0;
    for (i = 1; i < 10; i++)
    {
        if (max < arr[i])
        {
            max = arr[i];
        }
    }
    printf("%d\n", max);
    return 0;
}

6.打印9*9乘法表

#include <stdio.h>
int main()
{ //打印9*9乘法表
    int i = 0;
    int j = 0;
    for (i = 1; i <= 9; i++) //打印9行
    {
        for (j = 1; j <= i; j++) //打印每一项
        {
            printf("%d*%d=%2d ", i, j, i * j); //%2d打印两位整数（只有一位整数用空格补齐）
                                               //%2d两位右对齐 %-2d两位左对齐
        }
        printf("\n");
    }
    return 0;
}

函数习题

1.

分析：

A return （3，4）； （3，4）被当作一个逗号表达式（从左向右依次计算，整个表达式结果是最后一个表达式结果） 只会返回4（最后一个表达式结果）

B  int arr[ ]本质上是 int* arr(arr是一个指针变量，存放的是数组首元素的地址） arr[0]等价于*(arr+0) , arr[1]等价于*(arr+1)     (arr指向第一个元素 arr+1指向第二个元素）如下图观察调试结果也显示可以将3，4返回到主函数

C 

#include<stdio.h>
void test(int *px, int *py)
{
    *px = 3;
    *py = 4;
}
int main()
{
    int a = 0, b = 0;
    test(&a, &b);
    printf("%d %d\n",a,b);
    return 0;
}

D

#include<stdio.h>
int a = 0, b = 0;
void test()
{
    a=3;
    b=4;
}
int main()
{ 
    test();
    printf("%d %d\n",a,b);
    return 0;
}

2.打印n*n乘法表 (函数实现；能指定行和列)

#include <stdio.h>
void print_table(int n)
{
    int i = 0;
    int j = 0;
    for (i = 1; i <= n; i++) //打印n行
    {
        for (j = 1; j <= i; j++) //打印每一项
        {
            printf("%d*%d=%2d ", i, j, i * j); //%2d打印两位整数（只有一位整数用空格补齐）
                                               //%2d两位右对齐 %-2d两位左对齐
        }
        printf("\n");
    }
}
int main()
{ //打印n*n乘法表 1.函数实现 2.能指定行和列
    int n = 0;
    scanf("%d", &n);
    print_table(n);
    return 0;
}

递归习题

1.字符串逆序(递归实现)

编写一个函数 reverse(char * str) (递归实现)

• 实现: 将參数字符申中的字符反向排列,不是逆打
• 要求: 不能使用C函数库中的字符串操作函数
• 比如：char arr[]="abcdef" 逆序之后数组的內容变成: fedcba

方法一：迭代实现

#include <stdio.h>
#include <string.h>
//字符串逆序  迭代实现
void reverse(char arr[])
{
    int left = 0;
    int right = strlen(arr) - 1;
    // sz-2
    while (left < right) //第n个和倒数n个交换  >=没有可交换的了
    {                    //循环   迭代
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
}

int main()
{ //字符串反向排序（字符串数组存储内容反向） 函数实现
    char arr[] = "abcdef";
    reverse(arr);
    printf("%s\n", arr);
    return 0;
}

方法二：递归实现（只有一个参数）

#include <stdio.h>
#include <string.h>
//只有一个参数 递归实现
int my_strlen(char *str)
{
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

// 字符串逆序
//字符串反向排序（字符串数组存储内容反向） 递归实现
void reverse(char *str)
{ //逆序 abcdef ->交换af+逆序bcde ->交换af 交换be+逆序cd -> 交换af 交换be 交换cd
    // 1.tmp=a a=f (暂时不把a放到f处)2.f=\0(让从b开始向后组成一个字符串)3.逆序bcde 4.f=tmp
    char tmp = *str;
    int len = my_strlen(str);
    *str = *(str + len - 1); //这里不能sizeof求字符串字符串大小，这里数组没有传过来，传的是地址
    *(str + len - 1) = '\0';
    if (my_strlen(str + 1) >= 2) //中间剩一个字符就不用逆序了
        reverse(str + 1);        //要加限制条件否则会死递归
    *(str + len - 1) = tmp;
}

int main()
{
    char arr[] = "abcdef";
    reverse(arr);
    printf("%s\n", arr);
    return 0;
}

方法三：递归实现（多参数）     以下代码是错误示范

#include <stdio.h>
//多参数（arr right left）递归实现
//逆序abcdef :先用left和right锁定的a和f进行交换 逆序bcde (left+1 right-1 再让新left和新right锁定的字符be进行交换 逆序cd)
//直到left >=right 中间没有可以交换元素
//不需要\0找结束位置，直接用left right 限制范围

void reverse(char arr[], int left, int right)
{
    char tmp = arr[left];//元素交换了之后，再判断left<right，满足再次逆序中间的元素
    arr[left] = arr[right];
    arr[right] = tmp;
    if (left < right)
        reverse(arr, left + 1, right - 1);
}

int my_strlen(char *str)
{
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    char arr[] = "abcdef";
    int left = 0;
    int right = my_strlen(arr) - 1;
    reverse(arr, left, right); //将arr中left锁定的元素和right的元素之间的字符串进行逆序
    printf("%s\n", arr);
    return 0;
}

发现cd无法逆序，为什么？同时，当字符串是奇数个字符时又会逆序正确，偶数个字符则会逆序错误？

void reverse(char arr[], int left, int right)
{
    char tmp = arr[left];//元素交换了之后，再判断left<right，满足再次逆序中间的元素
    arr[left] = arr[right];
    arr[right] = tmp;
    if (left < right)
        reverse(arr, left + 1, right - 1);
}

分析：先进行交换，在判断是否有中间元素，有就把中间元素逆序，这个代码思路感觉没有错，用实例来代入一下:

eg “ab"

第一次进入reverse():得到的参数：&arr[0]  left=0 right=1   先进行元素交换（left和right指向的元素进行交换）,交换完为:“ba”,此时left=0 right=1（从main中接收过来一直没有改变left和right的值）满足判断条件，又递归进入reverse()  left + 1, right - 1

第二次进入reverse():得到的参数： &arr[0] left=1 right=0,先进行元素交换,交换完为:“ab”,再进行条件判断，此时left=1 ,right=0递归结束

所以全程一共交换了两次，相当于没有逆序

eg"abc"

第一次进入reverse():得到的参数：&arr[0]  left=0 right=2   先进行元素交换,交换完为:“cba”,此时left=0 right=2 满足递归判断条件，又递归进入reverse()  left + 1, right - 1

第二次进入reverse():得到的参数： &arr[0] left=1 right=1,先进行元素交换,因为此时left和right都指向了同一个元素，交换完还是为:“cba”,再进行条件判断,此时left=1 ,right=1 递归结束

eg"abcd"

第一次进入reverse():得到的参数：&arr[0]  left=0 right=3   先进行元素交换,交换完为:“dbca”,此时left=0 right=3 满足递归判断条件，又递归进入reverse()  left + 1, right - 1

第二次进入reverse():得到的参数： &arr[0] left=1 right=2,先进行元素交换,交换完还是为:“dcba”,此时left=1 ,right=2 满足递归判断条件，又递归进入reverse()  left + 1, right - 1

第三次进入reverse():得到的参数：&arr[0] left=2 right=1,先进行元素交换,交换完为:“dbca”,再进行条件判断，此时left=2 ,right=1递归结束   

中间那个的bc没有逆序

小结：left<right时中间才有元素进行交换，但是上面的程序却在left>=right时仍然进行了一次交换，所以出错了，奇数最后一次交换的是一个元素，相当于没有交换，所以逆序结果还是正确的，偶数是最中间的两个元素交换了两次，所以逆序结果出错

改进：元素进行交换时也放在left<right判断条件下，避免多余的交换

void reverse(char arr[], int left, int right)
{
    if (left < right)
    {
        char tmp = arr[left];//元素交换了之后，再判断left<right，满足再次逆序中间的元素
        arr[left] = arr[right];
        arr[right] = tmp;
        reverse(arr, left + 1, right - 1);
    }
            
}

2.计算一个数的每位之和（递归）：输入非负整数，返回组成它的数字之和

#include <stdio.h>
//#include <stdio.h>
//计算一个数的每位之和（递归）
int DigitSum(unsigned int n) // 1234
{                            // DigitSum(1234)->DigitSum(123)+4->DigitSum(12)+3+4->DigitSum(1)+2+3+4
    if (n > 9)               //两位数及以上才进行拆分 一位数不用拆
        return DigitSum(n / 10) + n % 10;
    else
        return n;
}

int main()
{
    unsigned int n = 0;
    scanf("%u", &n);
    int sum = DigitSum(n);
    printf("%d\n", sum);
    return 0;
}
int DigitSum(unsigned int n) // 1234
{                            // DigitSum(1234)->DigitSum(123)+4->DigitSum(12)+3+4->DigitSum(1)+2+3+4
    if (n > 9)               //两位数及以上才进行拆分 一位数不用拆
        return DigitSum(n / 10) + n % 10;
    else
        return n;
}

int main()
{
    unsigned int n = 0;
    scanf("%u", &n);
    int sum = DigitSum(n);
    printf("%d\n", sum);
    return 0;
}

3.递归实现N的K次方

#include <stdio.h>
//递归实现N的K次方
double Pow(int n, int k)//不要用pow避免与库函数冲突
{                       // Pow(n,k)->n*Pow(n,k-1) （k>0)
                        // k=0   1   k>0 Pow(n,k)  k<0  1.0/Pow(n,-k) 小数
    if (k > 0)
        return Pow(n, k - 1) * n;
    else if (0 == k)
        return 1;
    else
        return 1.0 / Pow(n, -k);
}

int main()
{

    int n = 0;
    int k = 0;
    scanf("%d %d", &n, &k);
    double ret = Pow(n, k);
    printf("%lf\n", ret);
    return 0;
}

4.小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？

输入描述：输入包含一个整数n (1 ≤ n ≤ 30)

输出描述：输出一个整数，即小乐乐可以走的方法数。

分析：n=1 fib(n)=1   n=2  fib(n)=2  n>2 fib(n)=fib(n-1)+fib(n-2) ( fib(n)表示计算走n个台阶的走法 )  走一个台阶：只有一种走法    走两个台阶：只有两种走法(一次走一步，一次走两步)      走10个台阶有 fib(10) 种走法，第一步只走一步，还剩下9阶台阶,有fib(9)种步法；第一步走两步，还剩下8阶台阶，有fib(8)种步法。一共有fib(8)+fib(9)种步法=======> 走n个台阶，有fib(n)种走法，按第一步走一步和第一步走两步两种情况，一共有fib(n-1)+fib(n-2)种步法                                                                                 

#include <stdio.h>

int fib(int n)
{
    if (n <= 2)
        return n;
    else
        return fib(n - 1) + fib(n - 2);
}

int main() 
{
    int n = 0;
    scanf("%d", &n);
    int m = fib(n);
    printf("%d", m);
    return 0;
}

数组习题

1.

分析：答案：C a[10]=2 数组a[10]只有10 个元素下标0~9,此处越界访问了

2.

分析：（3,4）逗号表达式 从左向右依次计算，整个表达式的结果是最后一个表达式结果 （3,4）= 4      答案：B

int arr[] = {1,2,4,5};//{1,2,(3,4),5}  4*4=16byte

补充：

int num = 10;    //num类型是int
int arr[10] = {0}//数组arr类型是int [10](去掉数组名剩下的部分)

//两种等价的写法
printf("%d\n", sizeof(arr));     //数组名 40
printf("%d\n", sizeof(int [10]));//数组的类型 40
//注意10不能省略掉 10也是类型的一部分
printf("%d\n", sizeof(int [5])); //20 换个数字就是另外一个数组的类型

3.

char str[]="hello world";
printf("%d\n",sizeof(str));//12 h e l l o _ w o r l d \0
printf("%d\n",strlen(str));//11 h e l l o _ w o r l d

sizeof是一个操作符，是用来变量或类型（类型不占空间的，还是看的这个类型所创建出来的变量）所占内存空间的大小，不关注内存中存放的具体内容。 单位是字节

strlen（）是一个库函数，是专门求字符串长度的，只能针对字符串，从参数给定的地址向后一直找\0，统计\0之前出现的字符的个数

4.

分析：不是字符串长度，acY没有\0字符串长度是不确定的，可以大于或等于acX   数组长度：数组的元素个数   答案：C

注意：

• 随着数组下标由小变大，数组地址由低到高变化
• int arr[][3]={{0,2},{},{3,4,5}};//错误初始化 中间不能加一个空的{}

5.交换数组：将数组A和数组B的内容进行交换

#include <stdio.h>
int main()
{ //交换数组 （内容进行交换） 两个数组一样大
    int arr1[] = {1, 3, 5, 7, 9};
    int arr2[] = {2, 4, 6, 8, 0};
    /*  //错误的示范
      int tmp[] = {0};
      //1.tmp中就一个元素空间不够
      //2.数组名是首元素地址  地址是一个常量值 不是空间 无法进行交换
      tmp = arr1;
      arr1 = arr2;
      arr2 = tmp;*/
    int i = 0;
    int sz = sizeof(arr1) / sizeof(arr1[0]);
    for (i = 0; i < sz; i++)
    {
        int tmp = arr1[i];
        arr1[i] = arr2[i];
        arr2[i] = tmp;
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr1[i]);
    }
    printf("\n");
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

6.数组操作：创建一个整型数组，完成对数组的操作

1. 实现init()初始化数组为全0
2. 实现print() 打印数组的每个元素
3. 实现reverse() 完成数组元素的逆置

#include <stdio.h>
//数组操作
//初始化函数 初始化为0
//打印函数
//逆置函数
void init(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        arr[i] = 0;
    }
}

void print(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void reverse(int arr[], int sz)
{
    int left = 0;
    int right = sz - 1;
    while (left < right)
    {
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
}

int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    print(arr, sz); //初始化前
    reverse(arr, sz);
    print(arr, sz); //逆序后
    init(arr, sz);
    print(arr, sz); //初始化后
    return 0;
}

7.有一个整数序列（可能有重复的整数），现删除指定的某一个整数，输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。

输入描述：

• 第一行输入一个整数(0≤N≤50)。
• 第二行输入N个整数，输入用空格分隔的N个整数。
• 第三行输入想要进行删除的一个整数。

输出描述：输出为一行，删除指定数字之后的序列。

#include <stdio.h>

int main() 
{
    int n;
    scanf("%d", &n);
    int arr[n];//支持c99
   // int arr[50] = {0};
    int i = 0;
    for (i = 0; i < n; i++) 
    {
        scanf("%d", &arr[i]);
    }
    int del = 0;
    scanf("%d", &del);
    int j = 0; 
    //j作为下标锁定的位置就是用来存放不删除的数据的
    //不需要创建新数组存放
    for (i = 0; i < n; i++) 
    {
        if (arr[i] != del) 
        {
            // arr[j]=arr[i];
            //j++; //两种写法等价
            arr[j++] = arr[i];
        }
    }
    for (i = 0; i < j; i++) 
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

8.输入n个成绩，换行输出n个成绩中最高分数和最低分数的差。

输入描述：

• 两行，第一行为n，表示n个成绩，不会大于10000。
• 第二行为n个成绩（整数表示，范围0~100），以空格隔开。

输出描述：一行，输出n个成绩中最高分数和最低分数的差。

方法一：

#include <stdio.h>

int main() 
{
    int n = 0;
    scanf("%d", &n);
    int arr[n];
    int i=0;
    for(i=0;i<n;i++)
    {
        scanf("%d",&arr[i]);
    }
    int max=arr[0];
    for(i=0;i<n;i++)
    {
        if(arr[i]>max)
        {
            max=arr[i];
        }
    }
    int min=arr[0];
    for(i=0;i<n;i++)
    {
        if(arr[i]<min)
        {
            min=arr[i];
        }
    }
    printf("%d",max-min);
    return 0;
}

方法二：//代码优化

#include <stdio.h>

int main()
{
    int n = 0;
    scanf("%d", &n);
    int arr[n];
    int i = 0;
    int max = 0;
    int min = 100;
    for (i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
        if (arr[i] > max)
            max = arr[i];
        if (arr[i] < min)
            min = arr[i];
    }
    printf("%d", max - min);
    return 0;
}

操作符习题

1.下面代码的结果是（ ）

答案：B 

分析：
c=++a;//先++再使用 a=a+1=6  c=a=6   
b=++c,c++,++a,a++;
//=优先级大于逗号表达式  
//b=++c c=c+1=7 b=c=7
//c++ c=c+1=8      ++a a=a+1=7 a++ a=a+1=8 
b+=a++ + c;
//b=b+(a++)+c=7+8+8=23   a++ a=a+1=9 
//a=9 b=23 c=8

2.统计二进制中1的个数，写一个函数返回参数二进制中1的个数

#include <stdio.h>
//方法1
/*int count_1(unsigned int n)
{ // 10 二进制：1010   十进制 %10 /10取出十进制每一位  1234   二进制：%2 /2 得到二进制每一位
	// 10%2=0  10/2=5  5%2=1  5/2=2  2%2=0  2/2=1  1%2=1  1/2=0
	//取出二进制的每一位就是取模的值  从最后一位开始
	int count = 0;
	while (n)
	{
		if (n % 2 == 1)
			count++;
		n /= 2;
	}
	return count;
}*/
//问题：输入负整数出错
// eg  -1
// 10000000 00000000 00000000 00000001原码
// 11111111 11111111 11111111 11111110 反码
// 11111111 11111111 11111111 11111111 补码
//补码中32个1  按理说应该会输出32 结果却输出0
//改进：形参设置为无符号类型 将传递过来的-1 的补码看成很大的正数(第一位不再看成符号位)

//方法2    负数正数都行
/*int count_1(int n)
{
	int count = 0, i = 0;
	for (i = 0; i < 32; i++)
	{
		if ((n >> i) & 1 == 1)
			//把数字n的二进制数的每一位移到到最低位 &1判断1/0
			count++;
	}
	return count;
}*/

//法1法2效率不高

//方法3
// n=15 
// n=n&(n-1)
//1111  n
//1110  n-1
//1110  n
//1101  n-1
//1100  n
//1011  n-1
//1000  n
//0111  n-1
//0000  n     发现每进行一次按位与就会消失一个1  统计1的个数,可以看这个表达式执行几次即可
//只关注1的个数  效率高

int count_1(int n)
{
	int count = 0;
	while (n)
	{
		n = n & (n - 1);
		count++;
	}
	return count;
}
//如果想判断一个数是否为2^n
//2^1  2  0010
//2^2  4  0100
//2^3  8  1000  发现2^n中二进制序列始终只有一个1
//if(n&(n-1)==0)  ===>n就是2^n  (n&(n-1)执行一次去掉一个1，而2^n只有一个1) 

int main()
{ //统计二进制中1的个数
	int n;
	scanf("%d", &n);
	int m = count_1(n);
	printf("%d\n", m);
	return 0;
}

3.求两个数二进制中不同的个数

#include <stdio.h>

// 两个int  二进制序列中不同的位数的统计
//方法1
/*int count_diff(int m, int n)
{
    int count = 0, i = 0;
    for (i = 0; i < 32; i++)
    {
        if (((m >> i) & 1) != ((n >> i) & 1))
        {
            count++;
        }
    }
    return count;
}*/

//方法2
int count_diff(int m, int n)
{
    int num = m ^ n;
    //相同为0 相异为1 只关注相异的
    int count = 0;
    while (num)
    {
        num = num & (num - 1);
        count++;
    }
    return count;
}

int main()
{
    int m = 0, n = 0;
    scanf("%d %d", &m, &n);
    int ret = count_diff(m, n);
    printf("%d", ret);
    return 0;
}

4.打印整数二进制的奇数位和偶数位，获取整数的二进制序列中的所有的偶数位和奇数位，分别打印出二进制序列

//假设最低位为第1位
//10
//00000000 00000000 00000000 00001010

#include <stdio.h>
int main()
{
	//获取奇数位数字   第N位来到最低位移动N-1
	int num = 0;
	scanf("%d", &num);
	int i = 0;
	//第31位移动30位到最低位  第1位移动0位到最低位
	for (i = 30; i >= 0; i-=2)
	{
		printf("%d ", ((num >> i) & 1));
	}
  printf("\n");
	//获取偶数位数字
	// 第32位移动31位到最低位  第2位移动1位到最低位
	for (i = 31; i >= 1; i-=2)
	{
		printf("%d ", ((num >> i) & 1));
	}

	return 0;
}

5.

答案：D  分析：vs:4+4+4=12  linux:3+3=6  6+4=10 问题代码

6

//全局变量 静态变量都是放在静态区的  
//全局变量 静态变量不初始化的时候，默认会被初始化为0
//局部变量放在栈区不初始化默认会被初始化为随机值

//sizeof这个操作符计算返回的结果是size_t类型的，是无符号整型的

//表达式中有int和unsigned int会进行算术转换 int -> unsigned int   
//有符号int:-1-->
//无符号int:11111111 11111111 11111111 11111111 看成一个很大的正整数
//10000000 00000000 00000000 00000001 
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111 补码
//答案：

7  打印X形图案

输入描述： 多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。

输出描述： 针对每行输入，输出用“*”组成的X形图案。

#include <stdio.h>

int main() 
{
    int i = 0, j = 0, num = 0;
    while (scanf("%d", &num) != EOF) 
    {
        for (i=0;i<num;i++)
        {
            for(j=0;j<num;j++)
            {
                if(j==i) printf("*");
                else if(j==num-1-i) printf("*");
                else printf(" ");
            }
            printf("\n");
        }
    }
    return 0;
}

指针习题

1.下面代码的结果是

分析：short*类型指针的特点，解引用一次可以访问两个字节  +1一次可以跳过两个字节      数据在内存中存放时，有一个顺序的问题：大小端字节序

整型数据在内存中存放时是倒着存放的

输出00345

2  

输出：6      12     答案：C

3

答案：C          分析：  D指针有关系运算可以比较大小

4

分析：整数在内存中是倒序存放

任何一个变量/表达式都有两个属性：值属性 类型属性  

int a=3;
a+4.5——>值属性:7.5 类型属性double(int算术转换为double+double)
a=3——>值属性：3 类型属性：int
&a——>值属性：a的地址 类型属性：int*

答案：C

5 使用指针打印数组内容

6 字符串逆序

使用scanf(),遇到空格就不读取了所以不用scanf（）用gets()

第一个和最后一个交换，以此类推

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[10001] = {0};
    //接收字符串有空格  使用scanf(),遇到空格就不读取了
    gets(arr);
    int left = 0;
    int right = strlen(arr) - 1;
    while (left < right)
    {
        char tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
    printf("%s\n", arr);
    return 0;
}

7

#include <stdio.h>
int main()
{ //求Sn=a+aa+aaa+aaaa+aaaaa 前5项之和
	int a = 0;
	int n = 0;
	scanf("%d %d", &a, &n);//a代表每一项数字  n：项数
	int i = 0;
	int sum = 0;
	int k = 0;//每一项代表的数字
	for (i = 0; i < n; i++)
	{
		k = k * 10 + 2;
		sum += k;
	}
	printf("%d\n", sum);
	return 0;
}

8   求0~100000的水仙花数并输出：n位数字的各位数字的n次方之和等于本身eg:153=1³+5³+3³

//这里的水仙花数不是严格意义上的水仙花数（水仙花数一般指三位自幂数） 
//12345
#include <stdio.h>
#include <math.h>
//方法一
int main()
{
	int i = 0;
	for (i = 0; i <= 100000; i++)
	{
		//1.计算i是几位数 ->n  2.得到i的每一位 计算n次方之和
	//认为任何数至少是一位数n从1开始
		int n = 1;
		int tmp = i;
		//避免在循环内部改变循环变量 而且下面还要计算i的每一位n次方之和
		while (tmp / 10)
		{
			n++;
			tmp /= 10;
		}
		tmp = i;
		int sum = 0;//每个i都要进行计算不能放到循环外面去
		while (tmp)
		{
			sum += pow(tmp % 10, n);//pow返回类型为double型，会有算术转换造成精度丢失 但是我们知道这里是整数没有误差的
			tmp /= 10;
		}
		if (sum == i)
		{
			printf("%d ",i);
		}

	}
	return 0;
}

//方法二：函数
#include <stdio.h>
#include <math.h>

int if_narcissistic_number(int i)
{

	//1.计算i是几位数 ->n  2.得到i的每一位 计算n次方之和
	//认为任何数至少是一位数n从1开始
	int n = 1;
	int tmp = i;
	//避免在循环内部改变循环变量 而且下面还要计算i的每一位n次方之和
	while (tmp / 10)
	{
		n++;
		tmp /= 10;
	}
	tmp = i;
	int sum = 0;//每个i都要进行计算不能放到循环外面去
	while (tmp)
	{
		sum += pow(tmp % 10, n);//pow返回类型为double型，放到int造成精度丢失 但是我们知道这里是整数没有误差的
		tmp /= 10;
	}
	/*if (sum == i)
	{
		return 1;
	}
	else
	{
		return 0;
	}*/
	//优化
	return sum == i;

}

int main()
{
	int i = 0;
	for (i = 0; i <= 100000; i++)
	{
		if (if_narcissistic_number(i))//_+小写字母的书写习惯
		{
			printf("%d ",i);
		}
	}
	return 0;
}

9   打印菱形

//上+下  上面有line行 下面line-1行
#include <stdio.h>
int main()
{
    //上
    int i = 0;
    int line = 0; //打印上半部分的行数
    scanf("%d", &line);
    for (i = 0; i < line; i++)
    {
        //打印每一行
        int j = 0;
        //打印空格
        for (j = 0; j < line - 1 - i; j++)
        {
            printf(" ");
        }
        //打印*
        for (j = 0; j < 2 * i + 1; j++)
        {
            printf("*");
        }
        printf("\n");
    }

    //下
    for (i = 0; i < line - 1; i++)
    {
        //打印每一行
        int j = 0;
        //打印空格
        for (j = 0; j <= i; j++)
        {
            printf(" ");
        }
        //打印*
        for (j = 0; j < 2 * (line - 1 - i) - 1; j++)
        {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

10

答案：A  分析：int(*arr)[10]：arr是一个数组指针（指向了[10]），指向数组的指针*arr arr与*组合表示arr是指针；数组arr[10] arr与[10]结合表示arr是数组名

结构体习题

1

答案：B  分析：优先级高于* 不加（）就不行 p.a 本身就是错的解引用又用在了a上也是错的

2

分析：输出：wang

3.喝汽水问题

#include <stdio.h>
int main()
{
    int money = 0;
    scanf("%d", &money);
    /*int total = money;//方法一
    int empty = money;
    //置换
    while (empty >= 2)
    {
        total += empty / 2;
        empty = empty % 2 + empty / 2;
    }
    printf("%d\n", total);*/

    //规律  2*money-1  方法二
    if (money > 0)
        printf("%d\n", 2 * money - 1);
    else
        printf("%d\n", 0);

    return 0;
}