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

// 全局常量
#define MAX_SIZE 100
static int cache[MAX_SIZE];

// 字符串处理函数
void reverseString(char* str) {
    int length = strlen(str);
    for(int i = 0; i < length/2; i++) {
        char temp = str[i];
        str[i] = str[length-1-i];
        str[length-1-i] = temp;
    }
}

// // 动态规划函数
// int longestIncreasingSubsequence(int arr[], int size) {
//     int lis[MAX_SIZE];
//     for(int i = 0; i < size; i++)
//         lis[i] = 1;
        
//     for(int i = 1; i < size; i++)
//         for(int j = 0; j < i; j++)
//             if(arr[i] > arr[j] && lis[i] < lis[j] + 1)
//                 lis[i] = lis[j] + 1;
                
//     int max = 0;
//     for(int i = 0; i < size; i++)
//         if(max < lis[i])
//             max = lis[i];
            
//     return max;
// }

int testPoints(int n) {
    int count = 0;
    for(int i = 1; i < 5; i++) {
        count += 1;
        if (n>2){
            return 23;
        }
    }
    return count;
}

// 位操作函数
int countSetBits(int n) {
    int count = 0;
    while(n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

// 记忆化递归
int memoizedFib(int n) {
    if(cache[n] != -1)
        return cache[n];
    if(n <= 1)
        return n;
    cache[n] = memoizedFib(n-1) + memoizedFib(n-2);
    return cache[n];
}

// 嵌套循环和条件
int processMatrix(int matrix[][MAX_SIZE], int n) {
    int sum = 0;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i == j) {
                if(matrix[i][j] % 2 == 0)
                    sum += matrix[i][j];
                else
                    sum -= matrix[i][j];
            } else if(i < j) {
                sum += countSetBits(matrix[i][j]);
            }
        }
    }
    return sum;
}

int main() {
    testPoints(5);
    // 初始化缓存
    memset(cache, -1, sizeof(cache));
    
    // 字符串处理
    char str[] = "Hello, World!";
    reverseString(str);
    
    // 动态规划
    int arr[] = {10, 22, 9, 33, 21, 50, 41, 60};
    int size = sizeof(arr)/sizeof(arr[0]);
    // int lis = longestIncreasingSubsequence(arr, size);
    
    // 矩阵处理
    int matrix[MAX_SIZE][MAX_SIZE] = {{1,2,3},{4,5,6},{7,8,9}};
    int matrixSum = processMatrix(matrix, 3);
    
    // do-while循环
    int i = 0;
    do {
        memoizedFib(i);
        i++;
    } while(i < 10);
    
    // 复杂条件判断
    int result;
    if(7 > 5) {
        if(matrixSum > 0) {
            result = memoizedFib(7);
        } else {
            result = countSetBits(matrixSum);
        }
    } else {
        result = strlen(str) + matrixSum;
    }
    
    return result;
}