Most interactive tasks in competitive programming use two primary interfaces: library-based (grader) calls common in domestic OI events and standard input/output (stdio) interactions seen on platforms like Codeforces. This content breaks down core implementation, local debugging workflows, problem-solving mindsets, and evaluation setup.

Core Implementation Notes

Interactive problems typically expose pre-defined query functions, bundled within a provided grader source file. To integrate these, iether include the specified header file (standard in official contests such as NOI series) or declare external C-style functions if headers are not distributed (required for some online judges like Luogu). Your submission only needs to implement one or more required target functions—do not write a main() routine, as the grader includes the entry point that invokes your code.

Take a binary search guessing task as a concrete example. The problem may require implementing a SolveGuess function that takes a maximum range upper_bound and a random seed seed_val, with access to a QueryComparison function that returns 1 if the secret number is strictly larger than the input, -1 if strictly smaller, and 0 on a match.

Below is a restructured binary search implementation tailored for this setup:

#include <cstdint>

extern "C" int QueryComparison(int32_t candidate);

extern "C" int32_t SolveGuess(int32_t upper_bound, int32_t seed_val) {
  int32_t low = 1, high = upper_bound, found = 1;
  while (low <= high) {
    int32_t mid = low + ((high - low) >> 1);
    int result = QueryComparison(mid);
    if (result >= 0) {
      found = mid;
      high = mid - 1;
    } else {
      low = mid + 1;
    }
  }
  return found;
}

The extern "C" specifier ensures cros-linkage compatibility between C and C++ compilers by disabling C++-specific name mangling, which handles function overloading. Both your target function and the grader's query functions need this modifier to avoid linker errors.

Local Debugging Setup

Official contests distribute a grader.cpp, a matching header file (e.g., guess.h), and sample input/output pairs. First, place your implementation file, the grader, and the header in the same directory. For example, if your submission is named guess_submit.cpp, compile all components together using GCC/Clang:

g++ guess_submit.cpp grader.cpp -o guess_debug -Wall -Wextra

By default, many graders write debug or final results only to internal buffers. Modify the sample grader (never use a modified one for submission!) to redirect output to a file or print directly to the console. For Codeforces-style stdio interactions, wrap your cin/cout calls with sync optimizations and avoid mixing C and C++ I/O to prevent synchronization issues.

Problem-Solving Mindsets

Interactive tasks fall into two broad categories: static and adaptive.

Static Tasks

These use a fixed secret value or system state that never changes during queries. Binary search, graph traversal with edge existence checks, and matrix multiplication verification fit here. Focus on minimizing query count with classic algorithms like ternary search, divide and conquer, or randomized sampling.

Adaptive Tasks

The system adjusts its state or secret value after each query, as long as it remains consistent with all prior responses. Treat these as zero-sum games: your goal is to lock the system into a state where only one valid answer exists, regardless of its choices. Avoid naive brute-force approaches, as adaptive graders can force O(n) or worse query counts.

Some tasks disguise adaptive behavior as static—always check problem statements carefully for wording about "adversarial behavior" or "consistent answers only."

Evaluating with Contest-Style Tools

Tools like LemonLime and Lemon support interactive task grading once configured properly:

1. Ensure you understand traditional task setup first.
2. Set the grader path to the official problem header, and the interface implementasion path to the official grader.cpp.
3. Mandatory: Enable "redirect to standard input/output" if required.
4. Place all test cases, the official grader, and the header in your data directory.
5. Run test batches as you would for traditional tasks.