Autograder-Safe Code: A Simple Checklist for Students

Background on buffer and flush
Let’s understand what a buffer is. scanf/printf and cin/cout are built on top of read() and write() system call.
To avoid calling these system calls frequently they maintain their own internal buffer.
Input (scanf/cin)
When you read input, the library makes a single call to read() system call to read a large chunk of data and store in its internal
input buffer. Subsequent calls to scanf and cin then read from this buffer. If the buffer runs out of data, another read() is invoked.
Output (printf/cout)
When you print, the data is stored in its internal output buffer. Once the buffer is filled or when a flush is requested, the buffer contents
are written out using the write system call(). Frequent flush operations can become expensive due to invocation of write().
when flushing occurs is determined by buffering mode:
Line buffered: the output is flushed when a new line is printed.
Fully Buffered: the output is flushed when the internal buffer is completely filled or program ends or manually flushed. This is the default mode when stdout is redirected to a file and autograders usually do redirect.
Unbuffered: the output is immediately written.

Now let’s understand why your program might be causing TLE.
Slow cin/cout
In C++, cout and cin are synchronized with printf and scanf. Additionally, cin is tied to cout, which results in cout being flushed before each input operation. Both of these reasons slow down the performance of cout/cin. To speed up their performance you need to disable synchronization and untie cin from cout.

std::ios::sync_with_stdio(false); // disable sync with stdio
std::cin.tie(nullptr); // untie cin from cout

Flush due to std::endl
Using std::endl implicitly flushes cout which may cause performance issues if you’re using too much for example in a loop. Use ‘\n’ instead to print a new line. Let’s compare the timings of std::endl and ‘\n’.
Using std:endl to print a new line

// slow
for (int i = 0; i < 100000000; i++) {
std::cout << output << std::endl;
}

$ time ./a.out > out
real 0m23.017s
user 0m6.405s
sys 0m16.591s

Using ‘\n’ to print a new line

// fast
for (int i = 0; i < 100000000; i++) {
std::cout << output << '\n';
}

$ time ./a.out > out
real 0m1.808s
user 0m1.575s
sys 0m0.233s

Replacing std::endl with '\n' sped up the program by ~12.7x.
Batch your output
If you are printing too much for example inside a very large loop, they can slow down the performance of the program due to internal flushing. Instead you can output inside your own buffer and perform a single output after the loop or when the buffer is full.
Batching example using C

// C fast, uses a custom buffer to collect output and
// prints when the buffer is full or finally at the end.
char buffer[MAX_BUFFER_LENGTH];
size_t buffer_length = 0;
for (int i = 0; i < 10000000; i++) {
int length = sprintf(buffer + buffer_length, "%d: hello\n", i);
buffer_length += length;
if (buffer_length >= FLUSH_LIMIT) {
buffer[buffer_length] = '\0';
printf("%s", buffer);
buffer_length = 0;
}
}

// edge case, what if the buffer_length never crossed FLUSH_LIMIT ?
if (buffer_length != 0) {
buffer[buffer_length] = '\0';
printf("%s", buffer);
}

Here we are assuming there is a good amount of difference between MAX_BUFFER_LENGTH and FLUSH_LIMIT such that sprintf never writes past MAX_BUFFER_LENGTH. Use safe snprintf instead of unsafe sprintf to prevent buffer overflow errors.
Batching example using C++

ostringstream out;
for (int i = 0; i < 10000000; i++) {
out << i << ": hello\n";
}
cout << out.str();