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 <algorithm>
       
 
       
// most of the code is based on problem 75

       
 
       
// find greatest common divisor

       
template <typename T>
       
T gcd(T a, T b)
       
{
       
  while (a != 0)
       
  {
       
    T c = a;
       
    a = b % a;
       
    b = c;
       
  }
       
  return b;
       
}
       
 
       
int main()
       
{
       
  // 10^6
       
  unsigned int limit = 1000000;
       
  std::cin >> limit;
       
 
       
  std::vector<std::vector<unsigned int>> sides(limit);
       
 
       
  // generate all Pythagorean triples (see https://en.wikipedia.org/wiki/Pythagorean_triple )
       
  for (unsigned int m = 2; m*m < limit; m++)
       
    for (unsigned int n = (m & 1) + 1; n < m; n += 2)
       
    {
       
      // only valid m and n
       
      if (gcd(m, n) != 1)
       
        continue;
       
 
       
      // compute basic triple
       
      auto a = m*m - n*n;
       
      auto b = 2*m*n;
       
      auto c = m*m + n*n;
       
 
       
      // and all multiples
       
      for (unsigned int k = 1; k*c < limit; k++) // longest side must be < 10^6
       
      {
       
        // either height is shorter than width ...
       
        sides[k*a].push_back(k*b);
       
        // or the other way around
       
        sides[k*b].push_back(k*a);
       
      }
       
    }
       
 
       
  auto count = 0;
       
  // process all triangles with one identical side (the width of the street)
       
  for (const auto& current : sides)
       
  {
       
    // compare all potential heights
       
    for (size_t left = 0; left < current.size(); left++)
       
      for (size_t right = left + 1; right < current.size(); right++)
       
      {
       
        auto X = current[left];
       
        auto Y = current[right];
       
 
       
        // see "Algorithm" for an explanation of the formula
       
        if ((X * (unsigned long long)Y) % (X + Y) == 0)
       
          count++;
       
        // note: need 64 bit multiplication because of potential overflows
       
      }
       
  }
       
 
       
  // display result
       
  std::cout << count << std::endl;
       
  return 0;
       
}

This solution contains 10 empty lines, 14 comments and 3 preprocessor commands.