printf

scanf

reads integers fast

long long int read_int(){
	char r;
	bool start=false,neg=false;
	long long int ret=0;
	while(true){
		r=getchar();
		if((r-'0'<0 || r-'0'>9) && r!='-' && !start){
			continue;
		}
		if((r-'0'<0 || r-'0'>9) && r!='-' && start){
			break;
		}
		if(start)ret*=10;
		start=true;
		if(r=='-')neg=true;
		else ret+=r-'0';
	}
	if(!neg)
		return ret;
	else
		return -ret;
}

Go to Codechef. Find a problem with a huge amount of input. Look at the fastest submit. Profit.

You can use fast cin/cout by writing "ios::sync_with_stdio(false);" on the top of your programm!

another approach is to read and store the entire input in a buffer before you begin processing it. Fastest functions are fread and fwrite (they are technically C functions, but should work fine in C++).

I did some benchmarks couple of days ago while trying to find the fastest method for reading integers from stdin. I used input that had 200000 lines and two integers on each line. The results were like this (MinGW 4.8, Intel 3770K):

• cin with operator>> : 540ms
• cin with operator>> (with sync_with_stdio(false)): 100ms
• scanf (two ints at a time): 330ms
• reading each line to buffer with fgets and then parsing ints with atoi: 110ms
• same as above but using hand written version atoi: 50ms
• hand written int parser that uses getchar() to directly read the input: 170ms
• reading entire input to char array with fread and using my own int parser: 30ms
• reading blocks of 1kB to char array with fread and using my own int parser: 30ms

So it's important to minimize the number of calls to standard library functions. The only type of IO that standard library does fast is transferring large chunks of data. I ended up with the last option because it's almost as fast as buffering the entire input but uses much less memory. Here's the code (it has some flaws but for contests it's good enough):

static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof (stdinBuffer);
static const char* stdinPos = stdinDataEnd;

void readAhead(size_t amount)
{
    size_t remaining = stdinDataEnd - stdinPos;
    if (remaining < amount) {
       memmove(stdinBuffer, stdinPos, remaining);
       size_t sz = fread(stdinBuffer + remaining, 1, sizeof (stdinBuffer) - remaining, stdin);
       stdinPos = stdinBuffer;
       stdinDataEnd = stdinBuffer + remaining + sz;
       if (stdinDataEnd != stdinBuffer + sizeof (stdinBuffer))
         *stdinDataEnd = 0;
    }
}

int readInt()
{
    readAhead(16);

    int x = 0;
    bool neg = false;
    if (*stdinPos == '-') {
       ++stdinPos;
       neg = true;
    }

    while (*stdinPos >= '0' && *stdinPos <= '9') {
       x *= 10;
       x += *stdinPos - '0';
       ++stdinPos;
    }

    return neg ? -x : x;
}

edit: this version requires manually skipping whitespace (stdinPos++), but it could easily be added to the function itself.

Slightly irrelevant, but since the topic was brought up: I've never seen contests that give contestant choice to perform IO using either:

1. formatted input/output (human readable, slower for integer IO, most contests use this)
2. binary input/output (less readabale, faster for reading huge arrays of integers, I've seen this only once or twice in OpenCup).

Of course, this "ability to choose" has cons:

1. is harder to maintain (e.g. in CodeForces you use only stdin/stdout, what do you use as 3rd/4th stream?)
2. could provoke "silly" mistakes (forgeting to switch between formatted <--> binary) in participants code
3. what do you do in interactive problems (most likely, this isn't a problem, because interaction is blocking anyway...)

Could this idea be used (at least) for problems that have big input/output files? By that, I mean — in the description of a task don't add comment that goes like this:

"oh yeah, input's huge, don't use slow IO, like C++ cin/cout, use printf/scanf",

but provide an option to read from "input.txt" or "binary.in", and write to "output.txt" or "binary.out".

fast IO from Burunduk1

Premature optimization is the root of all evil. Strict to cin/cout or scanf/printf.