PROJECT EULER #75

Link to Project Euler problem 75

It turns out that 12 cm is the smallest length of wire that can be bent to form an integer sided right angle triangle in exactly one way, but there are many more examples.

12 cm: (3,4,5)
24 cm: (6,8,10)
30 cm: (5,12,13)
36 cm: (9,12,15)
40 cm: (8,15,17)
48 cm: (12,16,20)

In contrast, some lengths of wire, like 20 cm, cannot be bent to form an integer sided right angle triangle, and other lengths allow more than one solution to be found; for example, using 120 cm it is possible to form exactly three different integer sided right angle triangles.

120 cm: (30,40,50), (20,48,52), (24,45,51)

Given that L is the length of the wire, for how many values of L 2,000,000 can exactly one integer sided right angle triangle be formed?

Using the two integer (m,n) technique for generating Pythagorean triples,I verify that they are primitive (using the IsRelativelyPrime method) then generate the non-primitives by simple scaling. Most of the time used goes to generate the list of prime factors of every number up to 2100000. The rest of the code uses 600 ms.

using System;
using System.Collections.Generic;

namespace project_euler
{
  class Program
  {
      public static Dictionary<int,List<int>> primeFactors = GeneratePrimeFactors(2100000);
      static void Main()
      {
          //Problem 75
          DateTime start = DateTime.Now;
          var pythagorasRecord = new Dictionary<long, int>();
          int count = 0;
          for (int m = 2; m < 1000000/m; m++)
              for (int n = 1; n < m; n++)
              {
                  long littleLeg = 2*m*n;
                  long bigLeg = m*m - n*n;
                  long hypotenuse = m*m + n*n;
                  if (IsRelativelyPrime(bigLeg, littleLeg))
                  {
                      long perimeter = littleLeg + bigLeg + hypotenuse;
                      long sum = perimeter;
                      while (sum <= 2000000)
                      {
                          if (pythagorasRecord.ContainsKey(sum))
                              pythagorasRecord[sum] += 1;
                          else
                              pythagorasRecord.Add(sum, 1);
                          sum += perimeter;
                      }
                  }
              }
          foreach (KeyValuePair<long, int> pair in pythagorasRecord)
              if (pair.Value == 1)
                  count++;
          Console.WriteLine(count);
          TimeSpan time = DateTime.Now - start;
          Console.WriteLine("This took {0}", time);
          Console.ReadKey();
      }
      public static bool IsRelativelyPrime (long m,long n)
      {
          foreach (long i in primeFactors[(int)m])
              if (n % i == 0) return false;
          return true;
      }
      public static Dictionary<int,List<int>> GeneratePrimeFactors(int n)
      {
          var primes = GeneratePrimes(n);
          var pF = new Dictionary<int, List<int>>();
          pF.Add(0,new List<int>{0});
          for (int i = 1; i <= n; i++)
              pF.Add(i,new List<int>());
          if (n == 1) return pF;
          foreach (int i in primes)
              for (int j = i; j <= n; j += i)
                  pF[j].Add(i);
          return pF;
      }
      public static bool IsPrime(int n)
      {
          if (n < 2) return false;
          if (n == 2) return true;
          for (long i = 2; i <= Math.Sqrt(n); i++)
              if (n % i == 0) return false;
          return true;
      }
      public static List<int> GeneratePrimes(int n)
      {
          var primeNumbers = new List<int> { 2, 3 };
          for (int i = 5; i <= n; i += 2)
              if (IsPrime(i))
                  primeNumbers.Add(i);
          return primeNumbers;
      }
  }
}