01Code编程工作室
01Code编程工作室
01Code编程工作室
01Code编程工作室
01Code编程工作室

GESP二级实操题目解析

题目导航

2023年3月百鸡问题
暴力枚举法
2023年3月画三角形
字符循环输出
2023年6月找素数
素数判断
2023年6月自幂数判断
数位操作
2023年9月小杨的X字矩阵
矩阵填充规则
2023年9月数字黑洞
数字变换
2023年12月小杨做题
条件斐波那契数列
2023年12月小杨的H字矩阵
字符矩阵构造
2024年3月乘法问题
乘积计算与判断
2024年3月小杨的日子矩阵
模式矩阵填充
2024年6月平方之和
枚举法求解
2024年6月计数
数字统计
2024年9月数位之和
数位和计算
2024年9月小杨的N字矩阵
矩阵模式识别
2024年12月寻找数字
枚举法求解
2024年12月数位和
最大数位和
2025年3月等差矩阵
矩阵构造
2025年3月时间跨越
日期时间计算
2025年6月数三角
组合计数
2025年6月幂和数
幂运算与枚举

2023年3月百鸡问题

解题思路

1
暴力枚举法：
  • 使用两层循环枚举公鸡(i)和母鸡(j)的数量
  • 通过 m-i-j 计算小鸡的数量
  • 判断当前组合是否满足：
    • 花费总额等于 n 元
    • 小鸡数量能被 z 整除（因为 z 只小鸡 1 元）

参考代码

#include<bits/stdc++.h>
using namespace std;
int main() {
    int x, y, z, n, m, cnt = 0;
    cin >> x >> y >> z >> n >> m;
    //假设公鸡数量i个，母鸡数量j个
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= m - i; j++) {
            // 关键判断条件：
            // i*x：公鸡花费
            // j*y：母鸡花费
            // (m-i-j)/z：小鸡花费（需要能整除z）
            // (m-i-j)%z == 0：小鸡数量必须能被z整除
            if (i * x + j * y + (m - i - j) / z == n && (m - i - j) % z == 0) {
                cnt++;
            }
        }
    }
    cout<<cnt;
    return 0;
}

关键点解释

  • for (int i = 0; i <= m; i++)：枚举公鸡数量，最多买 m 只
  • for (int j = 0; j <= m - i; j++)：枚举母鸡数量，保证总数不超过 m
  • m - i - j：计算小鸡数量
  • (m - i - j) % z == 0：检查小鸡数量是否能被 z 整除
  • i * x + j * y + (m - i - j) / z == n：检查总花费是否等于 n 元

2023年3月画三角形

解题思路

1
字符循环输出：
  • 使用嵌套循环，外层循环控制行数，内层循环控制每行的字母数
  • 使用一个变量记录当前应该输出的字母，每次输出后递增
  • 当字母超过'Z'时，重新从'A'开始
  • 注意每行输出完成后要换行

参考代码

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    
    char ch = 'A';  // 从字母A开始
    
    // 外层循环控制行数
    for (int i = 1; i <= n; i++) {
        // 内层循环控制每行的字母数
        for (int j = 1; j <= i; j++) {
            cout << ch;
            // 字母递增，超过Z则回到A
            ch = (ch - 'A' + 1) % 26 + 'A';
        }
        cout << endl;  // 每行结束后换行
    }
    
    return 0;
}

代码解析

  • char ch = 'A'：初始化第一个要输出的字符为'A'
  • 外层循环for (int i = 1; i <= n; i++)：控制输出n行
  • 内层循环for (int j = 1; j <= i; j++)：第i行输出i个字符
  • ch = (ch - 'A' + 1) % 26 + 'A'：实现字母的循环递增
    • ch - 'A'将字符转换为0-25的数字
    • + 1表示下一个字母
    • % 26确保超过25时回到0
    • + 'A'将数字转换回字符
  • 每行结束后用cout << endl换行

2023年6月找素数

解题思路

1
素数判断：
  • 遍历区间[A, B]中的每一个数
  • 对每个数判断是否为素数
  • 统计素数的个数
2
判断素数的关键方法：
  • 对于数n，检查从2到√n之间是否有能整除n的数
  • 如果没有，则n是素数；否则不是素数

参考代码

#include <bits/stdc++.h>
using namespace std;

// 判断一个数是否为素数
bool isPrime(int n) {
    // 小于2的数不是素数
    if (n < 2) return false;
    
    // 2是素数
    if (n == 2) return true;
    
    // 偶数(除了2)不是素数
    if (n % 2 == 0) return false;
    
    // 检查从3到√n的所有奇数
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0) return false;
    }
    
    return true;
}

int main() {
    int A, B;
    cin >> A >> B;
    
    int count = 0;
    
    // 遍历区间[A, B]中的每个数
    for (int i = A; i <= B; i++) {
        if (isPrime(i)) {
            count++;
        }
    }
    
    cout << count << endl;
    
    return 0;
}

代码解析

isPrime函数

  • 处理特殊情况：
    • 小于2的数不是素数
    • 2是素数
    • 大于2的偶数不是素数
  • 对于奇数，只需检查从3到√n的奇数是否能整除n：
    • 如果能找到能整除的数，则不是素数
    • 如果找不到，则是素数

主函数逻辑

  • 读入A和B
  • 遍历区间[A, B]中的每个数
  • 调用isPrime函数判断是否为素数
  • 统计素数个数并输出

2023年6月自幂数判断

解题思路

1
自幂数判断：
  • 对于每个输入的数，首先需要确定它的位数N
  • 提取每一位数字，计算N次幂之和
  • 比较幂次和与原数是否相等

参考代码

#include<bits/stdc++.h>
using namespace std;

// 计算一个数的位数
int getDigits(int n) {
    int count = 0;
    while (n > 0) {
        count++;
        n /= 10;
    }
    return count;
}

// 计算数字的各位数字的n次幂之和
int getPowerSum(int num, int n) {
    int sum = 0;
    int temp = num;
    
    while (temp > 0) {
        int digit = temp % 10;
        sum += pow(digit, n);
        temp /= 10;
    }
    
    return sum;
}

// 判断是否为自幂数
bool isNarcissistic(int num) {
    int digits = getDigits(num);
    return getPowerSum(num, digits) == num;
}

int main() {
    int M;
    cin >> M;
    
    for (int i = 0; i < M; i++) {
        int num;
        cin >> num;
        
        if (isNarcissistic(num)) {
            cout << "T" << endl;
        } else {
            cout << "F" << endl;
        }
    }
    
    return 0;
}

代码解析

主要函数说明

  • getDigits函数：
    • 用于计算一个正整数的位数
    • 通过不断除以10来统计位数
  • getPowerSum函数：
    • 计算一个数的各位数字的n次幂之和
    • 使用取模运算提取每一位数字
    • 使用pow函数计算幂次
  • isNarcissistic函数：
    • 判断一个数是否为自幂数
    • 先获取位数，再计算幂次和，最后比较
  • main函数：
    • 读取测试数据个数M
    • 循环处理每个数字并输出结果

2023年9月小杨的X字矩阵

解题思路

1
矩阵填充规则：
  • 使用双重循环遍历N×N矩阵的每个位置
  • 对于位置(i,j)，判断是否满足以下条件之一：
    • i == j：在主对角线上（从左上到右下）
    • i + j == N - 1：在副对角线上（从右上到左下）
  • 如果满足任一条件，则输出"+"，否则输出"-"

参考代码

#include<bits/stdc++.h>
using namespace std;
int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			//判断是否在对角线上
			if (i == j || i + j == n + 1) {
				cout << '+';
			} else {
				cout << '-';
			}
		}
		cout<<endl;
	}
	return 0;
}

关键点分析

以N=5为例：

  • 主对角线：(1,1), (2,2), (3,3), (4,4), (5,5)
  • 副对角线：(1,5), (2,4), (3,3), (4,2), (5,1)
  • 注意中心点(3,3)同时在两条对角线上，但只输出一个"+"即可

2023年9月数字黑洞

核心思路

1
数字黑洞变换：
  • 不断对输入的三位数进行变换，直到得到495为止
  • 每次变换将数字的各位数字重新排列，组成最大数和最小数，然后相减得到新数
  • 统计变换次数并输出

参考代码

#include<bits/stdc++.h>
using namespace std;
int a[3];
int main() {
	int n, cnt = 0;
	cin >> n;
	while (n != 495) {
		//将N的个位，十位，百位分别存放在数组a中
		for (int i = 0; i < 3; i++) {
			a[i] = n % 10;
			n /= 10;
		}
		sort(a, a + 3);
		n = (a[2] * 100 + a[1] * 10 + a[0]) - (a[0] * 100 + a[1] * 10 + a[2]);
		cnt++;
	}
	cout << cnt;
	return 0;
}

2023年12月小杨做题

解析思路

1
条件斐波那契数列求和：
  • 给定前两项aa和bb
  • 后续项按照斐波那契规则生成：F(n) = F(n-1) + F(n-2)
  • 累加过程中遇到以下任一条件则停止：
    • 已经计算了n项
    • 当前项大于等于m
  • 输出累加和

参考代码

#include<bits/stdc++.h>
using namespace std;
int a[10000],c;
int main() {
	int m,n;
	int aa,bb;
	cin>>aa>>bb>>m>>n;
	a[1]=aa;
	a[2]=bb;
	for(int i=1;i<=n;i++){
		if(i>=3) a[i]=a[i-1]+a[i-2];
		c+=a[i];
		if(a[i]>=m) break;
	}
	cout<<c;
	return 0;
}

2023年12月小杨的H字矩阵

解题思路

1
H字矩阵填充规则：
  • 读入N（N为奇数）
  • 遍历每一行（从第1行到第N行）
  • 对于每一行的每个位置（从第1列到第N列）：
    • 如果是第1列或第N列，输出|
    • 如果是中间行且不是第1列和第N列，输出-
    • 其他情况输出a

参考代码

#include <iostream>
using namespace std;

int main() {
    int N;
    cin >> N;
    
    int middleRow = (N + 1) / 2;  // 中间行的行号（从1开始计数）
    
    for (int i = 1; i <= N; i++) {  // 遍历每一行（从1到N）
        for (int j = 1; j <= N; j++) {  // 遍历每一列（从1到N）
            if (j == 1 || j == N) {
                // 最左列或最右列，输出 |
                cout << "|";
            } else if (i == middleRow) {
                // 中间行且不是最左最右列，输出 -
                cout << "-";
            } else {
                // 其他位置，输出 a
                cout << "a";
            }
        }
        cout << endl;  // 每行结束后换行
    }
    
    return 0;
}

2024年3月乘法问题

解题思路

1
乘积计算与判断：
  • 读取正整数个数n
  • 逐个读取每个正整数，并累乘
  • 在累乘过程中检查是否超过1,000,000
  • 如果超过，则标记并继续读取但不再计算（避免溢出）
  • 根据最终结果输出相应内容

参考代码

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    long long product = 1;  // 使用long long防止溢出
    bool exceed = false;    // 标记是否超过1000000
    
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        
        // 如果已经超过了1000000，就不再计算，但要继续读取输入
        if (!exceed) {
            product *= a;
            // 检查是否超过1000000
            if (product > 1000000) {
                exceed = true;
            }
        }
    }
    
    if (exceed) {
        cout << ">1000000" << endl;
    } else {
        cout << product << endl;
    }
    
    return 0;
}

算法思路

  • 使用long long类型存储乘积，防止在计算过程中发生整数溢出
  • 使用布尔变量exceed标记乘积是否超过1,000,000
  • 在循环中一边读取数据一边计算乘积，一旦发现超过限制就停止计算但继续读取
  • 根据最终状态输出结果

2024年3月小杨的日子矩阵

解题思路

1
日子矩阵填充规则：
  • 读入N（N为奇数）
  • 遍历每一行（从第1行到第N行）
  • 对于每一行的每个位置（从第1列到第N列）：
    • 如果是第1列或第N列，输出|
    • 如果是第1行、最后一行或中间行且不是第1列和第N列，输出-
    • 其他情况输出x

参考代码

#include <iostream>
using namespace std;

int main() {
    int N;
    cin >> N;
    
    int middleRow = (N + 1) / 2;  // 中间行的行号（从1开始计数）
    
    for (int i = 1; i <= N; i++) {  // 遍历每一行（从1到N）
        for (int j = 1; j <= N; j++) {  // 遍历每一列（从1到N）
            if (j == 1 || j == N) {
                // 最左列或最右列，输出 |
                cout << "|";
            } else if (i == 1 || i == N || i == middleRow) {
                // 第一行、最后一行或中间行且不是最左最右列，输出 -
                cout << "-";
            } else {
                // 其他位置，输出 x
                cout << "x";
            }
        }
        cout << endl;  // 每行结束后换行
    }
    
    return 0;
}

2024年6月平方之和

解题思路

1
核心思想：

枚举所有可能的x和y组合，检查是否满足x² + y² = n。

2
具体实现：
  • 确定枚举范围：x和y的取值范围都是1到√n，因为如果一个数大于√n，它的平方就超过了n
  • 双重循环枚举：
    • 外层循环枚举x：从1到√n
    • 内层循环枚举y：从x到√n（避免重复，保证x≤y）
  • 条件判断：检查x² + y²是否等于n
  • 提前返回：一旦找到满足条件的组合就返回true，否则返回false
3
优化点：
  • 限制枚举范围到√n，避免不必要的计算
  • 通过y从x开始枚举，避免重复检查相同组合
  • 找到解后立即返回，不继续枚举

参考代码

#include<bits/stdc++.h>
using namespace std;

bool check(int n) {
    int limit = sqrt(n) + 1;  // +1防止精度问题
    for(int i = 1; i <= limit; i++) {
        for(int j = i; j <= limit; j++) {
            if(i * i + j * j == n) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    int n, a;
    cin >> n;
    
    for(int i = 0; i < n; i++) {
        cin >> a;
        if(check(a)) {
            cout << "Yes" << endl; 
        } else {
            cout << "No" << endl; 
        }
    } 
    
    return 0;
}

2024年6月计数

解题思路

1
计数方法：

有两种主要方法：

  • 方法一：逐个数字统计
    • 遍历从1到n的每个数字
    • 对每个数字，统计其中k出现的次数
    • 累加所有次数
  • 方法二：按位统计（更高效）
    • 分别统计个位、十位、百位等各个数位上k出现的次数
    • 通过数学方法计算每一位上k的出现次数

考虑到数据规模较小(n≤1000)，使用方法一即可。

参考代码

#include <iostream>
using namespace std;

// 统计数字num中数字k出现的次数
int countDigit(int num, int k) {
    int count = 0;
    while (num > 0) {
        if (num % 10 == k) {
            count++;
        }
        num /= 10;
    }
    return count;
}

int main() {
    int n, k;
    cin >> n >> k;
    
    int totalCount = 0;
    for (int i = 1; i <= n; i++) {
        totalCount += countDigit(i, k);
    }
    
    cout << totalCount << endl;
    
    return 0;
}

代码解析

算法思路

  • 主循环遍历1到n的每个数字
  • 对每个数字调用countDigit函数统计其中k出现的次数
  • 累加所有次数并输出

关键函数说明

countDigit函数：

  • 功能：统计数字num中数字k出现的次数
  • 实现：通过取模运算获取数字的每一位，与k比较
  • 使用num /= 10逐步去掉已处理的最低位

2024年9月数位之和

算法思路

1
数位和计算：
  • 读取数字个数n
  • 对于每个数字，计算其各位数字之和
  • 判断该和是否能被7整除
  • 输出相应结果

参考代码

#include <iostream>
using namespace std;

// 计算一个数的数位之和
int digitSum(int num) {
    int sum = 0;
    while (num > 0) {
        sum += num % 10;  // 取出个位数加到sum中
        num /= 10;        // 去掉个位数
    }
    return sum;
}

int main() {
    int n;
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        
        // 计算数位之和
        int sum = digitSum(a);
        
        // 判断是否为7的倍数
        if (sum % 7 == 0) {
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
    }
    
    return 0;
}

2024年9月小杨的N字矩阵

解题思路

1
N字矩阵填充规则：

通过观察样例，可以发现 '+' 出现在以下位置：

  • 所有行的第1列（列索引为1，如果从1开始计数）
  • 所有行的最后1列（列索引为n）
  • 对角线位置（行索引等于列索引）

参考代码

#include <bits/stdc++.h>
using namespace std;
int main() {
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			//输出
			if(j==1 || j==n || j==i){
				cout<<"+";
			} 
			else{
				cout<<"-";
			}
		}
		cout<<endl;
	}
	return 0;
}

2024年12月寻找数字

解题思路

1
枚举法求解：
  • 对于每个测试用例，枚举可能的b值
  • 计算b⁴的值并与给定的a比较
  • 找到匹配的b值或确定不存在

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int t;
    cin >> t;
    
    while (t--) {
        long long a;
        cin >> a;
        
        long long b = 1;
        long long result = -1;
        
        // 枚举可能的b值
        while (true) {
            long long power = 1LL * b * b * b * b;  // 计算b^4
            
            if (power == a) {
                result = b;
                break;
            }
            
            if (power > a) {
                break;  // 如果b^4已经大于a，后续的值会更大，可以提前结束
            }
            
            b++;
        }
        
        cout << result << endl;
    }
    
    return 0;
}

代码解析

  1. 输入处理：读取测试数据组数t
  2. 循环处理每组数据：
    • 读取正整数a
    • 从b=1开始枚举
    • 计算b⁴的值
    • 如果b⁴ = a，则找到了答案，记录b并退出循环
    • 如果b⁴ > a，说明不存在满足条件的b，退出循环
    • 否则继续枚举下一个b值
  3. 输出结果：输出找到的b值或-1

时间复杂度分析

  • 单次查询最坏情况需要枚举到∜a，即大约100次操作
  • 总体时间复杂度：O(t × ∜max(a)) = O(10⁵ × 100) = O(10⁷)，在可接受范围内

2024年12月数位和

题目思路解析

1
问题理解：

这是一个求数位和最大值的问题。我们需要：

  • 读取n个正整数
  • 计算每个正整数的数位和（各个数位数字之和）
  • 找出所有数位和中的最大值
2
分析解决思路：

计算一个数的数位和有几种方法：

  1. 字符串方法：将数字转为字符串，遍历每个字符并转为数字相加
  2. 数学方法：通过取模和整除操作逐位提取数字

考虑到数字可能达到10¹²，使用数学方法更合适。

3
数学方法计算数位和：

对于正整数x：

  • x % 10 得到个位数字
  • x / 10 去掉个位数字
  • 重复上述过程直到x为0，将所有得到的数字相加

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    long long max_sum = 0;  // 存储最大的数位和
    
    for (int i = 1; i <= n; i++) {
        long long num;
        cin >> num;
        
        // 计算当前数字的数位和
        long long digit_sum = 0;
        long long temp = num;
        while (temp > 0) {
            digit_sum += temp % 10;  // 取出个位数字并加到数位和中
            temp /= 10;              // 去掉个位数字
        }
        
        // 更新最大数位和
        max_sum = max(max_sum, digit_sum);
    }
    
    cout << max_sum << endl;
    
    return 0;
}

2025年3月等差矩阵

题目思路解析

1
问题理解：

这是一个构造矩阵的问题，需要构造一个n行m列的矩阵，其中每个位置(i,j)的值为i×j，并且每行每列都构成等差数列。

2
分析解决思路：

我们需要按以下步骤处理：

  1. 构造一个n行m列的矩阵
  2. 矩阵第i行第j列的值为i×j
  3. 每行和每列都必须是等差数列
3
验证等差数列性质：

让我们验证为什么填入i×j能满足等差数列的要求：

对于第i行：i×1, i×2, i×3, ..., i×m

  • 相邻两项的差为：i×(j+1) - i×j = i
  • 这是一个公差为i的等差数列 ✓

对于第j列：1×j, 2×j, 3×j, ..., n×j

  • 相邻两项的差为：(i+1)×j - i×j = j
  • 这是一个公差为j的等差数列 ✓
4
解题思路：

直接按照公式matrix[i][j] = i × j来构造矩阵并输出。

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    
    // 构造并输出矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            // 第i行第j列的值为i*j
            cout << i * j;
            
            // 如果不是该行的最后一个元素，输出空格
            if (j < m) {
                cout << " ";
            }
        }
        // 每行结束后换行
        cout << endl;
    }
    
    return 0;
}

2025年3月时间跨越

题目思路解析

1
问题理解：

这是一个日期时间计算问题，需要计算从给定时间经过k小时后的具体时间。主要难点在于处理日期的进位和闰年的判断。

2
分析解决思路：

我们需要按以下步骤处理：

  1. 先处理小时的进位，计算出总小时数后转换为天数和剩余小时数
  2. 处理日期进位，考虑每月天数和闰年
  3. 逐级处理：时→日→月→年
3
关键知识点：
  • 闰年判断规则：
    • 普通闰年：能被4整除但不能被100整除
    • 世纪闰年：能被400整除
  • 每月天数：
    • 1,3,5,7,8,10,12月有31天
    • 4,6,9,11月有30天
    • 2月平年28天，闰年29天

参考代码

#include <bits/stdc++.h>
using namespace std;

// 判断是否为闰年
bool isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// 获取指定年月的天数
int getDaysInMonth(int year, int month) {
    switch (month) {
        case 1: case 3: case 5: case 7: case 8: case 10: case 12:
            return 31;
        case 4: case 6: case 9: case 11:
            return 30;
        case 2:
            return isLeapYear(year) ? 29 : 28;
        default:
            return 0;
    }
}

int main() {
    int y, m, d, h, k;
    cin >> y >> m >> d >> h >> k;
    
    // 先处理小时，计算总共要增加的小时数
    int totalHours = h + k;
    
    // 计算需要增加的天数和剩余小时数
    int addDays = totalHours / 24;
    int newHour = totalHours % 24;
    
    // 从当前日期开始，逐天增加
    int currentYear = y;
    int currentMonth = m;
    int currentDay = d;
    
    // 逐天增加
    for (int i = 0; i < addDays; i++) {
        // 当前月的天数
        int daysInCurrentMonth = getDaysInMonth(currentYear, currentMonth);
        
        // 如果当前日还没到月末
        if (currentDay < daysInCurrentMonth) {
            currentDay++;
        } else {
            // 到月末了，需要进位到下个月
            currentDay = 1;
            if (currentMonth < 12) {
                currentMonth++;
            } else {
                // 到年末了，需要进位到下一年
                currentMonth = 1;
                currentYear++;
            }
        }
    }
    
    cout << currentYear << " " << currentMonth << " " << currentDay << " " << newHour << endl;
    
    return 0;
}

2025年6月数三角

题目思路解析

1
问题理解：

这是一个计算满足条件的直角三角形数量的问题。我们需要找出所有满足条件的直角三角形对(a,b)，使得面积为整数且不重复计数。

2
分析解决思路：
  • 直角三角形两条直角边长度分别为a和b
  • 面积公式：S = (a×b)/2
  • a和b都是不超过n的正整数
  • 面积S必须为整数
  • 相同的三角形不重复计数：(a,b)和(b,a)视为同一个三角形
3
关键分析：

面积S = (a×b)/2为整数的条件是a×b为偶数。

a×b为偶数的情况：

  • a为偶数，b为任意正整数
  • a为奇数，b为偶数

为了避免重复计数，我们可以规定a ≤ b。

4
解题策略：

我们可以枚举所有满足1 ≤ a ≤ b ≤ n的数对(a,b)，并检查a×b是否为偶数。

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int count = 0;
    
    // 枚举所有可能的(a,b)对，且a <= b
    for (int a = 1; a <= n; a++) {
        for (int b = a; b <= n; b++) {
            // 检查面积是否为整数，即a*b是否为偶数
            if ((a * b) % 2 == 0) {
                count++;
            }
        }
    }
    
    cout << count << endl;
    
    return 0;
}

2025年6月幂和数

解题思路

1
问题理解：

需要找出[l,r]范围内满足条件的"幂和数"个数，幂和数定义为能表示为2ˣ + 2ʸ（其中x≤y）的正整数。

2
解决策略：
  1. 预处理所有可能的幂和数（不超过10000）
  2. 使用双重循环枚举所有可能的(x,y)对，其中x≤y
  3. 计算2ˣ + 2ʸ并标记结果
  4. 在[l,r]范围内统计标记为幂和数的个数

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int l, r;
    cin >> l >> r;
    
    bool isPowerSum[10001] = {false};
    
    // 直接枚举2的次幂
    for (int x = 1; x <= 10000; x *= 2) {        // x是2的次幂
        for (int y = x; y <= 10000; y *= 2) {    // y是2的次幂，且y >= x
            int sum = x + y;
            if (sum <= 10000) {
                isPowerSum[sum] = true;
            }
        }
    }
    
    // 统计[l,r]范围内幂和数的个数
    int count = 0;
    for (int i = l; i <= r; i++) {
        if (isPowerSum[i]) {
            count++;
        }
    }
    
    cout << count << endl;
    
    return 0;
}