private static long NumberOfWays(long numerator, long denominator, long lowerLimit, long upperLimit)
{
if (upperLimit == lowerLimit)
{
return(numerator * lowerLimit * lowerLimit == denominator ? 1 : 0);
}
var newLowerLimit = (long)Math.Sqrt(denominator / (double)numerator) + 1;
lowerLimit = Math.Max(lowerLimit, newLowerLimit + 1);
if (primes.Contains(upperLimit))
{
upperLimit -= 1;
}
if (primes.Contains(lowerLimit))
{
lowerLimit += 1;
}
long newNumerator = numerator * lowerLimit * lowerLimit - denominator;
long newDenominator = denominator * lowerLimit * lowerLimit;
var gcd = UtilityFunctions.Gcd(newNumerator, newDenominator);
long containsLowerLimit = NumberOfWays(newNumerator / gcd, newDenominator / gcd, lowerLimit + 1, upperLimit);
long doesNotContainLowerLimit = NumberOfWays(numerator, denominator, lowerLimit + 1, upperLimit);
return(containsLowerLimit + doesNotContainLowerLimit);
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(limit);
foreach (var p in primes.Where(t => t > 4))
{
UtilityFunctions.Gcd(-24, p, out long inverse, out var dummy);
var residue = ((inverse + p) * 9) % p;
solution += (residue % p);
}
return(solution);
}
public static long Solution()
{
long solution = 0;
var stopwatch = new Stopwatch();
var gcdStopwatch = new Stopwatch();
for (long a = 1; a <= Math.Sqrt(limit); a++)
{
var stepSize = 2 - (a % 2);
for (long b = 1; b < a; b += stepSize)
{
gcdStopwatch.Start();
var g = UtilityFunctions.Gcd(a, b);
gcdStopwatch.Stop();
if (g > 1)
{
continue;
}
var n = a * a + b * b;
if (n > limit)
{
break;
}
var floor = limit / n;
stopwatch.Start();
for (long k = 1; k <= floor; k++)
{
solution += 2 * (a + b) * k * (limit / (k * n));
}
stopwatch.Stop();
}
}
Console.WriteLine($"Time spent calculating gcd: {gcdStopwatch.ElapsedMilliseconds}");
Console.WriteLine($"Time spent in first loop: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
for (long i = 1; i <= limit; i++)
{
solution -= (limit % i) * (i % 2 == 0? 2:1);
}
stopwatch.Stop();
solution += limit * limit + limit * (limit / 2);
Console.WriteLine($"Time spent in second loop: {stopwatch.ElapsedMilliseconds}");
return(solution);
}
public static long Solution()
{
long solution = 0;
long mLimit = (long)1e4;
HashSet <long> squares = new HashSet <long>();
for (long m = 2; m < mLimit; m++)
{
long kLimit = (long)Math.Sqrt(limit / (m * m * m) + 1);
var step = 2 - (m % 2);
for (long r = 1; r < m; r += step)
{
if (UtilityFunctions.Gcd(m, r) != 1)
{
continue;
}
if (m * m * m * r + r * r >= limit)
{
break;
}
for (long k = 1; k <= kLimit; k++)
{
long n = k * k * m * m * m * r + k * r * r;
if (n >= limit)
{
break;
}
if (UtilityFunctions.IsPerfectSquare(n))
{
if (!squares.Contains(n))
{
solution += n;
squares.Add(n);
}
}
}
}
}
return(solution);
}
public static long Solution()
{
long solution = 0;
for (int a = 1; a <= limit; a++)
{
for (int c = 1; c <= a; c++)
{
for (int b = 1; b <= limit; b++)
{
for (int d = 1; d <= b; d++)
{
var internalPoints =
((a + c) * (b + d)
- UtilityFunctions.Gcd(a, b)
- UtilityFunctions.Gcd(b, c)
- UtilityFunctions.Gcd(c, d)
- UtilityFunctions.Gcd(d, a)) / 2 + 1;
if (UtilityFunctions.IsPerfectSquare(internalPoints))
{
solution += 4;
if (a == c || b == d)
{
solution -= 2;
if (a == c && b == d)
{
solution -= 1;
}
}
}
}
}
}
}
return(solution);
}
public static long Solution()
{
long answer = 0;
var validPairs = new Dictionary <long, HashSet <long> >();
var validSums = new HashSet <long>();
for (long m = 2; m < limit; m++)
{
var stepSize = 2 - (m % 2);
for (long n = 1; n < m; n += stepSize)
{
if (UtilityFunctions.Gcd(m, n) != 1 || (m - n % 3) == 0)
{
continue;
}
var firstSide = 2 * m * n + n * n;
var secondSide = m * m - n * n;
if (m * m + 2 * m * n > limit)
{
break;
}
var p = Math.Max(firstSide, secondSide);
var q = Math.Min(firstSide, secondSide);
for (long k = 1; k < limit; k++)
{
if (k * (p + q) > limit)
{
break;
}
if (validPairs.ContainsKey(k * p))
{
validPairs[k * p].Add(k * q);
}
else
{
validPairs.Add(k * p, new HashSet <long> {
k *q
});
}
}
}
}
foreach (var p in validPairs.Keys)
{
foreach (var q in validPairs[p])
{
if (validPairs.ContainsKey(q))
{
long sum = long.MaxValue;
foreach (var r in validPairs[q])
{
if (validPairs[p].Contains(r))
{
var aSquare = p * p + q * q + p * q;
var bSquare = p * p + r * r + p * r;
var cSquare = r * r + q * q + r * q;
if (bSquare + cSquare < aSquare)
{
var bc = Math.Sqrt(bSquare * cSquare);
if (bSquare + cSquare + bc < aSquare)
{
continue;
}
}
sum = p + q + r;
if (sum < limit)
{
validSums.Add(sum);
Console.WriteLine($"{p} {q} {r} {sum}");
}
}
}
}
}
}
foreach (var sum in validSums)
{
answer += sum;
}
return(answer);
}
