Day 10 · 函数：把代码写成模块

题意：给出平面上不共线的三个点的坐标（实数），求这三点围成的三角形的周长，保留两位小数。

思路

这题是「把公式封装成函数」的教科书例子。三点围成的三角形，三条边正好是 AB、BC、CA：

周长 = dist(A,B) + dist(B,C) + dist(C,A)

写一个 dist(x1, y1, x2, y2) 求两点距离，然后调用三次 —— 这就是函数最大的价值：公式只写一遍，用几次调几次。

输入是三行、每行两个数，但 cin 会自动跳过所有空白（空格、换行都算空白）， 所以直接 cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; 一次读完就行，完全不用管它在哪一行换行。

0 0
0 3
4 0

12.00

手算核对：(0,0)-(0,3) 长度 3；(0,3)-(4,0) 长度 √(16+9) = 5；(4,0)-(0,0) 长度 4。3+5+4 = 12 → 12.00 ✅

完整代码

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

// 求两点之间的距离（今天的主角：把公式封装成函数）
double dist(double x1, double y1, double x2, double y2){
    return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

int main(){
    double x1, y1, x2, y2, x3, y3;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

    double ans = dist(x1, y1, x2, y2)
               + dist(x2, y2, x3, y3)
               + dist(x3, y3, x1, y1);

    printf("%.2f\n", ans);     // 保留两位小数
    return 0;
}

易错点

• 用 int 读坐标：输入 0.5 这种小数会被读成 0，直接错。坐标是实数就必须 double。
• 用 float：精度只有 7 位左右，本题数据小，勉强能过，但没必要冒这个险 —— 竞赛里小数一律 double。
• 写成 (x2-x1)^2：C++ 里 ^ 是异或，不是乘方！必须老老实实写成 (x2-x1)*(x2-x1)，或者用 pow(x2-x1, 2)（不推荐，慢且返回 double）。
• 忘写 #include <cmath>：sqrt 找不到。用 printf 则要 <cstdio>。
• 输出用 cout << ans：会打出 12 或 12.0000000 这样的一串，不是两位小数。要么 printf("%.2f")，要么 cout << fixed << setprecision(2)（后者要 <iomanip>）。

题意：读入 n 个正整数，把其中的合数和 1 全部筛掉，按原顺序输出剩下的素数，用空格隔开。

思路

① 先把 n 个数读进数组（题目明确要求用数组存）。

② 写 isPrime 函数，即第 4 节的模板一：小于 2 直接否掉，然后从 2 试到 √n。

③ 遍历数组，是素数就输出，注意用 first 标记控制空格，避免行尾多一个空格。

5
3 4 5 6 7

3 5 7

完整代码

#include <iostream>
using namespace std;

// 判断一个数是不是质数
bool isPrime(int n){
    if(n < 2) return false;                     // 0 和 1 都不是质数
    for(int i = 2; (long long)i * i <= n; i++){ // 只需试到 sqrt(n)
        if(n % i == 0) return false;
    }
    return true;
}

int main(){
    int n;
    cin >> n;

    int a[105];
    for(int i = 0; i < n; i++) cin >> a[i];      // 题目要求先全部存进数组

    bool first = true;
    for(int i = 0; i < n; i++){
        if(isPrime(a[i])){
            if(!first) cout << " ";              // 不是第一个才补空格
            first = false;
            cout << a[i];
        }
    }
    cout << endl;
    return 0;
}

易错点

• isPrime 忘了 n < 2 的特判：那么 1 会被判成素数输出 —— 而本题的 a_i 正好可以等于 1。
• 循环写成 i <= n：会慢到 10⁵ 次，而且逻辑上也多余（试到 √n 就够）。
• 循环写成 i < n / 2：虽然结果对，但没必要试那么多。用 i * i <= n 最省事。
• 行尾多一个空格：某些评测会比较严格。用 first 标记，或写 if(i != 0) cout << " ";。
• 数组开太小：n ≤ 100，开 a[105] 够了，但别开 a[100]（下标只到 99）。

题意：输入 x 和 y，第一行输出 [x, y] 区间里闰年的个数，第二行按从小到大输出所有闰年年份，空格隔开。

思路

① 先把 isLeap(y) 函数写好（模板二：400 → 100 → 4 的顺序判断）。

② 数个数：从 x 到 y 走一遍，是闰年就 cnt++，先输出 cnt。

③ 再输出年份：从 x 到 y 再走一遍（或者把两步合并），是闰年就输出 + 空格处理。

两次循环其实可以合成一次，但这里分两步写更清楚：题目要求先给出总数，再列出明细， 分两步正好对应题目的输出顺序，不容易乱。

1989 2001

3
1992 1996 2000

手算核对：1989~2001 之间能被 4 整除的有 1992、1996、2000。 其中 2000 是世纪年，但能被 400 整除，所以是闰年 ✅（如果是 1900，就要被剔掉）

完整代码

#include <iostream>
using namespace std;

// 判断闰年：能被 4 整除但不能被 100 整除，或者能被 400 整除
bool isLeap(int y){
    if(y % 400 == 0) return true;
    if(y % 100 == 0) return false;
    return y % 4 == 0;
}

int main(){
    int x, y;
    cin >> x >> y;

    int cnt = 0;
    for(int i = x; i <= y; i++)
        if(isLeap(i)) cnt++;
    cout << cnt << endl;

    bool first = true;
    for(int i = x; i <= y; i++){
        if(isLeap(i)){
            if(!first) cout << " ";
            first = false;
            cout << i;
        }
    }
    cout << endl;
    return 0;
}

易错点

• 漏掉 400 的规则：写成 y % 4 == 0 && y % 100 != 0 就完了，2000 会被漏掉，样例直接挂。
• 判断顺序反了：先判 100 再判 400，2000 会被 100 那条规则提前否掉。必须先 400。
• 循环边界写成 i < y：区间是闭区间 [x, y]，要用 i <= y，否则会漏掉 y 这一年。
• 行尾多空格：同样用 first 标记处理。
• 忘了先输出个数：题目要两行输出，顺序不能反。

题意：输入一个偶数 N，把 4 到 N 之间的每一个偶数都写成「两个质数之和」， 每行一个，形如 10=3+7。如果一个偶数有多种拆法，输出第一个加数最小的那一种。

题面举的例子很关键：10 = 3+7 = 5+5，必须输出 10=3+7（3 比 5 小），写 10=5+5 判错。

思路

① 先用埃氏筛把 2~N 的质数全部标记出来。

埃氏筛的思路特别朴素：从 2 开始，把每个质数的倍数全部划掉。 2 是质数 → 划掉 4、6、8……；3 是质数 → 划掉 9、12、15……；下一个没被划掉的就是质数，继续划……

for(int i = 2; i * i <= N; i++)
    if(isPrime[i])                       // i 本身没被划掉 → i 是质数
        for(int j = i * i; j <= N; j += i)
            isPrime[j] = false;          // 把 i 的倍数全部划掉

② 对每个偶数 n，从小到大试 a：

for(int a = 2; a <= n / 2; a++){
    if(isPrime[a] && isPrime[n - a]){
        cout << n << "=" << a << "+" << n - a << endl;
        break;                       // ★ 找到第一个就停，这才保证 a 最小
    }
}

③ 外层循环从 4 开始，每次 +2，对应题目要求的那 (N−2)/2 个偶数。

10

4=2+2
6=3+3
8=3+5
10=3+7

4 = 2+2；6 = 3+3；8 = 3+5（8 还能拆成 5+3，但 3 更小）；10 = 3+7（不是 5+5）—— 正是题目要求的「第一个加数最小」。

完整代码

#include <iostream>
using namespace std;

// 埃氏筛：把 2~N 里所有质数标记出来，放在 main 外面（全局数组自动清零）
bool isPrime[10005];

int main(){
    int N;
    cin >> N;

    for(int i = 2; i <= N; i++) isPrime[i] = true;          // 先假设都是质数
    for(int i = 2; i * i <= N; i++){
        if(isPrime[i]){                                     // i 是质数
            for(int j = i * i; j <= N; j += i)
                isPrime[j] = false;                         // i 的倍数全部划掉
        }
    }

    for(int n = 4; n <= N; n += 2){          // 从 4 开始，每个偶数都要验证
        for(int a = 2; a <= n / 2; a++){     // a 从小到大试，第一个成功的 a 最小
            if(isPrime[a] && isPrime[n - a]){
                cout << n << "=" << a << "+" << n - a << endl;
                break;                       // 找到一个就够，换下一个偶数
            }
        }
    }
    return 0;
}

易错点

• 找到一对就继续试别的 a：忘了 break，会输出多行、或者把最后的 a 打印出来（那就成了「第一个加数最大」）。必须 break。
• 素组数组开小了：N 最大 10000，开 bool isPrime[10005] 刚好够；开 isPrime[10000] 会越界。
• 外层循环写成 n <= N; n++：会输出奇数行（3=…、5=… 这些偶数才需要验证）。要写 n += 2。
• 内层从 a = 1 开始：1 不是质数，虽然 isPrime[1] 是 false 不会出错，但从 2 开始更清楚。
• 全局数组忘了初始化为 true：这是我代码里唯一「要手动做」的初始化 —— 全局数组默认全是 false（=「还不是质数」）， 所以要先 for(i = 2; i <= N; i++) isPrime[i] = true; 把 2~N 假设成质数，再筛。
• 把筛法写成对每个偶数都重新判断质数：那样虽然 N ≤ 10000 也能过，但复杂度差一个量级。 「一次预处理、多次查询」是今天最值得带走的思维方式。