GCC (since some version) guarantees to make an optimisation in the case for (int i = 0; i < f(n); i++), so that f(n) computes only once (obviously, only when it succeeds to prove that f(n) does not change during the loop).

You can verify this yourself if you go to https://mirror.codeforces.com/problemset/customtest and try to experiment with the following code:

#include <iostream>
#include <math.h>

int main()
{
  int n = -1;
  double sqrt_n = sqrt(n);

  errno = 0;
  std::cout << "sqrt_n=" << sqrt_n << "\n";
  std::cout << "sqrt(n)=" << sqrt(n) << "\n";
  std::cout << "errno=" << errno << "\n";
}

The compiler is not allowed to get rid of the second call to "sqrt(n)" function and replace it by using the already pre-calculated value "sqrt_n". This optimization can't be safely applied, because it would change the user visible program behaviour and the printed errno value would be different.

But there is a special -ffast-math compiler option (which doesn't seem to be used by the codeforces platform by default), and it may help: https://stackoverflow.com/a/22135559/4882445

The code for (int i = 0; i < sqrt(n); i++) surely does call the sqrt function again and again on each loop iteration, unless the -ffast-math option is used. This all is very fragile and such code stinks.

It's fine for small numbers, but for bigger numbers you can run into precision errors. There are two solutions:

1. Increment or decrement the answer a few times, because you're guaranteed to be close even if there are precision errors. Something like this:

   long long my_sqrt(long long x) {
       long long y = x;
       if (y*y < x) y++;
       if (y*y > x) y--;
       return y;
   }
   

2. Just use u*u <= x. This saves a bit of time to implement, and your sanity. But if you need to explicitly calculate the square root, then use the first way.