We are excited to announce support for **Interactive Problems** on Repovive! Unlike traditional problems where you read all input at once, interactive problems require your solution to "talk" to the judge in real-time. Think of it as a conversation where each side reacts to the other's messages. ## How It Works: The "Conversation" In a standard problem, the judge pipes a file into your program. In an interactive problem, the judge runs a second program called an **Interactor** alongside your solution. The data flow looks like this: - **The Judge** reads the hidden test case file (`.in`) and feeds it to the **Interactor** (via `stdin`). - **The Interactor** processes the secret and sends a hint to your **Solution** (via `tout`). - **Your Solution** reads the hint, processes it, and sends a response (via `stdout`). - **The Interactor** reads your response (via `tin`) and decides whether to continue the game or end it with a verdict. ## For Contestants: How to Solve Solving an interactive problem is similar to a normal problem, but with one critical requirement: **You must flush your output.** ### The "Idleness Limit" Trap Most programming languages buffer output to save time. In an interactive problem, if your guess stays in the buffer, the Interactor never receives it. The Interactor waits for you, you wait for the Interactor, and the result is a **Time Limit Exceeded** (specifically an Idleness Limit). For our case on Repovive, **Idlenss Limit Exceeded Is treated as a Wrong Answer** **The Solution:** - **C++:** Use `std::endl` (which flushes) instead of `\n`. Or call `std::cout.flush()`. - **Python:** Use `print(..., flush=True)`. - **Java:** Use `System.out.println()` followed by `System.out.flush()`. ### Sample Solution (C++) C++ ```text #include #include using namespace std; int main() { int low, high; // 1. Read the initial range from the Interactor if (!(cin >> low >> high)) return 0; while (low <= high) { int mid = low + (high - low) / 2; // 2. Send your guess and FLUSH cout << mid << endl; // 3. Read the response string response; cin >> response; if (response == "correct") break; if (response == "higher") low = mid + 1; else high = mid - 1; } return 0; } ``` ## For Problem Setters: Creating the Interactor To set an interactive problem, you need to write a C++ program using our internal library `repovive.h`. ### The Interface You do not need to manage pipes or processes. Simply implement the `interact()` function, and whatever you do, never please, just never put a main function inside the interactor.cpp, the file you upload, **Must NEVER have a main function, ** - `cin`: Reads from the secret test case file (`.in`). - `tout`: Sends data to the user’s `stdin`. - `tin`: Reads data from the user’s `stdout`. - `cerr`: Use this for logging. It will be visible in the interaction logs in the editor page, so please make them meaningful to help our users! ### Interactor Template C++ ```text #include "repovive.h" bool interact() { // 1. Read secret data from the judge's .in file int min_val, max_val, target; if (!(cin >> min_val >> max_val >> target)) { cerr << "Setter: Error reading .in file" << endl; return WRONG_ANSWER; } // 2. Send initial data to the user tout << min_val << " " << max_val << endl; int max_attempts = 50; for (int i = 0; i < max_attempts; ++i) { int guess; // 3. Read guess from user (tin handles timeouts automatically) if (!(tin >> guess)) { cerr << "Verdict: User solution crashed or timed out." << endl; return WRONG_ANSWER; } if (guess == target) { tout << "correct" << endl; return ACCEPTED; } tout << (guess < target ? "higher" : "lower") << endl; } return WRONG_ANSWER; // Exceeded attempts } ``` ## Under the Hood: The Driver Logic For those interested in the systems side, Repovive's judge uses a custom driver `dirver.cpp` to manage the sandbox. It leverages: - **Unix Pipes**: Redirecting file descriptors between two concurrent processes. - `poll()`** & Custom Streambufs**: Our `TimeoutStreambuf` ensures that if a user's code hangs, the Interactor can detect the lack of data and fail gracefully rather than hanging the entire judge. - `rlimit`: Enforcing strict CPU and Memory limits on the user's sandbox without affecting the Interactor's performance. > **Technical Note:** On Repovive, `tout` is set to `ios::unitbuf`, meaning it flushes automatically. You don't need to manually flush `tout`, but your users **must** flush their `stdout`. ## Best Practices for Setters - **Be Explicit:** Clearly state the maximum number of queries allowed in the problem description. - **Validate Input:** Always check if `tin` fails. If the user sends a string i

The end-to-end platform for shaping elite talent.

Learn from structured roadmaps and videos.

Practice with high-quality problems and compete in contests.

Build your developer profile with Repovive interviews.

Global Ranking

Repovive Interviews

Interactive Roadmaps

FAANG Problemset

Coding Contests

Code Arena

Intent Interview with Sophie

Fit Interview with Alicia

Achievements Talk with Arjun

Technical Screen with Kevin

Dynamic Programming

Pattern 22: LeetCode Interview Patterns

Claude Code

and 29 more...

Name Collision Handler

Grid Spread Timer

Network Wiring Budget

Best Coupon Price

Repovive Standard Round 2

Repovive Standard Round 1 (Sponsored by TIG Foundation)

Repovive Premier Round 2

Repovive Premier Round 1

13 Languages, 20+ Compilers

Vim Keybindings

Real-Time Collaboration

Codeforces & AtCoder Integration

About Repovive