CSP-J/S IS COMING

CSP-J阅读程序基础算法
又到了一年一度的CSP时节了，在这一年，我要报考CSP-J和CSP-S两个考试，希望自己能过吧！不过重点准备的还是CSP-J，希望能出一个好成绩（毕竟历年我的CSP-J复赛都失误了）。现在重点在于准备CSP-J/S的初赛。
今天主要是给大家看阅读程序部分：
接下来的代码块中展示了CSP-J的阅读程序各种算法
CSP-J阅读程序基础算法

复制代码
```cpp
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// 一、基础运算与模拟类

// 1. 数值统计：统计1~n中能被3整除但不能被5整除的数的个数
int countSpecialNumbers(int n) {
    int count = 0;
    for (int i = 1; i <= n; ++i) {
        if (i % 3 == 0 && i % 5 != 0) {
            count++;
        }
    }
    return count;
}

// 2. 数学计算：计算1! + 2! + ... + n!
long long sumFactorials(int n) {
    long long total = 0;
    long long fact = 1;
    for (int i = 1; i <= n; ++i) {
        fact *= i;
        total += fact;
    }
    return total;
}

// 3. 字符串处理：统计字符串中大写字母的个数
int countUpperCase(const string &s) {
    int count = 0;
    for (char c : s) {
        if (c >= 'A' && c <= 'Z') {
            count++;
        }
    }
    return count;
}


// 二、枚举与暴力搜索类

// 1. 寻找完数（完全数）：一个数等于它的所有真因子之和
bool isPerfectNumber(int num) {
    if (num <= 1) return false;
    int sum = 1; // 1是所有大于1的数的真因子
    for (int i = 2; i * i <= num; ++i) {
        if (num % i == 0) {
            sum += i;
            if (i != num / i) {
                sum += num / i;
            }
        }
    }
    return sum == num;
}

// 2. 寻找水仙花数（三位数，各位数字的立方和等于该数本身）
bool isNarcissisticNumber(int num) {
    if (num < 100 || num > 999) return false;
    int a = num / 100;       // 百位
    int b = (num / 10) % 10; // 十位
    int c = num % 10;        // 个位
    return a*a*a + b*b*b + c*c*c == num;
}

// 3. 枚举法求最大公约数
int gcdByEnumeration(int a, int b) {
    int minVal = min(a, b);
    for (int i = minVal; i >= 1; --i) {
        if (a % i == 0 && b % i == 0) {
            return i;
        }
    }
    return 1;
}


// 三、前缀和与差分

// 1. 前缀和：计算区间[l, r]的和（1-based索引）
int rangeSum(const vector<int> &arr, int l, int r) {
    int n = arr.size();
    vector<int> pre(n + 1, 0);
    for (int i = 1; i <= n; ++i) {
        pre[i] = pre[i - 1] + arr[i - 1]; // arr是0-based，pre是1-based
    }
    return pre[r] - pre[l - 1];
}

// 2. 差分：对区间[l, r]加val，然后还原数组（1-based索引）
vector<int> rangeAdd(const vector<int> &arr, int l, int r, int val) {
    int n = arr.size();
    vector<int> diff(n + 2, 0); // 多开两个位置避免越界
    
    // 初始化差分数组
    for (int i = 1; i <= n; ++i) {
        diff[i] = arr[i - 1];
        if (i > 1) {
            diff[i] -= arr[i - 2];
        }
    }
    
    // 区间更新
    diff[l] += val;
    if (r + 1 <= n) {
        diff[r + 1] -= val;
    }
    
    // 还原数组
    vector<int> res(n);
    res[0] = diff[1];
    for (int i = 2; i <= n; ++i) {
        res[i - 1] = res[i - 2] + diff[i];
    }
    return res;
}


// 四、排序与查找

// 1. 冒泡排序
void bubbleSort(vector<int> &arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// 2. 选择排序
void selectionSort(vector<int> &arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; ++i) {
        int minIdx = i;
        for (int j = i + 1; j < n; ++j) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        swap(arr[i], arr[minIdx]);
    }
}

// 3. 二分查找（查找目标值是否存在，返回索引，-1表示不存在）
int binarySearch(const vector<int> &arr, int target) {
    int left = 0, right = arr.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2; // 避免溢出
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}


// 五、递推与递归

// 1. 斐波那契数列（递推版）：f(n) = f(n-1) + f(n-2)，f(1)=f(2)=1
long long fibonacciIterative(int n) {
    if (n <= 2) return 1;
    long long a = 1, b = 1, c;
    for (int i = 3; i <= n; ++i) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

// 2. 斐波那契数列（递归版）
long long fibonacciRecursive(int n) {
    if (n <= 2) return 1;
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

// 3. 阶乘（递归版）
long long factorialRecursive(int n) {
    if (n == 0 || n == 1) return 1;
    return n * factorialRecursive(n - 1);
}

// 4. 组合数（递推版，杨辉三角）
int combination(int n, int k) {
    if (k < 0 || k > n) return 0;
    if (k == 0 || k == n) return 1;
    vector<vector<int>> C(n + 1, vector<int>(k + 1, 0));
    for (int i = 1; i <= n; ++i) {
        C[i][0] = 1;
        for (int j = 1; j <= min(i, k); ++j) {
            C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
        }
    }
    return C[n][k];
}


// 六、其他高频算法

// 1. 辗转相除法求最大公约数
int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 2. 求最小公倍数
int lcm(int a, int b) {
    return a / gcd(a, b) * b; // 先除后乘避免溢出
}

// 3. 十进制转二进制（字符串形式）
string decimalToBinary(int num) {
    if (num == 0) return "0";
    string binary = "";
    bool isNegative = false;
    if (num < 0) {
        isNegative = true;
        num = -num;
    }
    while (num > 0) {
        binary = (num % 2 == 0 ? "0" : "1") + binary;
        num /= 2;
    }
    return isNegative ? "-" + binary : binary;
}

// 4. 二进制转十进制
int binaryToDecimal(const string &binary) {
    int decimal = 0;
    bool isNegative = false;
    int start = 0;
    if (binary[0] == '-') {
        isNegative = true;
        start = 1;
    }
    for (int i = start; i < binary.size(); ++i) {
        decimal = decimal * 2 + (binary[i] - '0');
    }
    return isNegative ? -decimal : decimal;
}

// 5. 贪心算法：找零钱（用尽量少的硬币）
int makeChange(int amount, const vector<int> &coins) {
    // 假设coins已按从大到小排序
    int count = 0;
    for (int coin : coins) {
        while (amount >= coin) {
            amount -= coin;
            count++;
        }
        if (amount == 0) break;
    }
    return amount == 0 ? count : -1; // -1表示无法找零
}

int main() {
    //执行操作
    return 0;
}
感谢大家的关注与支持，博主继续努力的！！！