【C语言篇】C语言常考及易错题整理DAY3

文章目录

选择题
- 整形提升与算术转换
- 左移右移操作符
- 操作符优先级与结合性
- 后置++
- 指针变量基本知识
编程题
- 最大连续1的个数
- 完全数计算
- 单词倒排
- 面试题.珠玑妙算
- 两数之和

选择题

整形提升与算术转换

声明以下变量，则表达式: ch/i + (f*d – i) 的结果类型为（）

char ch;
int i;
float f;
double d;

A: char

B: int

C: float

D: double

答案解析：

正确答案：D

基本数据类型的等级从低到高如下：char int long float double运算的时候是从低转到高的，表达式的类型会自动提升或者转换为参与表达式求值的最上级类型

相关知识点：整形提升和算术转换在【C语言篇】操作符详解（下篇）有详细介绍

关于代码的说法正确的是（）

#include <stdio.h>
int main()
{
    int x = -1;
    unsigned int y = 2;
    if (x > y)
    {
        printf("x is greater");
    }
    else
    {
        printf("y is greater");
    }
    return 0;
}

A: x is greater

B: y is greater

C: 依赖实现

D: 随机

答案解析：

正确答案：A

x是有符号数-1，内存中是全1，当有符号的x和无符号数进行比较时，x会隐式类型转换被当做无符号数，是一个很大的数，这时就选择A了

其实还是等级的问题，无符号数等级高于同类型的有符号数，在比较或者计算时会先进行转换，同上一道题

左移右移操作符

下面函数的输出结果是（）

void func()
{
    int k = 1^(1 << 31 >> 31);
    printf("%d\n", k);
}

A: 0

B: -1

C: -2

D: 1

答案解析：

正确答案：C

(1 << 31 );左移31位，并在右侧填充0，得到0x80000000，即符号位为1，其他为0，即-2147483648 int k = 1^(1 << 31 >> 31);注意，这里在右移的时候采用的是算术右移，符号位保持为1，右移后填充1，结果为0xFFFFFFFF，即-1， 0x00000001^0xFFFFFFFF，即0xFFFFFFFE(-2)

相关知识点：左移右移操作符在【C语言篇】操作符详解（下篇）也有详细介绍

操作符优先级与结合性

请阅读以下程序，其运行结果是（）

nt main()
{
    char c='A';
    if('0'<=c<='9') printf("YES");
    else printf("NO");
    return 0;
}

A: YES

B: NO

C: YESNO

D: 语句错误

答案解析：

正确答案：A

'0'<=c<='9'并非判断x大于等于字符0，小于等于字符9，而是先执行'0'<=c，使用这个表达式的结果再和'9'比较，'0'的ASCII码值是48，'A'的ASCII码值是’65’，故'0'<c是真值1，即字符9的ASCII码值和1比较，最终是真

后置++

有以下函数，该函数的功能是（）

int fun(char *s)
{
    char *t = s;
    while(*t++)
        ;
    return(t-s);
}

A: 比较两个字符的大小

B: 计算s所指字符串占用内存字节的个数

C: 计算s所指字符串的长度

D: 将s所指字符串复制到字符串t中

答案解析：

正确答案：B

循环在*t为0时停止，同时t++，t最后会停在字符串结束的'\0'之后的一个位置，t作为尾部指针减去头部指针就是整个字符串占用内存的字节数，包含'\0'在内；而c答案字符串长度不包括最后的'\0'

若有“ float a[3]={1.5,2.5,3.5},*pa=a;*(pa++)*=3; ”，则 *pa 的值是（）

A: 1.5

B: 2.5

C: 3.5

D: 4.5

答案解析：

正确答案：B

在*pa=a中指针pa指向a[0]；*(pa++)取pa指向的地址的值；*(pa++)*=3将该值变为原来的3倍，也就是数组a的第一个值为4.5；由于pa++之后pa指针移动了sizeof(float)个字节，所以pa指向a[1],所以值为2.5

指针变量基本知识

以下叙述中正确的是（）

A: 即使不进行强制类型转换，在进行指针赋值运算时，指针变量的基类型也可以不同

B: 如果企图通过一个空指针来访问一个存储单元，将会得到一个出错信息

C: 设变量p是一个指针变量，则语句p=0;是非法的，应该使用p=NULL;

D: 指针变量之间不能用关系运算符进行比较

答案解析：

正确答案：B

A选项描述不正确，不同类型指针一般不可以直接赋值；C选项中，在C语言里p=NULL;和p=0;是等价的；D选项中，指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的位置关系（低地址or高地址）。B选项正确

编程题

最大连续1的个数

给定一个二进制数组 nums ，计算其中最大连续 1 的个数。

示例 1：
输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.
示例 2:
输入：nums = [1,0,1,1,0,1]
输出：2
提示：

1 <= nums.length <= 105
nums[i] 不是 0 就是 1.

这道题思路比较简单，统计连续1的个数，遇到0时表示连续中断，判断如果当前的统计数大于之前最大的则替换，然后继续下一个位置开始的统计即可。

int findMaxConsecutiveOnes(int* nums, int numsSize){
    int max_count = 0, cur_size = 0;;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 1) {
            cur_size++;
        }else {
            max_count = max_count > cur_size ? max_count : cur_size;
            cur_size = 0;
        }
    }
    max_count = max_count > cur_size ? max_count : cur_size;
    return max_count;
}

完全数计算

描述

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。

输入n，请输出n以内(含n)完全数的个数。

数据范围： 1≤n≤5×10⁵

输入描述：

输入一个数字n

输出描述：

输出不超过n的完全数的个数

这道题的关键在于完全数的判断：完全数指的是一个数字的所有约数的和和自身相等。我们只需要从 1 开始将这个数的约数相加求和即可。约数就是能够被数字整除，而这里简化的一个思路是数字能够被整除，则除数和结果就都是约数，这种思路下，只需要从1计算到平方根即可

比如：数字 8 ，能够整除 2 ，结果是 4 ，则除数 2 和结果 4 都是约数，而这两个只需要一次计算判断即可

需要注意的是 4，9，25… 这种，除数和结果相同的情况，则除数或者结果只相加一次就够了。

#include <stdio.h>
#include <math.h>
int is_perfect_num(int num)
{
    int sum = 1;//1是大于等于2的所有数的约数，所以初始值sum设为1
    for (int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) {//判断是否能够整除i，能整除则i和结果都是约数
            sum += i; //与除数相加
            if (i != sqrt(num))//防止除数和结果相同的情况下重复相加
                sum += num / i; //与相除结果相加
        }
    }
    if (sum == num) 
        return 1;
    return 0;
}

int main()
{
    int n;
    while(scanf("%d", &n)==1){
        int count = 0;
        for(int i = 2; i <= n; i++) {//对n以内的数字都进行判断是否是完全数，注意1不参与判断
            if (is_perfect_num(i)) 
                count++;
        }
        printf("%d\n", count);
    }
    return 0;
}

单词倒排

描述

对字符串中的所有单词进行倒排。

说明：

1、构成单词的字符只有26个大写或小写英文字母；

2、非构成单词的字符均视为单词间隔符；

3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；

4、每个单词最长20个字母；

数据范围：字符串长度满足： 1≤n≤10000

输入描述：

输入一行，表示用来倒排的句子

输出描述：

输出句子的倒排结果

示例1

输入：
I am a student
输出：
student a am I
示例2

输入：
$bo*y gi!r#l
输出：
l r gi y bo

创建二维数组，每次读到的单词放到一行，最后逆序输出即可，这里有关scanf的拓展输入用法想了解更多的读者详情请见：【C语言篇】scanf和printf万字超详细介绍（基本加拓展用法）

#include <stdio.h>
int main(){
    char str[500][21]={0};
    int i=0;
    int x;
    while(1){
        x=scanf("%[a-zA-Z]",str[i]);
        if(getchar()=='\n') //这里getchar不仅可以用于结束输入，还能读取scanf不能读取的单词间隔符，让scanf得以成功读取之后的单词
            break;
        if(x)//只要scanf的返回值不为0，说明二维数组这一行成功读取了单词，下一个单词要存在二维数组的下一行
            i++;
    }
    for(int j=i;j>=0;j--){
        printf("%s ",str[j]);//注意最后都是间隔一个空格
    }
    return 0;
}

面试题.珠玑妙算

珠玑妙算游戏（the game of master mind）的玩法如下。

计算机有4个槽，每个槽放一个球，颜色可能是红色（R）、黄色（Y）、绿色（G）或蓝色（B）。例如，计算机可能有RGGB 4种（槽1为红色，槽2、3为绿色，槽4为蓝色）。作为用户，你试图猜出颜色组合。打个比方，你可能会猜YRGB。要是猜对某个槽的颜色，则算一次“猜中”；要是只猜对颜色但槽位猜错了，则算一次“伪猜中”。注意，“猜中”不能算入“伪猜中”。

给定一种颜色组合solution和一个猜测guess，编写一个方法，返回猜中和伪猜中的次数answer，其中answer[0]为猜中的次数，answer[1]为伪猜中的次数。

示例：
输入： solution="RGBY",guess="GGRR"
输出： [1,1]
解释： 猜中1次，伪猜中1次。
提示：

len(solution) = len(guess) = 4
solution和guess仅包含"R","G","B","Y"这4种字符

遍历两个数组，统计猜中次数和伪猜中次数

猜中次数：若位置相同且颜色字符也相同在猜中次数计数器+1

伪猜中次数：颜色相同，但是在不同位置，这时候只需要除去猜中位置之外，统计两个数组中各个字符出现的数量，取较小的一方就是每种颜色伪猜中的数量了

int* masterMind(char* solution, char* guess, int* returnSize){
    *returnSize = 2;
    static int arr[2] = {0};
    arr[0] = 0; arr[1] = 0;//静态空间不会进行二次初始化因此每次重新初始化，也可以使用memset函数
    int s_arr[26] = {0};//26个字符位 solution 四种颜色数量统计
    int g_arr[26] = {0};//26个字符位 guess 四种颜色数量统计
    for (int i = 0; i < 4; i++) {
        if (solution[i] == guess[i]) {
            arr[0] += 1;//位置和颜色完全一致则猜中数量+1
        }else {
            //统计同一位置不同颜色的两组颜色数量，伪猜中不需要对应位置相同，只需要有对应数量的颜色就行
            s_arr[solution[i]-'A'] += 1; //统计solution对应颜色字符出现次数
            g_arr[guess[i]-'A'] += 1;//统计guess对应颜色字符出现次数
        }
    }
    //在两个颜色数量统计数组中查看颜色数量，取相同位置较小的一方就是伪猜中数量
    for (int i = 0; i < 26; i++) {
        arr[1] += s_arr[i] > g_arr[i] ? g_arr[i] : s_arr[i];
    }
    return arr;
}

使用下面写法也是可以的，每次动态申请就不需要初始化，然后先找猜中次数，再统计全部猜中的次数，一减就是伪猜中次数

Mind(char*solution,char*guess,int*returnSize) {
    int* answer = (int*)malloc(sizeof(2*sizeof(int)));
    *returnSize =2;
    intcount1 =0;
    for(inti =0; i <4; i++) {
        if(solution[i] ==guess[i])
            count1++;
    }
    intcount2 =0;
    intharsh[128] = {0};
    for(inti =0; i <4; i++) {
        harsh[solution[i]]++;
    }
    for(inti =0; i <4; i++) {
        if(harsh[guess[i]] ==0)
            continue;
        else{
            harsh[guess[i]]--;
            count2++;
        }
    }
    answer[0] = count1;
    answer[1] = count2 - count1;
    return answer;
}

两数之和

给出一个整型数组 numbers 和一个目标值 target ，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
注意：本题只需要找到第一组符合要求的数据下标即可。不需要返回多组
示例：
输入：
[3,2,4],6
返回值：
[2,3]
说明：因为 2+4=6 ，而 2的下标为2 ， 4的下标为3 ，又因为下标2 < 下标3 ，所以输出[2,3]

在数组中拿到一个数字 num 后，在剩下的数字中查找是否有等于 target - num 的数字即可。

注意题目要求返回的下标从1开始计算

int* twoSum(int* numbers, int numbersLen, int target, int* returnSize ) {
    *returnSize = 2;
    static ret_arr[2] = {0};
    memset(ret_arr, 0x00, sizeof(ret_arr));//静态空间不会二次初始化，因此手动初始化
    for (int i = 0; i < numbersLen; i++) {//从第0个位置开始一个一个数字找
        for (int j = i + 1; j < numbersLen; j++) {//从第一个数字往后的数字中找出另一个数字
            //与numbers[i]相加等于target的数字找到了则i和j就是对应两个数字下标
            if (numbers[i] + numbers[j] == target) {
                ret_arr[0] = i + 1;//题目要求下标从1开始
                ret_arr[1] = j + 1;
                return ret_arr;
            }
        }
    }
    *returnSize = 0;//没有符合的下标则返回数组大小为0；
    return NULL;
}