东方博宜oj1130-1139
- 1130 - 简单a+b
- 1131 - 删除指定字符
- 1132 - 保留整数
- 1133 - 字符串的反码
- 1134 - 国王的魔镜
- 1135 - 歌德巴赫猜想
- 1136 - 输出m和n范围内的完全数(完美数)
- 1137 - 纯粹素数
- 1138 - 求无暇素数
- 1139 - 孪生素数
- ——————答案与解析分割线——————
- 1130 - 简单a+b 解析
- 1131 - 删除指定字符 解析
- 1132 - 保留整数 解析
- 1133 - 字符串的反码 解析
- 1134 - 国王的魔镜 解析
- 1135 - 歌德巴赫猜想 解析
- 1136 - 输出m和n范围内的完全数(完美数) 解析
- 1137 - 纯粹素数 解析
- 1138 - 求无暇素数 解析
- 1139 - 孪生素数 解析
（作者乞讨ing：“支持一下作者叭，点一个免费的赞让我刷一下数据啊！！！！（无能的狂怒）”）
1130 - 简单a+b
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
// 找到 + 和 = 的位置
int plusPos = s.find('+');
int equalPos = s.find('=');
// 提取两个数字
string num1Str = s.substr(0, plusPos);
string num2Str = s.substr(plusPos + 1, equalPos - plusPos - 1);
// 转换为长整型并计算
long long num1 = stoll(num1Str);
long long num2 = stoll(num2Str);
long long result = num1 + num2;
cout << result << endl;
return 0;
}
1131 - 删除指定字符
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
char c;
cin >> str;
cin >> c;
string result = "";
// 遍历字符串，只添加不等于c的字符
for (int i = 0; i < str.length(); i++) {
if (str[i] != c) {
result += str[i];
}
}
cout << result << endl;
return 0;
}
1132 - 保留整数
#include <iostream>
#include <string>
using namespace std;
int main() {
string str1;
getline(cin, str1);
string str2 = "";
bool inNonDigit = false; // 标记是否在连续的非数字段中
for (int i = 0; i < str1.length(); i++) {
if (str1[i] >= '0' && str1[i] <= '9') {
// 当前字符是数字
str2 += str1[i];
inNonDigit = false; // 数字段开始，非数字段结束
} else {
// 当前字符是非数字
if (!inNonDigit) {
// 如果不在非数字段中，说明非数字段开始，添加*
str2 += '*';
inNonDigit = true;
}
// 如果在非数字段中，继续跳过（连续的非数字只对应一个*）
}
}
cout << str2 << endl;
return 0;
}
1133 - 字符串的反码
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
// 小写字母：反码 = 'z' - (当前字母 - 'a')
s[i] = 'z' - (s[i] - 'a');
} else if (s[i] >= 'A' && s[i] <= 'Z') {
// 大写字母：反码 = 'Z' - (当前字母 - 'A')
s[i] = 'Z' - (s[i] - 'A');
}
// 其他字符保持不变
}
cout << s << endl;
return 0;
}
1134 - 国王的魔镜
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
// 不断检查是否可以折半
while (len % 2 == 0) {
string firstHalf = s.substr(0, len / 2);
string secondHalf = s.substr(len / 2, len / 2);
// 检查后半段是否是前半段的翻转
string reversedSecondHalf = secondHalf;
reverse(reversedSecondHalf.begin(), reversedSecondHalf.end());
if (firstHalf == reversedSecondHalf) {
// 可以折半，继续检查
len /= 2;
s = firstHalf; // 更新为前半段
} else {
break;
}
}
cout << len << endl;
return 0;
}
1135 - 歌德巴赫猜想
#include <iostream>
#include <vector>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
// 遍历所有4到n之间的偶数
for (int even = 4; even <= n; even += 2) {
// 对于每个偶数，寻找两个素数之和等于它
// 从2开始到even/2，避免重复
for (int p1 = 2; p1 <= even / 2; p1++) {
int p2 = even - p1;
if (isPrime(p1) && isPrime(p2)) {
cout << even << "=" << p1 << "+" << p2 << endl;
}
}
}
return 0;
}
1136 - 输出m和n范围内的完全数(完美数)
#include <iostream>
using namespace std;
// 判断一个数是否为完全数
bool isPerfect(int num) {
if (num < 2) return false;
int sum = 1; // 1是所有数的真约数
// 遍历可能的约数，从2到sqrt(num)
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
sum += i;
if (i != num / i) { // 避免重复添加平方根
sum += num / i;
}
}
}
return sum == num;
}
int main() {
int m, n;
cin >> m >> n;
bool first = true; // 用于控制输出格式
for (int i = m; i <= n; i++) {
if (isPerfect(i)) {
if (!first) {
cout << " ";
}
cout << i;
first = false;
}
}
// 如果没有找到完全数，输出空行（题目没说，但通常这样处理）
if (first) {
cout << endl;
}
return 0;
}
1137 - 纯粹素数
#include <iostream>
#include <cmath>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
// 判断纯粹素数
bool isPurePrime(int n) {
int temp = n;
// 不断去掉最高位，检查每一步是否都是素数
while (temp > 0) {
if (!isPrime(temp)) {
return false;
}
// 去掉最高位：比如 1234 -> 234
// 方法：取对应当前位数的模
int digits = 0;
int t = temp;
while (t > 0) {
digits++;
t /= 10;
}
temp = temp % (int)pow(10, digits - 1);
}
return true;
}
int main() {
// 输出所有小于3000的四位纯粹素数
for (int i = 1000; i < 3000; i++) {
if (isPurePrime(i)) {
cout << i << endl;
}
}
return 0;
}
1138 - 求无暇素数
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
string s;
cin >> s;
// 去掉末尾的%
s = s.substr(0, s.length() - 1);
vector<int> results;
// 遍历所有长度为2的子串
for (int i = 0; i < s.length() - 1; i++) {
// 提取两位数字
int num1 = (s[i] - '0') * 10 + (s[i + 1] - '0');
int num2 = (s[i + 1] - '0') * 10 + (s[i] - '0');
// 检查是否为无暇素数
if (num1 >= 10 && num2 >= 10 && isPrime(num1) && isPrime(num2)) {
// 避免重复添加
bool found = false;
for (int r : results) {
if (r == num1) {
found = true;
break;
}
}
if (!found) {
results.push_back(num1);
}
}
}
// 输出结果
for (int i = 0; i < results.size(); i++) {
if (i > 0) {
cout << ",";
}
cout << results[i];
}
cout << endl;
return 0;
}
1139 - 孪生素数
#include <iostream>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int N;
cin >> N;
// 从2遍历到N-2（因为要检查a和a+2）
for (int a = 2; a <= N - 2; a++) {
if (isPrime(a) && isPrime(a + 2)) {
cout << a << " " << a + 2 << endl;
}
}
return 0;
}
——————答案与解析分割线——————
1130 - 简单a+b 解析
过于简单QWQ（做过来感觉跟1129差不多）
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
// 找到 + 和 = 的位置
int plusPos = s.find('+');
int equalPos = s.find('=');
// 提取两个数字
string num1Str = s.substr(0, plusPos);
string num2Str = s.substr(plusPos + 1, equalPos - plusPos - 1);
// 转换为长整型并计算
long long num1 = stoll(num1Str);
long long num2 = stoll(num2Str);
long long result = num1 + num2;
cout << result << endl;
return 0;
}
算法说明：
使用 find(‘+’) 找到加号的位置
使用 find(‘=’) 找到等号的位
用 substr 提取两个数字字符串：
第一个数字：从开始到 + 之前
第二个数字：从 + 之后到 = 之前
用 stoll 转换为 long long 类型（因为数字可能达到10⁹）
计算并输出和
例子： “1+2=”
plusPos = 1（+ 在索引1）
equalPos = 3（= 在索引3）
num1Str = “1”（索引0-0）
num2Str = “2”（索引2-2）
计算：1 + 2 = 3
另一个例子： “23+58=”
plusPos = 2（+ 在索引2）
equalPos = 5（= 在索引5）
num1Str = “23”（索引0-1）
num2Str = “58”（索引3-4）
计算：23 + 58 = 81
1131 - 删除指定字符 解析
哟呵，有意思，给代码：
#include <iostream>
#include <string>
using namespace std;
int main() {
string str;
char c;
cin >> str;
cin >> c;
string result = "";
// 遍历字符串，只添加不等于c的字符
for (int i = 0; i < str.length(); i++) {
if (str[i] != c) {
result += str[i];
}
}
cout << result << endl;
return 0;
}
算法说明：
读取输入的字符串和要删除的字符
创建一个空的结果字符串
遍历原字符串的每个字符：
如果字符不等于要删除的字符，就添加到结果字符串
如果等于要删除的字符，就跳过
输出结果字符串
例子：
输入："sdf$ $ $ sdf $ $ " 和 ’ $ ’
遍历过程：
‘s’ ≠ ’ $ ’ → 添加
‘d’ ≠ ’ $ ’ → 添加
‘f’ ≠ ’ $ ’ → 添加
’ $ ’ = ’ $ ’ → 跳过
’ $ ’ = ’ $ ’ → 跳过
’ $ ’ = ’ $ ’ → 跳过
‘s’ ≠ ’ $ ’ → 添加
‘d’ ≠ ’ $ ’ → 添加
‘f’ ≠ ’ $ ’ → 添加
’ $ ’ = ’ $ ’ → 跳过
’ $ ’ = ‘$’ → 跳过（有空格请见谅，因为 $ 打出来会自动转化成
字体
字体
字体 ，所以必须空格）
输出：“sdfsdf”
这种方法简单直接，时间复杂度为 O(n)，其中 n 是字符串长度。
1132 - 保留整数 解析
？我试了3次才通过
题目要求：
连续的非数字字符子串 → 替换成 1个 *
数字字符 → 原样保留
最终结果中，数字段和交替出现
关键点： 连续的非数字段无论多长，都只替换成1个
#include <iostream>
#include <string>
using namespace std;
int main() {
string str1;
getline(cin, str1);
string str2 = "";
bool inNonDigit = false; // 标记是否在连续的非数字段中
for (int i = 0; i < str1.length(); i++) {
if (str1[i] >= '0' && str1[i] <= '9') {
// 当前字符是数字
str2 += str1[i];
inNonDigit = false; // 数字段开始，非数字段结束
} else {
// 当前字符是非数字
if (!inNonDigit) {
// 如果不在非数字段中，说明非数字段开始，添加*
str2 += '*';
inNonDigit = true;
}
// 如果在非数字段中，继续跳过（连续的非数字只对应一个*）
}
}
cout << str2 << endl;
return 0;
}
重新分析样例： “KaTeX parse error: Expected 'EOF', got '&' at position 6: Ts!47&̲*s456 a23* +B9"…'：非数字，inNonDigit=false → 添加”“，inNonDigit=true
‘T’：非数字，inNonDigit=true → 跳过
‘s’：非数字，inNonDigit=true → 跳过
‘!’：非数字，inNonDigit=true → 跳过
‘4’：数字 → 添加"4”，inNonDigit=false
‘7’：数字 → 添加"7"，inNonDigit=false
‘&’：非数字，inNonDigit=false → 添加"“，inNonDigit=true
''：非数字，inNonDigit=true → 跳过
‘s’：非数字，inNonDigit=true → 跳过
‘4’：数字 → 添加"4"，inNonDigit=false
‘5’：数字 → 添加"5"，inNonDigit=false
‘6’：数字 → 添加"6"，inNonDigit=false
’ '：非数字，inNonDigit=false → 添加"”，inNonDigit=true
’ '：非数字，inNonDigit=true → 跳过
‘a’：非数字，inNonDigit=true → 跳过
‘2’：数字 → 添加"2"，inNonDigit=false
‘3’：数字 → 添加"3"，inNonDigit=false
‘’：非数字，inNonDigit=false → 添加"“，inNonDigit=true
’ '：非数字，inNonDigit=true → 跳过
‘+’：非数字，inNonDigit=true → 跳过
‘B’：非数字，inNonDigit=true → 跳过
‘9’：数字 → 添加"9”，inNonDigit=false
结果： " * 47 * 456 * 23 * 9" ✓
这个逻辑是：
遇到数字：直接添加到结果，标记不在非数字段
遇到非数字：
如果不在非数字段中：添加*，标记进入非数字段
如果在非数字段中：跳过（连续的非数字只对应一个*）
1133 - 字符串的反码 解析
明显简单很多
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
// 小写字母：反码 = 'z' - (当前字母 - 'a')
s[i] = 'z' - (s[i] - 'a');
} else if (s[i] >= 'A' && s[i] <= 'Z') {
// 大写字母：反码 = 'Z' - (当前字母 - 'A')
s[i] = 'Z' - (s[i] - 'A');
}
// 其他字符保持不变
}
cout << s << endl;
return 0;
}
算法说明：
小写字母：反码 = ‘z’ - (当前字母 - ‘a’)
例如：‘a’ → ‘z’ - (0) = ‘z’
‘c’ → ‘z’ - (2) = ‘x’
大写字母：反码 = ‘Z’ - (当前字母 - ‘A’)
例如：‘W’ → ‘Z’ - (22) = ‘D’
其他字符：保持不变
例子验证：
‘a’：‘z’ - (‘a’ - ‘a’) = ‘z’ - 0 = ‘z’
‘c’：‘z’ - (‘c’ - ‘a’) = ‘z’ - 2 = ‘x’
‘W’：‘Z’ - (‘W’ - ‘A’) = ‘Z’ - 22 = ‘D’
‘1’ 和 ‘$’：保持不变
这个算法正确实现了题目要求的反码计算。
1134 - 国王的魔镜 解析
稍稍有些难度啊~
我们先来分析一下这个问题。
魔镜的作用是：把当前项链的一端接触镜面，项链会变成 原项链 + 原项链的镜像。
也就是说，如果原项链是 S，接触一次后变成 S + reverse(S)。
题目说：给定最终的项链，求最初的项链可能的最小长度。
思路
如果当前项链是经过魔镜变换得到的，那么它的长度一定是偶数，并且前半部分和后半部分的翻转相同。
即：S = X + reverse(X)。
我们可以不断检查当前长度是否是偶数，并且是否满足 S = X + reverse(X)。
如果满足，说明它可能是由 X 经过一次变换得到的，我们就令 S = X，继续检查。
重复这个过程，直到长度是奇数，或者不满足镜像条件为止，这时的长度就是最初的最小可能长度。
举例
比如 ABBAABBA：
长度 8，偶数，检查前半 ABBA 和后半 ABBA 的反转是否相等：
后半反转是 ABBA，与前半相等，所以可以还原成 ABBA。
长度 4，偶数，前半 AB，后半 BA，反转后半是 AB，相等，所以还原成 AB。
长度 2，偶数，前半 A，后半 B，反转后半是 B，不等于 A，停止。
所以最初长度是 2。
算法步骤
读入字符串 s。
当 len(s) 是偶数时：
检查 s 是否等于 前半段 + 反转(前半段)。
如果是，则 s = 前半段，继续。
否则，停止。
输出 len(s)。
上代码！！！！
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
// 不断检查是否可以折半
while (len % 2 == 0) {
string firstHalf = s.substr(0, len / 2);
string secondHalf = s.substr(len / 2, len / 2);
// 检查后半段是否是前半段的翻转
string reversedSecondHalf = secondHalf;
reverse(reversedSecondHalf.begin(), reversedSecondHalf.end());
if (firstHalf == reversedSecondHalf) {
// 可以折半，继续检查
len /= 2;
s = firstHalf; // 更新为前半段
} else {
break;
}
}
cout << len << endl;
return 0;
}
算法说明：
读取最终的项链字符串
循环检查：
如果当前长度是偶数
将字符串分成前后两半
检查后半段反转后是否等于前半段
如果相等，说明可以折半，继续检查
如果不相等或长度为奇数，停止循环
输出最终的最小长度
例子验证： “ABBAABBA”
长度8，偶数：
前半=“ABBA”，后半=“ABBA”
反转后半=“ABBA”，与前半相等 → 长度减半为4，字符串=“ABBA”
长度4，偶数：
前半=“AB”，后半=“BA”
反转后半=“AB”，与前半相等 → 长度减半为2，字符串=“AB”
长度2，偶数：
前半=“A”，后半=“B”
反转后半=“B”，不等于前半 → 停止
输出：2
这个算法正确实现了题目要求，找到了最初的项链可能的最小长度。
1135 - 歌德巴赫猜想 解析
#include <iostream>
#include <vector>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
// 遍历所有4到n之间的偶数
for (int even = 4; even <= n; even += 2) {
// 对于每个偶数，寻找两个素数之和等于它
// 从2开始到even/2，避免重复
for (int p1 = 2; p1 <= even / 2; p1++) {
int p2 = even - p1;
if (isPrime(p1) && isPrime(p2)) {
cout << even << "=" << p1 << "+" << p2 << endl;
}
}
}
return 0;
}
算法说明：
素数判断：isPrime 函数判断一个数是否为素数
遍历偶数：从4到n的所有偶数
寻找素数对：对于每个偶数，从2开始到even/2寻找素数对
这样可以避免重复（如10=3+7和10=7+3）
检查p1和p2是否都是素数
输出结果：按格式输出所有素数对
例子验证： n=10
even=4: p1=2, p2=2 → 都是素数 → 输出4=2+2
even=6: p1=2, p2=4(不是素数); p1=3, p2=3 → 输出6=3+3
even=8: p1=2, p2=6(不是素数); p1=3, p2=5 → 输出8=3+5
even=10:
p1=2, p2=8(不是素数)
p1=3, p2=7 → 输出10=3+7
p1=5, p2=5 → 输出10=5+5
这个算法正确实现了哥德巴赫猜想的验证，并按题目要求格式输出所有素数对。
1136 - 输出m和n范围内的完全数(完美数) 解析
#include <iostream>
using namespace std;
// 判断一个数是否为完全数
bool isPerfect(int num) {
if (num < 2) return false;
int sum = 1; // 1是所有数的真约数
// 遍历可能的约数，从2到sqrt(num)
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
sum += i;
if (i != num / i) { // 避免重复添加平方根
sum += num / i;
}
}
}
return sum == num;
}
int main() {
int m, n;
cin >> m >> n;
bool first = true; // 用于控制输出格式
for (int i = m; i <= n; i++) {
if (isPerfect(i)) {
if (!first) {
cout << " ";
}
cout << i;
first = false;
}
}
// 如果没有找到完全数，输出空行（题目没说，但通常这样处理）
if (first) {
cout << endl;
}
return 0;
}
算法说明：
完全数判断：isPerfect 函数计算一个数的所有真约数之和
从1开始（1是所有数的真约数）
遍历2到√num，如果i是约数，则添加i和num/i
注意避免重复添加平方根
遍历范围：从m到n检查每个数是否为完全数
输出控制：用first标志控制空格输出，保证数与数之间用空格隔开
优化说明：
只遍历到√num而不是num-1，时间复杂度从O(n)降到O(√n)
对于每个约数i，同时找到对应的约数num/i
例子验证：
6: 真约数1+2+3=6 → 完全数
28: 真约数1+2+4+7+14=28 → 完全数
496, 8128也是完全数（但在32767范围内只有6,28,496,8128）
在2-32767范围内的完全数：
6, 28, 496, 8128
所以对于输入2 10，输出6是正确的。
1137 - 纯粹素数 解析
这么快Σ(⊙▽⊙"a就到函数了？？？没反应过来。这道题你用计算机硬算，枚举，用cout也可以~~~~~~~~开个玩笑：
#include <iostream>
#include <cmath>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
// 判断纯粹素数
bool isPurePrime(int n) {
int temp = n;
// 不断去掉最高位，检查每一步是否都是素数
while (temp > 0) {
if (!isPrime(temp)) {
return false;
}
// 去掉最高位：比如 1234 -> 234
// 方法：取对应当前位数的模
int digits = 0;
int t = temp;
while (t > 0) {
digits++;
t /= 10;
}
temp = temp % (int)pow(10, digits - 1);
}
return true;
}
int main() {
// 输出所有小于3000的四位纯粹素数
for (int i = 1000; i < 3000; i++) {
if (isPurePrime(i)) {
cout << i << endl;
}
}
return 0;
}
算法说明：
素数判断：isPrime函数判断一个数是否为素数
纯粹素数判断：isPurePrime函数
从原数开始，不断去掉最高位
每一步都检查剩下的数是否为素数
直到剩下个位数
遍历范围：1000到2999的所有四位数
去掉最高位的方法：
先计算当前数的位数digits
然后用 num % 10^(digits-1) 去掉最高位
例如：1234 → 位数=4 → 1234 % 1000 = 234
例子验证：
2333：
2333是素数
去掉最高位：333是素数
去掉最高位：33不是素数 → 不是纯粹素数
2339：
2339是素数
去掉最高位：339不是素数 → 不是纯粹素数
运行这个程序，会输出所有小于3000的四位纯粹素数。
1138 - 求无暇素数 解析
稍微费手了一点哈
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
string s;
cin >> s;
// 去掉末尾的%
s = s.substr(0, s.length() - 1);
vector<int> results;
// 遍历所有长度为2的子串
for (int i = 0; i < s.length() - 1; i++) {
// 提取两位数字
int num1 = (s[i] - '0') * 10 + (s[i + 1] - '0');
int num2 = (s[i + 1] - '0') * 10 + (s[i] - '0');
// 检查是否为无暇素数
if (num1 >= 10 && num2 >= 10 && isPrime(num1) && isPrime(num2)) {
// 避免重复添加
bool found = false;
for (int r : results) {
if (r == num1) {
found = true;
break;
}
}
if (!found) {
results.push_back(num1);
}
}
}
// 输出结果
for (int i = 0; i < results.size(); i++) {
if (i > 0) {
cout << ",";
}
cout << results[i];
}
cout << endl;
return 0;
}
算法说明：
输入处理：读取字符串并去掉末尾的%
遍历子串：提取所有长度为2的子串
检查无暇素数：
原两位数A = s[i]s[i+1]
交换后B = s[i+1]s[i]
检查A和B是否都是素数且都是两位数
去重：避免输出重复的无暇素数
输出格式：用逗号分隔
例子验证： “321314%”
子串"32"：A=32(不是素数), B=23(素数) → 不满足
子串"21"：A=21(不是素数), B=12(不是素数) → 不满足
子串"13"：A=13(素数), B=31(素数) → 满足，添加13
子串"31"：A=31(素数), B=13(素数) → 满足，添加31
子串"14"：A=14(不是素数), B=41(素数) → 不满足
输出： “13,31”
注意：题目要求输出的是无暇素数A，不是B。所以输出13和31，而不是23或41等。
1139 - 孪生素数 解析
最后一篇啦~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~已经打了13031字了
#include <iostream>
using namespace std;
// 判断素数
bool isPrime(int n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int N;
cin >> N;
// 从2遍历到N-2（因为要检查a和a+2）
for (int a = 2; a <= N - 2; a++) {
if (isPrime(a) && isPrime(a + 2)) {
cout << a << " " << a + 2 << endl;
}
}
return 0;
}
算法说明：
素数判断：isPrime函数判断一个数是否为素数
遍历检查：从2到N-2遍历每个数a
检查a和a+2是否都是素数
如果都是素数，则输出这对孪生素数
边界处理：只遍历到N-2，因为要检查a+2
例子验证： N=10
a=2: 2(素数), 4(不是素数) → 不满足
a=3: 3(素数), 5(素数) → 输出3 5
a=4: 4(不是素数), 6(不是素数) → 不满足
a=5: 5(素数), 7(素数) → 输出5 7
a=6: 6(不是素数), 8(不是素数) → 不满足
a=7: 7(素数), 9(不是素数) → 不满足
a=8: 8(不是素数), 10(不是素数) → 不满足
输出：
3 5
5 7
另一个例子： N=17
孪生素数对有：(3,5), (5,7), (11,13)
注意：(17,19)中的19超过了N=17，所以不输出
这个算法正确找出了2∼N之间的所有孪生素数对。
好啦，支持一下作者叭
看到这里了，不点个赞再走嘛？
QWQ，开玩笑的！！！！！！不要真走啊！！！！
来我主页逛逛叭~
顺带关注一下也挺好的（小害羞），不过看来读者大大们是不大可能的o(╥﹏╥)o
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
