1. 实现mystrcpy函数

char * mystrcpy(char * strDest, const char * strSrc)
{
    if(NULL == strDest || NULL == strSrc)
    {
        return NULL;
    }
    char * address = strDest;
    while(*strSrc)
    {
        *strDest = *strSrc;
        strDest++;
        strSrc++;
    }
    return address;
}

2. 无符号整型与有符号整型进行运算

void foo(void)
{
    unsigned int a = 6;
    int b = -20;
    (a + b > 6) ? puts(">6") : puts("<6");
}

        答案输出为：“>6”，当表达式中存在有符号类型和无符号类型时，所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。嵌入式系统中频繁用到无符号整形的数据，务必注意。

3. c语言将一个数组原地逆序排放

32bit 整数，高地位互换

在C语言中实现32位整数的高低交换（即反转所有位）可以通过分治法高效完成。

#include <stdint.h>


uint32_t reverse_bits(uint32_t x) 
{

    x = (x >> 16) | (x << 16); // 交换高16位和低16位

    x = ((x & 0xFF00FF00) >> 8) | ((x & 0x00FF00FF) << 8); // 交换每个16位中的8位块

    x = ((x & 0xF0F0F0F0) >> 4) | ((x & 0x0F0F0F0F) << 4); // 交换每个8位中的4位块

    x = ((x & 0xCCCCCCCC) >> 2) | ((x & 0x33333333) << 2); // 交换每个4位中的2位块

    x = ((x & 0xAAAAAAAA) >> 1) | ((x & 0x55555555) << 1); // 交换每个2位中的1位

    return x;

}

### **代码解析**

1. **交换高/低16位**

   `(x >> 16) | (x << 16)`：将高16位与低16位整体交换。

2. **交换每16位中的8位块**

   掩码`0xFF00FF00`和`0x00FF00FF`分别提取高8位和低8位，交换后组合。

3. **交换每8位中的4位块**

   掩码`0xF0F0F0F0`和`0x0F0F0F0F`提取每字节的高4位和低4位，交换后组合。

4. **交换每4位中的2位块**

   掩码`0xCCCCCCCC`和`0x33333333`提取每4位的高2位和低2位，交换后组合。

5. **交换每2位中的1位**

   掩码`0xAAAAAAAA`和`0x55555555`提取每2位的最高位和最低位，交换后组合。

4. 输出1000个质数

5. 数组100个元素，窗口10，求每个窗口平均值。

#include <stdio.h>

void calculateWindowAverages(int arr[], int n, int windowSize) {
    if (n < windowSize) return;
    
    for (int i = 0; i <= n - windowSize; i++) {
        double sum = 0;
        for (int j = 0; j < windowSize; j++) {
            sum += arr[i + j];
        }
        printf("窗口%d-%d的平均值: %.2f\n", i, i+windowSize-1, sum/windowSize);
    }
}

int main() {
    int arr[100];
    // 假设数组已初始化
    calculateWindowAverages(arr, 100, 10);
    return 0;
}

6. 获取最长回文字符串

#include <stdio.h>
#include <string.h>

int longestPalindrome(char *s) {
    int n = strlen(s);
    if (n == 0) return 0;

    int dp[n][n]; // dp[i][j] = 1 表示 s[i..j] 是回文
    memset(dp, 0, sizeof(dp)); // 初始化为 0

    int max_len = 1; // 至少有一个字符的回文

    // 所有单个字符都是回文
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }

    // 检查两个连续字符是否相同
    for (int i = 0; i < n - 1; i++) {
        if (s[i] == s[i + 1]) {
            dp[i][i + 1] = 1;
            max_len = 2;
        }
    }

    // 检查长度 >= 3 的子串
    for (int len = 3; len <= n; len++) {
        for (int i = 0; i <= n - len; i++) {
            int j = i + len - 1; // 子串结束位置
            if (s[i] == s[j] && dp[i + 1][j - 1] == 1) {
                dp[i][j] = 1;
                if (len > max_len) {
                    max_len = len;
                }
            }
        }
    }

    return max_len;
}

int main() {
    printf("%d\n", longestPalindrome("aabbcc"));          // 输出: 2
    printf("%d\n", longestPalindrome("1234321aabbcc"));   // 输出: 7
    printf("%d\n", longestPalindrome("abc12345shfkaaaaaa")); // 输出: 6
    return 0;
}