#include <iostream>
using namespace std;

int main()
{
    // 定义起始年份、结束年份、循环变量以及用于累加的变量，并初始化累加变量为0
    int start, end, i, sum = 0;

    // 从标准输入读取起始年份和结束年份
    cin >> start >> end;

    // 循环遍历从起始年份的下一年到结束年份的前一年
    for (i = start + 1; i < end; i++)
    {
        // 判断当前年份是否为闰年（能被4整除但不能被100整除，或者能被400整除）
        if ((i % 4 == 0 && i % 100!= 0) || i % 400 == 0)
            // 如果是闰年，将该年份累加到sum中
            sum = sum + i;
    }

    // 将累加得到的闰年年份总和输出
    cout << sum;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义用于存储小时、分钟、秒的变量以及用于存储最终总秒数的变量
    int h, m, s, sum;

    // 定义一个字符变量，用于存储表示上午或下午的字符（'A'表示上午，'P'表示下午）
    char c;

    // 从标准输入读取小时、分钟、秒以及表示上午或下午的字符
    cin >> h >> m >> s >> c;

    // 如果读取到的字符是 'A'，表示上午
    if (c == 'A')
        // 将小时、分钟、秒转换为总秒数，计算公式为：小时 * 60 * 60 + 分钟 * 60 + 秒
        sum = h * 60 * 60 + m * 60 + s;
    // 如果读取到的字符不是 'A'，那就认为是 'P'，表示下午
    else
        // 对于下午的时间，先将小时数加上12，再转换为总秒数
        sum = (h + 12) * 60 * 60 + m * 60 + s;

    // 将计算得到的总秒数输出
    cout << sum;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    // 定义变量A用于存储输入的整数，变量C用于统计A的因数个数，初始化为0
    int A, C = 0;

    // 从标准输入读取一个整数赋值给A
    cin >> A;

    // 循环从1到A的平方根（使用sqrt函数获取），这样可以减少循环次数，提高效率
    // 因为一个数的因数是成对出现的，比如对于数n，若i是n的因数，那么n/i也是n的因数
    // 只需要遍历到其平方根即可找到所有因数对中的一个因数
    for (int i = 1; i <= sqrt(A); i++)
    {
        // 如果A能被当前的i整除，说明i是A的一个因数
        if (A % i == 0)
            // 因数个数加1
            C++;
    }

    // 将统计得到的因数个数输出
    cout << C;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量A用于存储年份，变量B用于存储月份，变量day用于存储对应月份的天数
    int A, B, day;

    // 从标准输入读取年份和月份
    cin >> A >> B;

    // 判断月份是否是1、3、5、7、8、10、12月，这些月份每月有31天
    if (B == 1 || B == 3 || B == 5 || B == 7 || B == 8 || B == 10 || B == 12)
        day = 31;
    // 如果不是上述月份，则先默认该月有30天
    else
    {
        day = 30;

        // 判断年份是否为闰年（能被4整除但不能被100整除，或者能被400整除）
        if ((A % 4 == 0 && A % 100!= 0) || A % 400 == 0)
        {
            // 如果是闰年且月份为2月，则2月有29天
            if (B == 2)
                day = 29;
        }
        // 如果不是闰年且月份为2月，则2月有28天
        else
        {
            if (B == 2)
                day = 28;
        }
    }

    // 将计算得到的对应月份的天数输出
    cout << day;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量h和m用于存储起始时间的小时数和分钟数
    // 定义变量H和M用于存储结束时间的小时数和分钟数
    // 定义变量L用于存储计算得到的时间间隔（以分钟为单位）
    int h, m, H, M, L;

    // 从标准输入读取起始时间的小时数和分钟数，以及结束时间的小时数和分钟数
    cin >> h >> m >> H >> M;

    // 计算小时数的差值
    int s = H - h;
    // 计算分钟数的差值
    int t = M - m;

    // 如果分钟数的差值小于0，说明结束时间的分钟数小于起始时间的分钟数
    // 此时需要将小时数的差值减1，并将分钟数的差值加上60来得到正确的时间间隔（以分钟为单位）
    if (t < 0)
        L = (s - 1) * 60 + t + 60;
    // 如果分钟数的差值大于等于0，直接按照正常计算方式得到时间间隔（以分钟为单位）
    else
        L = s * 60 + t;

    // 将计算得到的时间间隔（以分钟为单位）输出
    cout << L;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量n用于存储输入的整数，变量i作为循环变量
    // 变量t用于累加从1到当前循环次数i的值，初始化为0
    // 变量s用于累加每次循环得到的t的值，初始化为0
    int n, i, t = 0, s = 0;

    // 从标准输入读取一个整数赋值给n
    cin >> n;

    // 循环从1到n，每次循环执行以下操作
    for (i = 1; i <= n; i++)
    {
        // 将当前循环次数i累加到t中，这样t就依次变为1、1 + 2、1 + 2 + 3 等
        t = t + i;

        // 将每次更新后的t的值累加到s中，也就是对每次得到的累加和t再进行累加
        s = s + t;
    }

    // 将最终累加得到的s的值输出
    cout << s;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量X、Y、Z、Q分别用于存储从标准输入读取的四个整数
    // 定义变量s用于存储计算结果
    int X, Y, Z, Q, s;

    // 从标准输入读取四个整数，分别赋值给X、Y、Z、Q
    cin >> X >> Y >> Z >> Q;

    // 根据给定的计算规则，用Q减去X乘以2、Y乘以5、Z乘以3的和，得到结果存储在s中
    s = Q - (X * 2 + Y * 5 + Z * 3);

    // 如果计算结果s大于等于0，说明够买
    if (s >= 0)
        // 输出"Yes"，并换行后输出剩余钱s
        cout << "Yes" << "\n" << s;
    // 如果计算结果s小于0，说明不够买
    else
        // 输出"No"，并换行后输出s的绝对值（缺少的钱）
        cout << "No" << "\n" << -s;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
	int X, N;
	cin >> X >> N;
	X = X + N;
	while (X > 7)
		X = X - 7;
	cout << X;
	return 0;
}

#include <iostream>
using namespace std;
int main()
{
	int N, M;
	cin >> N >> M;
	for (int i = 1; i <= N; i++)
	{
		if (i % M != 0)
			cout << i << "\n";
	}
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量m用于存储从标准输入读取的整数，变量count用于记录m中包含13的个数，初始化为0
    int m, count = 0;

    // 从标准输入读取一个整数并赋值给m
    cin >> m;

    // 当m的值大于等于13时，进入循环体执行以下操作
    while (m >= 13)
    {
        // 将m的值减去13，模拟从m中减去一个13的操作
        m = m - 13;

        // 每减去一个13，count的值就增加1，用于记录减去13的次数
        count++;
    }

    // 先将count的值输出，并换行
    cout << count << "\n";

    // 再将最终剩余的m的值输出
    cout << m;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量a用于存储从标准输入读取的整数，变量b作为循环变量
    int a, b;

    // 从标准输入读取一个整数并赋值给a
    cin >> a;

    // 开启一个循环，循环变量b从1开始，每次递增1，直到b的值不超过a
    for (b = 1; b <= a; b++)
    {
        // 判断a除以b的余数是否为0，即判断b是否是a的因数
        if (a % b == 0)
            // 如果b是a的因数，就将b输出，并换行
            cout << b << "\n";
    }

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量h、m、s分别用于存储输入的小时、分钟、秒数
    // 定义变量k用于存储要增加的总秒数
    // 定义变量H、M用于中间计算过程中存储转换得到的小时数和分钟数
    int h, m, s, k;
    int H, M;

    // 从标准输入读取小时、分钟、秒数以及要增加的总秒数
    cin >> h >> m >> s >> k;

    // 将增加的总秒数k转换为分钟数，存储在M中（整除运算得到分钟数）
    M = k / 60;

    // 将增加的总秒数k除以60取余数，得到剩余的秒数，更新k的值
    k = k % 60;

    // 将得到的分钟数M再转换为小时数，存储在H中（整除运算得到小时数）
    H = M / 60;

    // 将原来的秒数s与增加的剩余秒数k相加
    s = s + k;

    // 如果相加后的秒数s大于等于60，说明秒数满60需要进位
    if (s >= 60)
    {
        // 将秒数s减去60，恢复到0到59的范围内
        s = s - 60;

        // 分钟数m增加1，表示秒数进位到分钟数
        m++;
    }

    // 将原来的分钟数m与转换得到的分钟数M相加
    m = m + M;

    // 如果相加后的分钟数m大于等于60，说明分钟数满60需要进位
    if (m >= 60)
    {
        // 将分钟数m减去60，恢复到0到59的范围内
        m = m - 60;

        // 小时数h增加1，表示分钟数进位到小时数
        h++;
    }

    // 将最终得到的小时数h、分钟数m、秒数s输出，中间用空格隔开
    cout << h << " " << m << " " << s;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 定义变量n存储输入的整数，变量x作为循环变量，变量i标记是否找到符合条件的情况，初始化为0
    int n, x, i = 0;

    // 从标准输入读取一个整数并赋值给n
    cin >> n;

    // 开启一个循环，循环变量x从1开始，每次递增1，直到x的值不超过n
    for (x = 1; x <= n; x++)
    {
        // 判断n是否等于x的立方（即x * x * x），如果相等，说明找到了满足条件的x
        if (n == x * x * x)
            // 将i的值设为1，表示找到了符合条件的情况
            i = 1;
    }

    // 根据i的值来判断是否找到了符合条件的情况，如果i等于1，说明找到了
    if (i == 1)
        // 输出"Yes"，表示n是某个整数的立方
        cout << "Yes";
    // 如果i不等于1，说明没有找到符合条件的情况
    else
        // 输出"No"，表示n不是某个整数的立方
        cout << "No";

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
	int n, a, b;
	cin >> n >> a >> b;
	cout << n / (a + b);
	return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    // 定义变量n用于存储输入的整数，表示后续要输入数据的个数
    // 定义变量num用于临时存储数据以及后续统计满足特定条件的个数，初始化为0
    // 定义变量i作为循环变量
    // 定义变量j用于记录已经存入向量A中的元素个数，初始化为0
    int n, num, i, j = 0;

    // 定义一个vector容器A，用于存储长整型数据
    vector<long long> A;

    // 从标准输入读取一个整数n，该整数决定了后续要输入的数据个数
    cin >> n;

    // 循环n次，每次从标准输入读取一个整数num，并将其添加到向量A中，同时更新j的值
    for (i = 0; i < n; i++)
    {
        cin >> num;
        A.push_back(num);
        j++;
    }

    // 将num重新初始化为0，用于统计满足特定条件的元素个数
    num = 0;

    // 循环遍历向量A中的所有元素，循环次数为已经存入的元素个数j
    for (i = 0; i < j; i++)
    {
        // 判断当前元素A[i]是否能被9整除且不能被8整除
        if (A[i] % 9 == 0 && A[i] % 8!= 0)
            // 如果满足条件，将统计个数num的值加1
            num++;
    }

    // 将统计得到的满足特定条件的元素个数num输出
    cout << num;

    // 返回主函数的结束状态，一般0表示正常结束
    return 0;
}

 这一题因有数据规模规定（n无上限），所以选择了用动态数组的方法

 有没听说过或者仍不会用vector的伙伴可以收藏下方的博客学习⬇

C++ vector的超级详细实用用法-CSDN博客