I usually define my adjacency list, visited array, and other things globally for graph problems and reset them at the end of every test case. So one day I had hard time debugging code for a graph problem. After debugging for hours mistake turned out to be that I wasn't resetting the global things in some cases where I was using continue.

const int N = 1e5 + 5;
vector<int> gr[N], vis(N);

main(){

  for (int t = 1; t <= tc; ++t) {

     // code
        
     // some special case 
     {
        // didn't reset the global variables
        continue;
     }

     // reset everything.
  }

}

Now I reset the global variables at the start of every test case like this.

const int N = 1e5 + 5;
vector<int> gr[N], vis(N);

main(){

  for (int t = 1; t <= tc; ++t) {

     // reset everything.

    // code
    
    // some special case 
     {
        // now its fine :)
        continue;
     }

     
  }

}

this by rotavirus

The very first contest here at codeforces, I solved one problem, then got hacked for the worst case O(N^2) sorting on primitive type in Java. That's when I learned I better use auto-boxing for sorting in Java....

In C++ custom sort function, if I forgot to use references for the 2 input parameters, it can lead to slow execution if the structs are big.

A size of a vector is an unsigned integer, therefore, this for loop :

for(int i=0; i<v.size()-1; i++)

produces a runtime error or TLE when v is empty because its condition is i < (0-1) Since it is stored as an unsigned int, the condition becomes i < SOME_LARGE_NUMBERS because in this case -1 cannot be stored in an unsigned number

The first paragraph is funny because the answer is either $$$x$$$ or $$$x.5$$$ lol

As a (mostly) Python user it has to be this https://mirror.codeforces.com/blog/entry/101817
Thanks to this beethoven97 got the highest number of hacks in a contest https://mirror.codeforces.com/blog/entry/104725?f0a28=1

Actually I think of some others

• getting a TLE because of using unordered_map instead of map

• when calculating 1<<x and the result exceeds the limit of integer. Should be using 1ll << x instead

• passing a vector to a function as a value like this : void f(vector<int> v) runs in $$$O(N)$$$ While passing it by reference like this : void f(vector<int> &v) runs in $$$O(1)$$$ This becomes a troublesome if we run the function that passes the vector as value inside a query

• sorting compare function should returns false if elements are equal

• resetting an array using a memset in a multiple test cases scenario might leads to TLE if the array is declared globally with a static size of maximum possible $$$N$$$

for (int i = 1; i <= n; ++i)
    for (int j = 1; i <= n; ++j)
        ...;

C++ map's operator [] always creates an element, which might cause TLs: https://mirror.codeforces.com/blog/entry/61459?#comment-454131

log10()

158174611

I could have been CM by now if I made a normal count_digits function but instead, I used log10(X) which fails if X is equal to $$$10^{18}-1$$$

Last year, on Facebook Hacker Cup Round 2, I didn't think to create a new file for input. So, when I go the massive input, I tried to COPY PASTE into my tiny CLion input console. Unsurprisingly, it didn't work, given that the test data had around 7 million characters.

This year, I got my revenge (somewhat) by winning a t-shirt in round 2.

This problem

As a C# programmer, there's something to know about floating point numbers: the representation depends on the locale of the machine executing the code. For example the number 1.5 (US writing) would be 1,5 in most other parts of the world. When I was competing on yandex algorithms, there was a task that required to read in a double value (done with double.Parse(Console.ReadLine())). Due to yandex not using the US locale on their servers, I get a RTE verdict. Took me a while to figure out what went wrong. I never ran into this issue on any other website.

I'm surprised no one said -1%2=-1

I compiled a few of those here