递归入门：函数怎么调用自己

// 数位和 —— 循环写法（你已经会的那种）
//
// 输入：一个非负整数 n
// 输出：n 的各位数字之和。例如 12345 -> 1+2+3+4+5 = 15
//
// 思路：反复取出最后一位（n % 10），然后把最后一位砍掉（n / 10），直到 n 变成 0。

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

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

    int sum = 0;
    while (n > 0) {
        sum += n % 10;   // 取出最后一位
        n /= 10;         // 砍掉最后一位
    }

    cout << sum << "\n";
    return 0;
}

// 数位和 —— 递归写法
//
// 和 loop.cpp 解的是同一道题，答案必须完全一样。
//
// 递归三要素：
//   1. 这个函数「负责什么」—— digitSum(n) 返回 n 的各位数字之和。
//      想清楚这一句，比想清楚它内部怎么执行重要一百倍。
//   2. 边界（递归出口）—— n == 0 时，没有任何数字，和是 0。直接返回，不再往下递。
//   3. 递推关系 —— n 的数位和 = 最后一位(n % 10) + 剩下部分的数位和(digitSum(n / 10))。
//
// 注意第 3 步：我们直接「相信」digitSum(n / 10) 会算对，不去追问它内部怎么跑的。
// 这就是递归最难迈过去、也最关键的一步 —— 把自己当成使用者，而不是执行者。

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

// ⚠ 两个新手容易被绊一下的写法，说清楚：
//   · 参数是 `long long`、返回值是 `int` —— 这不是笔误。
//     输入的数可能很大（超过 int 能存的 21 亿），所以参数要用 long long；
//     但**数位和**再大也就几十（19 位的数最多 9×19 = 171），int 绰绰有余。
//     「输入用大类型、答案用够用的类型」是常态，不用强求两边一致。
//   · `(int)(n % 10)` 里的括号是**类型转换**：`n % 10` 的类型是 long long，
//     转成 int 再和右边的 int 相加。不写这一句也能编译（会自动转），
//     写出来是为了让「这里发生了一次类型转换」看得见。
//     ⇒ C++ 更推荐的写法是 `static_cast<int>(n % 10)`，本书为了短用了 C 风格。
int digitSum(long long n) {
    if (n == 0) return 0;              // 出口
    return (int)(n % 10) + digitSum(n / 10);   // 递推：最后一位 + 剩下的
}

int main() {
    long long n;
    cin >> n;
    cout << digitSum(n) << "\n";
    return 0;
}

// 数位和 —— 带打印的递归，用来「看见」调用栈
//
// 这份代码答案和 rec.cpp 一样，只是在进入和返回时各打印一行，
// 并用缩进表示当前在第几层。跑一遍，你就能亲眼看到：
//   - 先一路「递」下去（缩进越来越深），直到撞上出口
//   - 再一路「归」回来（缩进越来越浅），答案是在回来的路上攒出来的
//
// 这个「进入打印 / 返回打印」的技巧，以后调试任何递归都能用。

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

int depth = 0;

void indent() {
    for (int i = 0; i < depth; i++) cout << "|   ";
}

int digitSum(long long n) {
    indent();
    cout << "-> 进入 digitSum(" << n << ")\n";
    depth++;

    int result;
    if (n == 0) {
        result = 0;
        indent();
        cout << "   撞到出口，直接返回 0\n";
    } else {
        int rest = digitSum(n / 10);          // 先把子问题算出来
        result = (int)(n % 10) + rest;
        indent();
        cout << "   " << n % 10 << " + " << rest << " = " << result << "\n";
    }

    depth--;
    indent();
    cout << "<- 返回 " << result << "  (来自 digitSum(" << n << "))\n";
    return result;
}

int main() {
    long long n;
    cin >> n;
    cout << "开始计算 " << n << " 的数位和\n\n";
    int ans = digitSum(n);
    cout << "\n最终答案 = " << ans << "\n";
    return 0;
}

// 数位和 —— 递归写法
//
// 和 loop.cpp 解的是同一道题，答案必须完全一样。
//
// 递归三要素：
//   1. 这个函数「负责什么」—— digitSum(n) 返回 n 的各位数字之和。
//      想清楚这一句，比想清楚它内部怎么执行重要一百倍。
//   2. 边界（递归出口）—— n == 0 时，没有任何数字，和是 0。直接返回，不再往下递。
//   3. 递推关系 —— n 的数位和 = 最后一位(n % 10) + 剩下部分的数位和(digitSum(n / 10))。
//
// 注意第 3 步：我们直接「相信」digitSum(n / 10) 会算对，不去追问它内部怎么跑的。
// 这就是递归最难迈过去、也最关键的一步 —— 把自己当成使用者，而不是执行者。

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

// ⚠ 两个新手容易被绊一下的写法，说清楚：
//   · 参数是 `long long`、返回值是 `int` —— 这不是笔误。
//     输入的数可能很大（超过 int 能存的 21 亿），所以参数要用 long long；
//     但**数位和**再大也就几十（19 位的数最多 9×19 = 171），int 绰绰有余。
//     「输入用大类型、答案用够用的类型」是常态，不用强求两边一致。
//   · `(int)(n % 10)` 里的括号是**类型转换**：`n % 10` 的类型是 long long，
//     转成 int 再和右边的 int 相加。不写这一句也能编译（会自动转），
//     写出来是为了让「这里发生了一次类型转换」看得见。
//     ⇒ C++ 更推荐的写法是 `static_cast<int>(n % 10)`，本书为了短用了 C 风格。
int digitSum(long long n) {
    if (n == 0) return 0;              // 出口
    return (int)(n % 10) + digitSum(n / 10);   // 递推：最后一位 + 剩下的
}

int main() {
    long long n;
    cin >> n;
    cout << digitSum(n) << "\n";
    return 0;
}