Fast Input/Output for Competitive Programming

Why I/O Speed Matters

In competitive programming, time limits are tight — typically 1-2 seconds for C++ and 3-5 seconds for Python. When your problem involves reading 10^6 integers, slow I/O can be the difference between Accepted and Time Limit Exceeded (TLE). I have seen students lose contests not because their algorithm was wrong, but because cin was too slow without proper configuration.

C++: The Critical Optimization

The Problem with cin/cout

By default, C++ synchronizes cin/cout with C's scanf/printf to allow mixing both in the same program. This synchronization adds significant overhead. Additionally, cin is tied to cout, meaning cout flushes before every cin read.

The Fix: Two Magic Lines

The first line disables synchronization with C I/O. The second unties cin from cout. Together, they make cin/cout roughly as fast as scanf/printf.

Important: After sync_with_stdio(false), do NOT mix cin/cout with scanf/printf in the same program. Pick one style.

Benchmark Comparison

Reading 10^7 integers:

scanf/printf: The C Way

Still widely used by competitive programmers who want guaranteed speed:

Format specifiers: %d (int), %lld (long long), %f (float), %lf (double), %s (string/char array), %c (char).

Ultra-Fast: Custom getchar Reader

For problems with extremely large input (10^7+ numbers), some contestants use a custom reader that processes input character by character:

This avoids all formatting overhead. Use it only when I/O is the proven bottleneck.

Avoid endl, Use "\n"

endl flushes the buffer every time it is called. With 10^5 output lines, this creates 10^5 flush operations. Use "\n" instead:

Java: BufferedReader and PrintWriter

Java's Scanner class is notoriously slow due to regex-based parsing. Use BufferedReader and StreamTokenizer instead:

Slow (Scanner)

Fast (BufferedReader + StringTokenizer)

Even Faster (StreamTokenizer)

Benchmark (Reading 10^6 integers in Java)

Python: The Slowest but Improvable

Python is inherently slow for I/O, but there are tricks to minimize the damage.

Use sys.stdin Instead of input()

sys.stdin.readline is roughly 3x faster than the built-in input() because it skips the prompt handling.

Read All Input at Once

For very large inputs, read everything in one system call:

Output: Join and Print Once

Use PyPy When Available

PyPy is typically 5-10x faster than CPython for algorithmic code. Most platforms (Codeforces, AtCoder) offer PyPy as a submission option. If your Python solution gets TLE, try PyPy before rewriting in C++.

When Does I/O Actually Matter?

I/O optimization matters when:

• Input size exceeds 10^5 elements
• You have many test cases (T ≤ 10^5) each with input
• The algorithm itself is O(n) or O(n log n) — I/O becomes a significant fraction of total time

I/O optimization does NOT matter when:

• Input is small (N ≤ 1000)
• Your algorithm is O(n²) or worse — the algorithm dominates
• You are using Python (algorithm speed is usually the bottleneck, not I/O)

Complete C++ Template with Fast I/O

This template covers 95% of competitive programming problems. Memorize it.

Language-Specific Gotchas

C++: Mixing cin and getline

A common bug: after reading an integer with cin >> n, calling getline() reads the leftover newline character. Fix:

Python: The map(int, input().split()) Pattern

This is the standard way to read multiple integers on one line in Python:

Java: The System.out.println Trap

Each System.out.println() call can be slow due to auto-flushing. Buffer your output:

Real Contest Scenarios

Scenario 1: "My solution is O(n) but I still get TLE"

This almost always means I/O is the bottleneck. Check:

1. Are you using cin without sync_with_stdio(false)?
2. Are you using endl instead of "\n"?
3. For Python: are you using input() instead of sys.stdin.readline?

Scenario 2: "It works locally but TLE on judge"

Online judges have slower I/O than your machine. The judge reads from stdin pipe, which behaves differently from terminal input. Always use fast I/O even if your local tests pass without it.

Scenario 3: "My Python solution is 3x the time limit"

Options in order of effort:

1. Switch to PyPy (often 5-10x speedup, zero code changes)
2. Use sys.stdin.buffer.read() and pre-parse all input
3. Avoid creating unnecessary objects (list comprehensions over loops)
4. If nothing works, rewrite in C++ (last resort)

Summary of Best Practices