Question

I was told by an experienced programmer(spoj,codechef,topcoder etc ) than as a general rule one can use int for values upto 10^9.

What is the general rule for using
signed long int,
unsigned long int,
signed long long int,
unsigned long long int

Answer 1

It depends on your portability constraints. Formally, an int is only
guaranteed to support values in the range [-32767,32767], so anytime
you need more, you should use long. Practically, a lot of programs
don’t need portability to 16 bit machines (which are very rare today),
and on most modern 64 bit platforms, long will be 64 bits, which is
more than is needed, and will slow things down (if only because of
poorer locality). If you can assume int is at least 32 bits, that’s
what you should use pretty much everywhere, with the following
exceptions:

• If you’re concerned with the actual bitwise representation, using bitwise &, |, ^ and ~, or the shifting operators, then you should use unsigned types, unsigned int by default, but other sizes if one of the following cases occurs.

• If you need the modulo arithmetic of unsigned, use an unsigned type. This is very, very rare, but does occur in things like calculating hash
  codes.

• If you have really large tables (vectors or any other contiguous representation), you might consider short or even signed char (or unsigned short or unsigned char, if you’re concerned with the bitwise representation). I would not use plain char for anything but characters, since its signedness is implementation defined.

• If you need to represent values greater than 2^31, then consider long long. (Often, however, even long long won’t be big enough in such cases, and you’ll need some sort of BigInteger class.)

As a general rule, anything but int should be the exception.