My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <vector>
       
#include <cmath>
       
 
       
// count open doors in a segment "from"-"to" (including "from", but excluding "to"

       
unsigned long long bruteForce(unsigned long long from, unsigned long long to)
       
{
       
  // allocate enough RAM
       
  auto size = to - from;
       
  std::vector<bool> doors(size, 0);
       
  // note: char instead of bool is about 15% faster but needs 700% more memory
       
 
       
  // look at all relevant squares i^2 + j^2
       
  for (unsigned long long i = 1; 2*i*i < to; i++)
       
  {
       
    // find smallest j such that i^2 + j^2 >= from
       
    auto minJ = i + 1;
       
    if (from > i*i + minJ*minJ)
       
      minJ = ceil(sqrt(from - i*i));
       
 
       
    // process all j until i^2 + j^2 >= to
       
    for (auto j = minJ; ; j++)
       
    {
       
      auto index = i*i + j*j;
       
      // range check
       
      if (index >= to)
       
        break;
       
 
       
      // adjust offset
       
      index -= from;
       
      // and "flip" that door
       
      doors[index] = !doors[index];
       
    }
       
  }
       
 
       
  // open doors => lowest bit is set
       
  unsigned long long result = 0;
       
  for (auto x : doors)
       
    result += x & 1; // x is odd => door is open
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // 10^7 doors per segment
       
  const auto SliceSize =     100000000ULL;
       
  // 10^12 doors in total
       
  auto       limit     = 1000000000000ULL;
       
  std::cin >> limit;
       
 
       
  // total number of segments
       
  auto numSlices = limit / SliceSize; // => 10^12 / 10^7 = 10^5 by default
       
  if (numSlices == 0)
       
    numSlices++;
       
 
       
  // will contain the final result
       
  unsigned long long sum = 0;
       
 
       
  // 0 => all cores, 1 => one CPU, 2 => 2 CPUs, ... I used 6 on my 4+4-core system
       
#define PARALLEL
       
#ifdef  PARALLEL
       
  auto numCores = 6;
       
#pragma omp parallel for num_threads(numCores) reduction(+:sum) schedule(dynamic)
       
#endif
       
  for (unsigned int i = 0; i < numSlices; i++)
       
  {
       
    // compute lower/upper limit of current segment
       
    auto from = i * SliceSize;
       
    auto to   = from + SliceSize; // "to" is excluded
       
    if (to >= limit)
       
      to = limit + 1; // extend last segment to include "to" as well
       
 
       
    // process segment
       
    auto current = bruteForce(from, to);
       
    sum += current;
       
 
       
    // time echo "1000000000000" | ./611  <= numCores was set to 6
       
    // real    48m34.024s
       
    // user    290m21.924s
       
    // sys     0m49.327s
       
 
       
    // and for numCores = 1 (roughly half as fast)
       
    // real    94m51.945s
       
    // user    94m42.514s
       
    // sys     0m8.803s
       
  }
       
 
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 14 empty lines, 25 comments and 7 preprocessor commands.