线上笔试总结

PS：记得的是没答好的，还有很多不会的且忘记了的题目

1、常量指针和指针常量：

区别在于const所修饰的对象

指针常量： int * const p（const修饰的是变量p）只能指向一个对象的指针

指针所指向的地址不可修改，即指针所指的对象不可修改，但是地址内的内容可做修改；

int a，b；
int * const p=&a //指针常量
//那么分为一下两种操作
*p=9;//操作成功
p=&b;//操作错误

常量指针：const int *p / int const *p（const修饰的是int）指向常量的指针

const int *p等同于int const *p原因：C或C++当中const可放在类型的前面或后面，语义不变。

指针所指对象的值不可被修改。

int a，b；
 const int *p=&a //常量指针
//那么分为一下两种操作
*p=9;//操作错误
p=&b;//操作成功

2、IIC的地址位数及其能挂载的从机个数

IIC大多为7位地址模式（也有10位地址模式但其也与7位地址共享同一地址空间）故理论上IIC最多能挂载的从机数目为128个；但是由于IIC总线采用开漏输出与上拉电阻的结构导致每增加一个设备会使总线电容增大（其上限通常为400pF）故一般不会挂载超过20-30个从机。

3、RS-232支持的波特率

RS-232-C标准规定的数据传输速率为每秒50、75、100、150、300、600、1200、2400、4800、9600、19200波特。（1969年）

仅全双工通信仅支持1对1；传输距离短。单端信号（TX/RX）

拓展：RS485：

支持半双工和全双工，通信距离最长可达1200m，差分信号，RS485 的数据最高传输速率为 10Mbps 。

4、编程题：设计一个函数，判断传入的字符串是否为回文数，若是则返回其本身，若不是则返回它的最短回文数；1001返回1001；2000返回20002；

后续回顾自己的解法存在很多漏洞完全错误，确实也是因为没有刷过算法题，而且基础不牢学得不够深；我用到算法的地方不多，用过一些滤波算法都是让AI帮忙设计的。

以下是我让ai写的，采用双指针的方法

char *shortestPalindrome(char *s)
{
    // 获取字符串长度
    int n = 0;
    for (; s[n] != '\0'; n++) ;

    // 检查整个字符串是否为回文
    int is_palindrome = 1;
    for (int i = 0; i < n / 2; i++)
    {
        if (s[i] != s[n - 1 - i])
        {
            is_palindrome = 0;
            break;
        }
    }

    if (is_palindrome)
    {
        char *result = (char *)malloc(n + 1);
        for (int i = 0; i <= n; i++)
        {
            result[i] = s[i];
        }
        return result;
    }

    // 寻找最小的k使得s[k:n]是回文
    int k = 1;
    for (; k <= n; k++)
    {
        int valid = 1;
        int len = n - k;
        for (int i = 0; i < len / 2; i++)
        {
            if (s[k + i] != s[k + len - 1 - i])
            {
                valid = 0;
                break;
            }
        }
        if (valid)
            break;
    }

    // 创建结果字符串
    char *result = (char *)malloc(n + k + 1);

    // 复制原字符串
    for (int i = 0; i < n; i++)
    {
        result[i] = s[i];
    }

    // 添加反转的前k个字符
    for (int i = 0; i < k; i++)
    {
        result[n + i] = s[k - 1 - i];
    }
    result[n + k] = '\0';

    return result;
}

代码的核心思想是在不是回文数的时候寻找到最小K使得s[k] ~ s[n]为回文数，其中

if (s[k + i] != s[k + len - 1 - i])

通过左右指针检查有无回文数，若不相等则说明不是回文数，右指针往后一位继续检查后面是否存在回文数，如果存在回文数则不会进入if判断value保持为1跳出k循环，s[k] ~ s[n]就是回文数子串；如果一直都没有回文数直到len/2 = 0；将不会进入i循环value值为1跳出循环，那么此时n-k = 1;也就是说回文子串只有一个数s[n]。

最后再将除去最小回文子串的前K个字符添加到原字符串后方就可得到最短回文数。

5、编程题：设计一个函数判定传入的字符串1是否能由字符串2拆分构成；例如字符串1："abc"字符串2："bdfac"返回true；"adc"和"abret"返回false。(有点记不清楚了)

bool canBeFormed(const char *s1, const char *s2)
{
    int len1 = strlen(s1);
    int len2 = strlen(s2);

    // 如果s1比s2长，肯定无法构成
    if (len1 > len2)
    {
        return false;
    }

    // 创建ASCII字符计数数组（0-127）
    int count[128] = {0}; // 初始化为0

    // 统计s2中的字符
    for (int i = 0; i < len2; i++)
    {
        char c = s2[i];
        count[(int)c]++;
    }

    // 检查s1中的字符是否都存在于s2中
    for (int i = 0; i < len1; i++)
    {
        char c = s1[i];
        count[(int)c]--;

        // 如果出现负值，说明s2中该字符不足
        if (count[(int)c] < 0)
        {
            return false;
        }
    }

    return true;
}

代码的核心思想：将char型转成int型（巧妙利用ASCII码判定）

另一种解法结构体数组保存字符并记录字符出现的次数：

typedef struct {
    char character;
    int count_s1;
    int count_s2;
} CharCount;

bool canBeFormed(const char *s1, const char *s2) {
    // 1. 获取字符串长度
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    
    // 2. 处理边界情况
    if (len1 > len2) return false;    // s1 比 s2 长，不可能构成
    if (len1 == 0) return true;       // s1 为空字符串，总是能构成
    
    // 3. 创建字符频率列表（最坏情况：s1 中所有字符都不相同）
    CharCount* list = (CharCount*)malloc(len1 * sizeof(CharCount));
    if (!list) return false;  // 内存分配失败
    
    int distinct_count = 0;  // 记录列表中不同字符的数量
    
    // 4. 统计 s1 中字符频率
    for (int i = 0; i < len1; ++i) {
        char c = s1[i];  // 当前字符
        bool found = false;
        
        // 检查字符是否已在列表中
        for (int j = 0; j < distinct_count; ++j) {
            if (list[j].character == c) {
                list[j].count_s1++;  // 增加计数
                found = true;
                break;
            }
        }
        
        // 新字符添加到列表
        if (!found) {
            list[distinct_count] = (CharCount){c, 1, 0};
            distinct_count++;
        }
    }
    
    // 5. 统计 s2 中字符频率（仅统计 s1 中存在的字符）
    for (int i = 0; i < len2; ++i) {
        char c = s2[i];
        
        // 在列表中查找当前字符
        for (int j = 0; j < distinct_count; ++j) {
            if (list[j].character == c) {
                list[j].count_s2++;  // 增加 s2 中的计数
                break;  // 找到即退出内层循环
            }
        }
    }
    
    // 6. 检查 s2 字符数量是否足够覆盖 s1
    bool result = true;
    for (int i = 0; i < distinct_count; ++i) {
        if (list[i].count_s2 < list[i].count_s1) {
            result = false;  // 数量不足
            break;
        }
    }
    
    // 7. 释放资源并返回结果
    free(list);
    return result;
}

6、视频题：C语言中Static关键字的作用是什么，一般用于什么场景？

static可用于修饰变量和函数，有状态保持、模块封装、性能优化（只初始化一次）、内存优化等作用。

但是需要注意其在多线程环境下的安全性和对程序的影响；

（静态局部变量）：

当 static 用于函数内部的局部变量时，该变量的生命周期变为整个程序的执行期间（即它在程序启

动时被初始化，在程序结束时才被销毁），而不是每次函数调用时创建、调用结束销毁。嵌入式当

中静态局部变量常用于中断服务程序（ISR）中，用于在多次中断调用中保持某些状态。

（静态全局变量）：

当static用于全局变量（在函数外部）时，该变量的作用域被限制在定义它的源文件内（即从定义

处开始到文件结尾），其他源文件无法使用 extern 来引用这个变量。可以避免多个源文件中同名全

局变量冲突的问题。

（静态函数）：

当 static 用于函数时，该函数的作用域被限制在定义它的源文件内（即该文件内部可见），其他源

文件不能调用这个函数。可以避免多个源文件中同名函数冲突的问题，也便于封装。