比特C语言小练

关于switch说法不正确的是：（ C）

A. switct语句中的default子句可以放在任意位置

B. switch语句中case后的表达式只能是整形常量表达式

C. switch语句中case子句必须在default子句之前

D. switch语句中case表达式不要求顺序

答案解析：

A：正确，可以放在任意位置，但是一般建议最好还是放在最后

B：正确，case语句后一般放整形结果的常量表达式或者枚举类型，枚举类型也可以看成是一个特殊的常量

C：错误，没有规定case必须在default之前，一般case最好放在default之前

D：正确，但一般还是按照次序来

switch(c)语句中，c不可以是什么类型（D ）

A. int

B. long

C. char

D. float

答案解析： switch语句中表达式的类型只能是：整形和枚举类型。D选项为浮点类型，不是整形和枚举类型

给定两个数，求两个数的最大公约数

/*
最大公约数：即两个数据中公共约数的最大者。
求解的方式比较多，暴力穷举、辗转相除法、更相减损法、Stein算法算法
此处主要介绍：辗转相除法
思路：
例子：18和24的最大公约数
第一次：a = 18  b = 24  c = a%b = 18%24 = 18
      循环中：a = 24   b=18
第二次：a = 24   b = 18  c = a%b = 24%18 = 6
      循环中：a = 18   b = 6
第三次：a = 18   b = 6   c=a%b = 18%6 = 0
  循环结束 
此时b中的内容即为两个数中的最大公约数。
*/
int main()
{
    int a=0;
    int b=0;
    int c=0;
    scanf("%d %d",&a,&b);
    while(c=a%b)
    {
        a = b;
        b = c;
    }

    printf("%d\n", b);
    return 0;
}

打印1-2023之间的闰年

int main(){
    int year=0;
    int count=0;
    for(year=1;year<=2023;year++){
        if(year%4==0&&year%100!=0){
            printf("%d ",year);
        }
        if(year%400==0){
            printf("%d ",year);
        }
    }
    return 0;
}

打印100-200之间的素数

int main(){
    int i=0;
    int j=0;
    int count=0;
    for(i=101;i<=200;i+=2){    //除了2-3之外，没有两个连续相邻的数据同时为素数 
        for(j=2;j<sqrt(i);j++){
            if(i%j==0){
                break;
            }
        }
        if(j>sqrt(i)){
            count++;
            printf("%d ",i);
        }
    }
    printf("\ncount=%d\n",count);
    return 0;
}

int main()
{
    int i = 0;
    int count = 0;
    // 外层循环用来获取100~200之间的所有数据，100肯定不是素数，因此i从101开始
    for(i=101; i<=200; i++)
    {
        //判断i是否为素数：用[2, i)之间的每个数据去被i除，只要有一个可以被整除，则不是素数
        int j = 0;
        for(j=2; j<i; j++)
        {
            if(i%j == 0)
            {
                break;
            }
        }
        // 上述循环结束之后，如果j和i相等，说明[2, i）之间的所有数据都不能被i整除，则i为素数
        if(j==i)
        {
            count++;
            printf("%d ", i);
        }
    }
    printf("\ncount = %d\n", count);
    return 0;
}

// 方法三：每拿到一个数据，只需要检测其：[2, i/2]区间内是否有元素可以被2i整除即可，可以说明i不是素数
int main()
{
    int i = 0;
    int count = 0;
    for(i=101; i<=200; i++)
    {
        //判断i是否为素数
        //2->i-1
        int j = 0;
        for(j=2; j<=i/2; j++)
        {
            if(i%j == 0)
            {
                break;
            }
        }
        if(j>i/2)
        {
            count++;
            printf("%d ", i);
        }
    }
    printf("\ncount = %d\n", count);
    return 0;
}

输入三个整数，按照从大到小输出

int main()
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d",&a, &b,&c);
    if(a<b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }
    if(a<c)
    {
        int tmp = a;
        a = c;
        c = tmp;
    }
    if(b<c)
    {
        int tmp = b;
        b = c;
        c = tmp;
    }
    printf("a=%d b=%d c=%d\n", a, b, c);
    return 0;
}

打印1-100之间所有3的倍数

/*解题思路：
1. 3的倍数一定能够被3整除，因此i%3==0表达式成立时，则i一定是3的倍数
2. 要输出1~100之间的3的倍数，那只需要从1~100循环100次即可，每次拿到i之后，用i%3==0检测
   如果成立：i是3的倍数，输出
   如果不成立：i不是3的倍数*/
int main()
{
    int i = 0;
    for(i=1; i<=100; i++)
    {
        if(i%3==0)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

二分查找

/*二分查找：
 在一个有序的序列中，找某个数据是否在该集合中，如果在打印该数据在集合中的下标，否则打印找不到
 具体找的方式：
  1. 找到数组的中间位置
  2. 检测中间位置的数据是否与要查找的数据key相等
    a: 相等，找到，打印下标，跳出循环
    b: key < arr[mid], 则key可能在arr[mid]的左半侧，继续到左半侧进行二分查找
    c: key > arr[mid], 则key可能在arr[mid]的右半侧，继续到右半侧进行二分查找
    如果找到返回下标，否则继续，直到区间中没有元素时，说明key不在集合中，打印找不到
 易错点：
 1. right的右半侧区间取值，该值决定了后序的写法
 2. while循环的条件是否有等号
 3. 求中间位置的方法，直接相加除2容易造成溢出
 4. 更改left和right的边界时，不确定是否要+1和-1  */
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int key = 3;
    int left = 0;
    int right = sizeof(arr)/sizeof(arr[0]); // right位置的数据取不到

    while(left<right) // right位置没有数据，此处不需要添加=
    {
        int mid = left+(right-left)/2;
        if(arr[mid]>key) // key小于中间位置数据，说明key可能在左半侧，需要改变右边界
        {
            right = mid; // right位置的数据取不到，因此right=mid，不需要减1
        }
        else if(arr[mid]<key)// key大于中间位置数据，说明key可能在右半侧，需要改变左边界
        {
            left = mid+1; // left位置的数据可以取到，因此left=mid+1
        }
        else
        {
            printf("找到了，下标是：%d\n", mid);
      break;
        }
    }
    if(left>=right)
        printf("找不到\n");
    return 0;
}

猜数字游戏

#include <stdlib.h>
#include <time.h>

void menu()
{
    printf("********************************\n");
    printf("*******     1. play      *******\n");
    printf("*******     0. exit      *******\n");
    printf("********************************\n");
}
void game()
{
    //RAND_MAX-32767
    int ret = rand()%100+1;      //1.生成随机数    讲解rand函数
    int num = 0;
    while(1)  //2.猜数字
    {
        printf("请猜数字:>");
        scanf("%d", &num);
        if(num == ret)
        {
            printf("恭喜你，猜对了\n");
            break;
        }
        else if(num > ret)
        {
            printf("猜大了\n");
        }
        else
        {
            printf("猜小了\n"); 
        }
    }
}
int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));   //讲解srand函数
    do 
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch(input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误\n");
            break;
        }
    } while (input);
    return 0;
}

数一下1-100出现多少个9

/*思路：
1. 给一个循环从1遍历到100，拿到每个数据后进行一下操作
2.  a. 通过%的方式取当前数据的个位，检测个位数据是否为9
         如果是，给计数器加1
    b. 通过/的方式取当前数据的十位，检测十位数据是否是9，
          如果是，给计数器加1
  循环一直继续，直到所有的数据检测完，所有9的个数已经统计在count计数中。*/

int main()
{
    int i = 0;
    int count = 0;
    for(i=1; i<=100; i++)
    {
        if(i%10==9)
            count++;
        if(i/10==9)
            count++;
    }
    printf("%d\n", count);
    return 0;
}

计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值，打印出结果

/*思路：
1. 从上述表达式可以分析出
   a. 该表达式主要由100项，基数项为正，偶数项为负
2. 设置一个循环从1~100，给出表达式中的每一项：1.0/i, 注意此处不能使用1，否则结果全部为0
    然后使用flag标记控制奇偶项，奇数项为正，偶数项为负
    然后将所有的项相加即可*/

int  main()
{
    int i = 0;
    double sum = 0.0;
    int flag = 1;
    for(i=1; i<=100; i++)
    {
        sum += flag*1.0/i;
        flag = -flag;
    }
    printf("%lf\n", sum);
    return 0;
}

求10个整数中的最大值

/*思路：
1. 采用循环的方式输入一个数组
2. 使用max标记数组中的最大值，采用循环的方式依次获取数组中的每个元素，
    与max进行比较，如果arr[i]大于max，更新max标记的最大值，
    数组遍历结束后，max中保存的即为数组中的最大值。*/
int main()
{
    int arr[10] = {0};
    int i = 0;
    int max = 0;
    for(i=0; i<10; i++)
    {
        scanf("%d", &arr[i]);
    }
    max = arr[0];
    for(i=1; i<10; i++)
    {
        if(arr[i]>max)
            max = arr[i];
    }
    printf("max = %d\n", max);
    return 0;
}

九九乘法表

int main(){
    int i=0;
    int j=0;
    for(i=1;i<10;i++){
        for(j=1;j<=i;j++){
            printf("%d*%d=%2d ",i,j,i*j);  //%2d是为了对齐 
        }
        printf("\n");
    }
    return 0;
} 

创建一个函数，判断一个数是否是素数

int is_prime(int n)
{
    int i = 0;
    for(i=2; i<=sqrt(n); i++)
    {
        if(0 == n%i)
        {
            return 0;
        }
    }
    return 1;
}

能把函数处理结果的二个数据返回给主调函数，在下面的方法中不正确的是：（A）

A. return 这二个数

B. 形参用数组

C. 形参用二个指针

D. 用二个全局变量

答案解析：

A：错误，一个函数只能返回一个结果

B：正确，将形参存在数组中，修改数组中内容，可以通过数组将修改结果带出去

C：正确，形参如果用指针，最终指向的是外部的实参，在函数中对指向指向内容进行修改，改变的就是外部的实参

D：正确，全局变量不受函数的结束而结束，在函数中改变全局变量，主调函数中可以看到改变之后的结果

关于实参和形参描述错误的是：（ C）

A. 形参是实参的一份临时拷贝

B. 形参是在函数调用的时候才实例化，才开辟内存空间

C. 改变形参就是改变实参

D. 函数调用如果采用传值调用，改变形参不影响实参

答案解析：

A：正确，传参时不论是按照值还是指针方式传递，形参拿到的都是实参的一份拷贝

B：正确，函数没有调用时，新参没有空间

C：错误，如果是按照值的方式传递，形参和实参各自有各自的空间，改变形参不能改变外部的实参

D：正确，因为形参和实参是两个不同的变量

打印整数二进制的奇数位和偶数位

/*思路：
1. 提取所有的奇数位，如果该位是1，输出1，是0则输出0
2. 以同样的方式提取偶数位置

 检测num中某一位是0还是1的方式：
   1. 将num向右移动i位
   2. 将移完位之后的结果与1按位与，如果：
      结果是0，则第i个比特位是0
      结果是非0，则第i个比特位是1   */
void Printbit(int num)
{
    for(int i=31; i>=1; i-=2)
    {
        printf("%d ", (num>>i)&1);
    }
    printf("\n");
    
    for(int i=30; i>=0; i-=2)
    {
        printf("%d ", (num>>i)&1);
    }
    printf("\n");
}

不允许创建临时变量，交换两个整数的内容

//方法一：
int main()
{
    int a = 10;
    int b = 20;
    printf("交换前:a = %d b = %d\n", a,b);
    a = a^b;
    b = a^b;
    a = a^b;
    printf("交换后:a = %d b = %d\n", a,b);
    return 0;
}

方法二：
int main()
{
    int a;
    int b;
    scanf("%d %d", &a, &b);
    a = a + b;
    b = a - b;
    a = a - b;
    printf("%d %d\n", a, b);
    return 0;
}