I see. I knew there'd be other contributing factors too like implementation details and compiler optimizations etc but its interesting to see upto 1e9 operations can pass. Thanks!

The amount of operations per second also heavily depends on the memory usage patterns. The best case is arithmetic operations on the small amount of variables. In this case, $$$10^9$$$ may fit into a second (or even in 0.6 seconds). Another good case is sequential access to memory (for example, a simple loop over the array). In this case, the memory accesses fit well into CPU cache. When the memory accesses become more random, much cache misses occur and the things become dramatically slower.

For example, consider this simple program:

volatile int a[1000 * 1000 * 1000];

const int STEP = 1;

int main() {
    for (int i = 0; i < STEP; ++i) {
        for (int j = i; j < 1000 * 1000 * 1000; j += STEP) {
            a[j] = j;
        }
    }
    return 0;
}

(Minor note: volatile is used to prevent the compiler from optimizing the writes to the array)

It's easy to notice that the program fills each item of the array exactly once, regardless of the value of STEP. But the total running time will change dramatically if I change STEP. If STEP = 1, it runs in about 0.8 seconds on my laptop, but when STEP = 1000, it takes about 9 seconds. (Note also that it's probably not the worst random memory access pattern, and the things may become even slower).

In contests, I usually stick to the values of $$$10^8-10^9$$$ operations per second when writing the code with much sequential access (DPs for example). For data structure problems with binary searches and segment trees, the values of $$$10^7-10^8$$$ are more suitable. Though, most of the time the considerations of the amount of time look like "well, seems it may fit into time limits, let's try to submit it and optimize if I got TL".

Also, you need to consider that integer division and modulo operations are much slower than addition, subtraction and multiplication.

I see, interesting. Thanks!

Got it, thanks! :)

5000 = 5e3

5e4 = 50000

50000^2 = 2.5e9