Input/Output Optimization

Why I/O Speed Matters in Competitive Programming

Everything you've written so far cared about correctness — did the program produce the right answer? Competitive programming (CP) adds a second constraint: a strict time limit, often 1–2 seconds, enforced by an online judge. A perfectly correct solution that reads its input too slowly can still fail with a Time Limit Exceeded verdict.

This matters because CP problems routinely read 10⁵ to 10⁶ integers or more. std::cin and std::cout are convenient — type-safe, overloaded for every type — but by default they carry overhead you don't need once you understand where it comes from.

sync_with_stdio(false) & cin.tie(NULL)

Two lines, placed at the very top of main(), are the standard competitive-programming opener. They remove overhead you don't need as long as you commit to using either cin/cout or scanf/printf — not a mix of both.

#include <iostream>
using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    cin >> n;

    long long sum = 0;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        sum += x;
    }

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

ios_base::sync_with_stdio(false) unlinks C++'s streams from C's stdio buffers, so cin/cout no longer pay the cost of staying interleaved with scanf/printf. cin.tie(NULL) removes a separate behavior: by default, cin is "tied" to cout, meaning cin automatically flushes cout's buffer before every read. Untying it lets output batch up naturally instead of flushing on every single input.

'\n' vs std::endl

std::endl does two things: it inserts a newline character, and it flushes the output buffer — forcing any buffered output to be written out immediately. '\n' only does the first part. In a loop that prints thousands or millions of lines, that extra flush on every single endl is pure wasted work.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> results = {10, 25, 7, 42, 3};

    // Slower in a loop: endl flushes the buffer on EVERY iteration
    for (int r : results) {
        cout << r << endl;
    }

    // Faster: '\n' just inserts the character, no forced flush
    for (int r : results) {
        cout << r << "\n";
    }

    return 0;
}

Both loops print the same output. The buffer still gets flushed eventually — automatically when it fills up, and always when the program exits normally — so switching to '\n' never loses output. It simply stops forcing a flush after every single line.

scanf & printf as an Alternative

<cstdio>'s scanf/printf are C's I/O functions. They don't carry iostream's type-safety or operator overloading, but they also don't carry its abstraction overhead, so many competitive programmers reach for them directly instead of tuning cin/cout.

#include <cstdio>

int main() {
    int n;
    scanf("%d", &n);

    long long sum = 0;
    for (int i = 0; i < n; i++) {
        int x;
        scanf("%d", &x);
        sum += x;
    }

    printf("%lld\n", sum);
    return 0;
}

Notice %lld for long long and &x — scanf needs the address of each variable since it can't use references. This is more error-prone than cin >> x (a wrong format specifier compiles fine but reads garbage), which is the real trade-off: scanf/printf can be raw and fast, but they give up the compiler's type checking.

General I/O Tips for Tight Loops

A few more habits that matter once input sizes get large: