枚举与模拟：把题目老老实实翻译成代码

// 百钱买百鸡（加强版）—— 暴力：三重循环
//
// 输入：一个整数 n
// 输出：所有的买法，每行一种；最后一行是总数
//
// 题意：公鸡 5 钱一只，母鸡 3 钱一只，小鸡 3 只 1 钱。
//       用 n 钱买 n 只鸡（三种都可以是 0 只），问有多少种买法。
//       n = 100 就是那道流传了一千五百年的「百钱买百鸡」。
//
// 暴力写法就是把题意逐字翻译：公鸡买几只不知道，那就从 0 试到 n；
// 母鸡、小鸡同理。三个数都试遍，符合条件的就记一笔。
//
// 这份代码**思路完全正确**，n = 100 时秒出。
// 但它是 O(n³) 的：n 每翻一倍，耗时就是 8 倍。正文第 4 步会让你亲眼看到这一点。
//
// 注意小鸡那个条件：3 只才 1 钱，所以只能整 3 只整 3 只地买，z 必须是 3 的倍数。
// 这个坑不少人第一次写会漏掉。

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

int main() {
    int n;
    if (!(cin >> n)) return 0;
    if (n < 0) { cout << "共 0 种\n"; return 0; }

    int cnt = 0;
    for (int x = 0; x <= n; x++)                 // 公鸡
        for (int y = 0; y <= n; y++)             // 母鸡
            for (int z = 0; z <= n; z++) {       // 小鸡
                if (x + y + z != n) continue;    // 一共要 n 只
                if (z % 3 != 0) continue;        // 小鸡只能 3 只 3 只地买
                if (5 * x + 3 * y + z / 3 != n) continue;   // 一共要花 n 钱
                cout << "公鸡 " << x << " 只，母鸡 " << y << " 只，小鸡 " << z << " 只\n";
                cnt++;
            }

    cout << "共 " << cnt << " 种\n";
    return 0;
}

// 百钱买百鸡 —— 正解：一重循环
//
// 输出和前两份完全一样。这一份连母鸡都不枚举了。
//
// 推导（纸笔三行，不需要任何算法知识）：
//     x + y + z = n              ……只数
//     5x + 3y + z/3 = n          ……钱数
//   把第二个式子乘 3：15x + 9y + z = 3n
//   减去第一个式子：  14x + 8y = 2n
//   两边除以 2：      7x + 4y = n        ← 只剩两个变量了
//
// 于是枚举 x，只要 (n - 7x) 能被 4 整除，y 就唯一确定；z = n - x - y。
// x 最多到 n/7，所以复杂度是 O(n/7)。
//
// 还有一个漂亮的副产品：
//   z = n - x - y = (7x + 4y) - x - y = 6x + 3y = 3(2x + y)
//   —— z **自动**是 3 的倍数，那个「小鸡只能 3 只 3 只买」的判断可以整个删掉。
//
// 化简一次方程，同时干掉了一重循环和一个特判。
// 这就是为什么信息学竞赛里，纸笔推导的地位不比敲代码低。

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

int main() {
    int n;
    if (!(cin >> n)) return 0;
    if (n < 0) { cout << "共 0 种\n"; return 0; }

    int cnt = 0;
    for (int x = 0; 7 * x <= n; x++) {
        int rest = n - 7 * x;
        if (rest % 4 != 0) continue;             // y 必须是整数
        int y = rest / 4;
        int z = n - x - y;                       // 由前面的推导，z 一定是 3 的倍数
        cout << "公鸡 " << x << " 只，母鸡 " << y << " 只，小鸡 " << z << " 只\n";
        cnt++;
    }

    cout << "共 " << cnt << " 种\n";
    return 0;
}

// 百钱买百鸡 —— 正解：一重循环
//
// 输出和前两份完全一样。这一份连母鸡都不枚举了。
//
// 推导（纸笔三行，不需要任何算法知识）：
//     x + y + z = n              ……只数
//     5x + 3y + z/3 = n          ……钱数
//   把第二个式子乘 3：15x + 9y + z = 3n
//   减去第一个式子：  14x + 8y = 2n
//   两边除以 2：      7x + 4y = n        ← 只剩两个变量了
//
// 于是枚举 x，只要 (n - 7x) 能被 4 整除，y 就唯一确定；z = n - x - y。
// x 最多到 n/7，所以复杂度是 O(n/7)。
//
// 还有一个漂亮的副产品：
//   z = n - x - y = (7x + 4y) - x - y = 6x + 3y = 3(2x + y)
//   —— z **自动**是 3 的倍数，那个「小鸡只能 3 只 3 只买」的判断可以整个删掉。
//
// 化简一次方程，同时干掉了一重循环和一个特判。
// 这就是为什么信息学竞赛里，纸笔推导的地位不比敲代码低。

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

int main() {
    int n;
    if (!(cin >> n)) return 0;
    if (n < 0) { cout << "共 0 种\n"; return 0; }

    int cnt = 0;
    for (int x = 0; 7 * x <= n; x++) {
        int rest = n - 7 * x;
        if (rest % 4 != 0) continue;             // y 必须是整数
        int y = rest / 4;
        int z = n - x - y;                       // 由前面的推导，z 一定是 3 的倍数
        cout << "公鸡 " << x << " 只，母鸡 " << y << " 只，小鸡 " << z << " 只\n";
        cnt++;
    }

    cout << "共 " << cnt << " 种\n";
    return 0;
}

// 约瑟夫问题 —— 老老实实模拟
//
// 输入：n m（n 个人围成一圈，从 1 号开始报数，报到 m 的人出局，
//            然后从下一个人重新从 1 开始报，直到只剩一个人）
// 输出：最后幸存者的编号
//
// 这份代码就是把题意逐字翻译过来的，没有任何技巧：
// 拿一个 vector 当那个圈，谁出局就把谁删掉。
//
// 「老老实实翻译」听起来很笨，但它是这一章的重点之一：
//   1. 考场上想不出正解时，模拟能保底拿分；
//   2. 它是对拍的标准答案；
//   3. **它还是你找规律的工具** —— 先用它打一张表出来，规律往往就浮出水面了。
//
// 唯一的坑在下标：vector 是从 0 开始的，而报数是从 1 开始的。
// 从当前位置往后数 m 个人，落点是 (pos + m - 1) % 剩下的人数。
// 那个 -1 是最容易写错的地方，把 n=5、m=1 代进去验一验就清楚了。
//
// 复杂度 O(n²)：每次 erase 都要把后面的元素整体往前挪一格。

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

int main() {
    long long n, m;
    if (!(cin >> n >> m)) return 0;
    if (n <= 0 || m <= 0) { cout << 0 << "\n"; return 0; }

    vector<int> circle(n);
    for (int i = 0; i < n; i++) circle[i] = i + 1;    // 编号 1..n

    size_t pos = 0;                                   // 下一轮从谁开始报「1」
    while (circle.size() > 1) {
        pos = (pos + (size_t)((m - 1) % (long long)circle.size())) % circle.size();
        circle.erase(circle.begin() + (long long)pos);
        // erase 之后，原来 pos 后面那个人自动顶到了 pos 这个位置，
        // 他正好就是下一轮报「1」的人 —— 所以 pos 不用动。
        if (pos == circle.size()) pos = 0;            // 除非删的是最后一个，要绕回开头
    }

    cout << circle[0] << "\n";
    return 0;
}

// 约瑟夫问题 —— 把每一轮的圈子打印出来
//
// 输入：n m（用小数据，n <= 20）
// 输出：每出局一个人就打印一次当前的圈子，出局的人用 [x] 标出来
//
// 跑一遍 n = 7, m = 3，然后盯住**出局之后那一行**：
// 剩下的人重新排成一个圈，从刚才出局者的下一个人开始 ——
// 这不就是一个人数少一个的、一模一样的问题吗？
//
// 看出这一点，正文第 9 步那个递推式就是水到渠成的事了。

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

int main() {
    long long n, m;
    if (!(cin >> n >> m)) return 0;
    if (n <= 0 || n > 20 || m <= 0) { cout << "这份是用来看过程的，请用 1 <= n <= 20\n"; return 0; }

    vector<int> circle(n);
    for (int i = 0; i < n; i++) circle[i] = i + 1;

    vector<int> outOrder;
    size_t pos = 0;
    int round_ = 0;

    while (circle.size() > 1) {
        size_t hit = (pos + (size_t)((m - 1) % (long long)circle.size())) % circle.size();

        cout << "第 " << ++round_ << " 轮：从 " << circle[pos] << " 号开始报数，";
        cout << "报到 " << m << " 的是 " << circle[hit] << " 号　　";
        for (size_t i = 0; i < circle.size(); i++) {
            if (i == hit) cout << "[" << circle[i] << "] ";
            else cout << circle[i] << " ";
        }
        cout << "\n";

        outOrder.push_back(circle[hit]);
        circle.erase(circle.begin() + (long long)hit);
        pos = (hit == circle.size()) ? 0 : hit;
    }

    cout << "\n出局顺序：";
    for (size_t i = 0; i < outOrder.size(); i++) cout << outOrder[i] << (i + 1 == outOrder.size() ? "\n" : " -> ");
    cout << "幸存者：" << circle[0] << " 号\n";
    return 0;
}

// 约瑟夫问题 —— 用暴力打一张表出来，然后自己找规律
//
// 输入：N m
// 输出：n 从 1 到 N，每个 n 对应的幸存者编号
//
// 这份代码没有任何新算法，它调用的还是那个 O(n²) 的模拟。
// 但它演示了一个在竞赛里极其常用的动作：**用暴力打表，从表里看规律。**
//
// 跑一次 N = 15, m = 3，把输出抄在纸上，然后做一件事：
//   把每个答案都减 1（换成从 0 开始编号），再看相邻两项的关系。
//
//     n:      1  2  3  4  5  6  7  8  9  10
//     答案-1: 0  1  1  0  3  0  3  6  0   3
//     ↑ 拿前一项 +3，再对当前的 n 取模，是不是正好等于当前这一项？
//       (0+3)%2=1  (1+3)%3=1  (1+3)%4=0  (0+3)%5=3  (3+3)%6=0  (0+3)%7=3 …
//
// 看出来了，那就是 f(i) = (f(i-1) + m) % i。
//
// 找规律不是「投机取巧」，它是正经的解题手段：先猜，再证，最后用对拍验。
// 猜错了对拍会告诉你 —— 这就是为什么这个站点到处都在对拍。

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

/** 老老实实模拟，返回 n 个人、每报到 m 出局时的幸存者编号（1 基） */
int survivor(int n, int m) {
    vector<int> circle(n);
    for (int i = 0; i < n; i++) circle[i] = i + 1;

    size_t pos = 0;
    while (circle.size() > 1) {
        pos = (pos + (size_t)((m - 1) % (long long)circle.size())) % circle.size();
        circle.erase(circle.begin() + (long long)pos);
        if (pos == circle.size()) pos = 0;
    }
    return circle[0];
}

int main() {
    int N, m;
    if (!(cin >> N >> m)) return 0;
    if (N <= 0 || N > 2000 || m <= 0) { cout << "请用 1 <= N <= 2000, m >= 1\n"; return 0; }

    cout << "  n   幸存者   幸存者-1（0 基编号）\n";
    cout << "---   ------   ------------------\n";
    for (int n = 1; n <= N; n++) {
        int s = survivor(n, m);
        cout << setw(3) << n << setw(9) << s << setw(15) << (s - 1) << "\n";
    }
    return 0;
}

// 约瑟夫问题 —— 递推
//
// 输入输出和 josephBrute.cpp 完全一样，但是 O(n) 的，而且不用开数组。
//
// 关键的一步（正文第 9 步会详细讲）：
//   第一个出局的是 m 号。剩下的 n-1 个人从 m+1 号开始重新报数 ——
//   这**就是一个 n-1 个人的约瑟夫问题**，只不过所有人的编号都平移了 m。
//
// 用「从 0 开始的编号」来写最干净（这样取模不用来回 +1 -1）：
//     f(1) = 0
//     f(i) = (f(i-1) + m) % i
//   最后答案是 f(n) + 1，把 0 基编号换回 1 基。
//
// 注意这里递推的方向：从 1 个人往 n 个人推。
// 也可以写成递归（f(n) 调用 f(n-1)），思路完全一样，但 n 大了会爆栈。
// 「能写成递推就别写递归」—— 这条经验第 17 章还会再遇到一次。

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

int main() {
    long long n, m;
    if (!(cin >> n >> m)) return 0;
    if (n <= 0 || m <= 0) { cout << 0 << "\n"; return 0; }

    long long f = 0;                       // f(1) = 0
    for (long long i = 2; i <= n; i++)
        f = (f + m) % i;                   // f(i) = (f(i-1) + m) % i

    cout << f + 1 << "\n";                 // 0 基换回 1 基
    return 0;
}

// 约瑟夫问题 —— 递推
//
// 输入输出和 josephBrute.cpp 完全一样，但是 O(n) 的，而且不用开数组。
//
// 关键的一步（正文第 9 步会详细讲）：
//   第一个出局的是 m 号。剩下的 n-1 个人从 m+1 号开始重新报数 ——
//   这**就是一个 n-1 个人的约瑟夫问题**，只不过所有人的编号都平移了 m。
//
// 用「从 0 开始的编号」来写最干净（这样取模不用来回 +1 -1）：
//     f(1) = 0
//     f(i) = (f(i-1) + m) % i
//   最后答案是 f(n) + 1，把 0 基编号换回 1 基。
//
// 注意这里递推的方向：从 1 个人往 n 个人推。
// 也可以写成递归（f(n) 调用 f(n-1)），思路完全一样，但 n 大了会爆栈。
// 「能写成递推就别写递归」—— 这条经验第 17 章还会再遇到一次。

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

int main() {
    long long n, m;
    if (!(cin >> n >> m)) return 0;
    if (n <= 0 || m <= 0) { cout << 0 << "\n"; return 0; }

    long long f = 0;                       // f(1) = 0
    for (long long i = 2; i <= n; i++)
        f = (f + m) % i;                   // f(i) = (f(i-1) + m) % i

    cout << f + 1 << "\n";                 // 0 基换回 1 基
    return 0;
}