这是为您准备的**“时空旅行者的怀表”**题目专用数据生成器。

该生成器包含标准解答逻辑，并精心设计了 10 个测试点，覆盖了从简单的加减法到跨越多天的时空跳跃，以及极端的整数边界情况。

Generator 代码 (gen_clock.cpp)

请将以下代码保存为 gen_clock.cpp，编译并运行。它会在当前目录下生成 1.in/1.out 到 10.in/10.out。

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

// ==========================================
// Part 1: 标准解答 (Standard Solution)
// 用于生成正确答案
// ==========================================
long long solve(long long h, long long n) {
    // 核心公式：((h + n) % 24 + 24) % 24
    // 使用 long long 防止 n 很大时计算溢出（虽然 n=10^9 int 也够，但习惯上防溢出）
    return ((h + n) % 24 + 24) % 24;
}

// ==========================================
// Part 2: 数据生成器工具 (Generator Tools)
// ==========================================
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

// 生成 [L, R] 范围内的随机整数 (支持 long long)
long long random_long(long long L, long long R) {
    return uniform_int_distribution<long long>(L, R)(rng);
}

// ==========================================
// Part 3: 测试点生成逻辑
// ==========================================
void generate_case(int case_id) {
    long long h, n;

    switch (case_id) {
        case 1: // 【基础】简单加法，不跨天
            h = 10; 
            n = 5;
            break;

        case 2: // 【基础】跨越午夜（加法）
            h = 23; 
            n = 2; // 结果应该是 1
            break;

        case 3: // 【基础】简单减法，不跨天
            h = 15; 
            n = -5; // 结果应该是 10
            break;

        case 4: // 【基础】时光倒流跨越午夜
            h = 2; 
            n = -5; // 结果应该是 21
            break;

        case 5: // 【边界】原地不动
            h = random_long(0, 23);
            n = 0;
            break;

        case 6: // 【特殊】恰好过了整数天 (n 是 24 的倍数)
            h = random_long(0, 23);
            n = 24 * random_long(1, 100);
            break;

        case 7: // 【特殊】恰好倒退整数天
            h = random_long(0, 23);
            n = -24 * random_long(1, 100);
            break;

        case 8: // 【压力】向未来大幅跳跃 (n 很大)
            h = random_long(0, 23);
            n = random_long(10000, 1000000000LL);
            break;

        case 9: // 【压力】向过去大幅跳跃 (n 很小)
            h = random_long(0, 23);
            n = random_long(-1000000000LL, -10000LL);
            break;
            
        case 10: // 【极端】最大数据边界混合
            h = 0; // 从 0 点开始
            // 测试极端的 n 值，确保取模正确
            n = (case_id % 2 == 0) ? 1000000000LL : -1000000000LL;
            break;

        default:
            h = 0; n = 0;
            break;
    }

    // ------------------------------------
    // 文件写入操作
    // ------------------------------------
    string in_file = to_string(case_id) + ".in";
    string out_file = to_string(case_id) + ".out";

    // 1. 写入输入文件
    ofstream fin(in_file);
    fin << h << " " << n << endl;
    fin.close();

    // 2. 计算并写入输出文件
    long long ans = solve(h, n);
    ofstream fout(out_file);
    fout << ans << endl;
    fout.close();

    cout << "Generated Case " << case_id << ": H=" << h << ", N=" << n 
         << " -> Ans=" << ans << endl;
}

int main() {
    // 生成 1 到 10 号测试点
    for (int i = 1; i <= 10; ++i) {
        generate_case(i);
    }
    cout << "All 10 test cases generated successfully." << endl;
    return 0;
}

使用指南

1. 保存：将代码保存为 gen_clock.cpp。
2. 编译：g++ gen_clock.cpp -o gen_clock -std=c++11
3. 运行：
   • Windows: gen_clock.exe
   • Mac/Linux: ./gen_clock
4. 验证：
   • Case 4: 打开 4.in 应为 2 -5，4.out 应为 21。
   • Case 6/7: 由于 $N$ 是 24 的倍数，输出的时间应与输入的 $H$ 相同。
   • Case 9: $N$ 是巨大的负数，验证你的解题代码是否会输出负数（如果输出了负数，说明公式写错了）。此生成器产生的 .out 保证是正数（$0 \sim 23$）。

【参考代码 (C++14)】

#include <iostream>
using namespace std;

int main() {
    // 优化输入输出效率
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    long long h, n; // 虽然 h 是 int，但 n 很大，运算过程建议用 long long 防止意外溢出
    if (cin >> h >> n) {
        // 核心公式
        // 1. (h + n) % 24 : 初步取模，C++中如果 n 是负数，结果可能是负数
        // 2. + 24        : 将可能的负数结果变为正数
        // 3. % 24        : 再次取模，防止原本就是正数时加上24超过范围
        
        long long ans = ((h + n) % 24 + 24) % 24;
        
        cout << ans << endl;
    }
    return 0;
}

【测试数据点设计建议】

如果你要把它做成 OJ 题目，建议设置 5 个测试点：

1. Normal: $H=10, N=5$ (结果 15，普通加法)
2. Cross Day: $H=23, N=2$ (结果 1，跨天)
3. Backwards: $H=2, N=-3$ (结果 23，简单倒流)
4. Loop Positive: $H=10, N=2401$ (结果 11，未来很多天)
5. Loop Negative: $H=5, N=-100000$ (结果 13，回到远古时代，测试大数取模)