public long Problem3()
{
long number = 600851475143;
List <long> primes = new List <long>();
for (long i = 2; i <= Math.Pow(number, 0.5); i++)
{
if (number % i == 0)
{
long otherDivisor = number / i;
if (MathsHelper.IsPrime(i))
{
primes.Add(i);
}
else
{
if (MathsHelper.IsPrime(otherDivisor))
{
return(otherDivisor);
}
}
}
}
primes.Reverse();
return(primes[0]);
}
public static bool IsPalindrome(int pal)
{
int factor = 0;
int maxPower = 7;
bool palindromeSet = false;
int[] palindrome = new int[1];
int j = 0;
for (int i = maxPower; i >= 0; i--)
{
factor = (pal / MathsHelper.Power(10, i));
if (!palindromeSet && factor > 0)
{
palindromeSet = true;
palindrome = new int[i + 1];
}
if (palindromeSet)
{
palindrome[j] = factor;
j++;
}
pal = pal - (factor * MathsHelper.Power(10, i));
}
return(IsPalindrome(palindrome));
}
public void Problem27()
{
Dictionary <long, bool> isPrimeDict = new Dictionary <long, bool>();
long maxConsecutive = 0;
Tuple <long, long> coeffs;
for (long a = -500; a < 500; a++)
{
long aValue = (2 * a) + 1;
for (long b = -500; b < 500; b++)
{
long bValue = (2 * b) + 1;
//bool resultPrime = true;
while (true)
{
long quadValue = this.GetQuadraticValue(aValue, bValue, 0);
if (!isPrimeDict.ContainsKey(quadValue))
{
bool isPrime = MathsHelper.IsPrime(quadValue);
isPrimeDict.Add(quadValue, isPrime);
}
if (isPrimeDict[quadValue])
{
maxConsecutive++;
coeffs = Tuple.Create(aValue, bValue);
}
else
{
break;
}
}
}
}
}
public int Problem9()
{
int s = 1000;
int mlimit = (int)Math.Sqrt(s / 2);
var range = Enumerable.Range(2, mlimit - 2);
Func <int, Tuple <bool, int> > action = m =>
{
if ((s / 2) % m == 0)
{
int k = m % 2 == 0 ? m + 1 : m + 2;
while (k < 2 * m && k <= s / (2 * m))
{
if (s / (2 * m) % k == 0 && MathsHelper.gcd(k, m) == 1)
{
int n = k - m;
int d = s / (2 * m * k);
return(Tuple.Create(true, MathsHelper.Power(d, 3) *
((m * m) - (n * n)) *
(2 * m * n) *
((m * m) + (n * n))));
}
k += 2;
}
}
return(Tuple.Create(false, 0));
};
return(range.Select(action).First(x => x.Item1).Item2);
}
//not mathematical
public int Problem40Alternative()
{
var t = Enumerable.Range(1, 1000000).SelectMany(x => x.ToString()).ToArray();
var indexes = Enumerable.Range(0, 7).Select(x => MathsHelper.Power(10, x));
return(indexes.Select(x => Int32.Parse(t[x - 1].ToString())).Product());
}
public int PowerUp(IEnumerable <int> t)
{
int result = 0;
foreach (int i in t)
{
result += MathsHelper.Power(2, i);
}
return(result);
}
public void Problem23()
{
var range = Enumerable.Range(1, 28123);
var tuples = range.
Select(x => Tuple.Create(x, MathsHelper.GetFactors(x).Distinct().Sum())).
ToList();
var abundents = tuples.Where(x => x.Item2 > x.Item1).Select(x => x.Item1).Where(x => x <= 28123).Skip(1).ToList();
var abundentSums = abundents.SelectMany(x => abundents, (x, y) => x + y).Distinct().Where(x => x <= 28123).OrderBy(x => x).ToList();
int tot = (28123 * 28124 / 2);
int answer = tot - abundentSums.Sum();
}
public int Problem12()
{
int numberOfFactors = 0;
int n = 0;
int triangle = 0;
while (numberOfFactors < 500)
{
n++;
triangle += n;
numberOfFactors = MathsHelper.NumberOfFactors(triangle);
}
return(triangle);
}
public int TheNthPrimeIs(int whichNumerPrime)
{
int i = 1;
int numberToTest = 3;
while (i < whichNumerPrime)
{
if (MathsHelper.IsPrime(numberToTest))
{
i++;
}
numberToTest++;
}
return(numberToTest - 1);
}
public IEnumerable <int> ProductSum(IEnumerable <int> l)
{
for (int i = 0; i < 9; i++)
{
for (int j = i + 1; j < 9; j++)
{
var num1 = MathsHelper.ConvertToDecimal(l.Take(i + 1));
var num2 = MathsHelper.ConvertToDecimal(l.Where((x, ix) => (ix > i) && ix <= j));
var eq = MathsHelper.ConvertToDecimal(l.Skip(j + 1));
if (num1 * num2 == eq)
{
yield return(eq);
}
}
}
}
public void Problem43()
{
var list = this.GetPerms(0, 10).Select(x => new { Orig = x, Split = this.Split(x, 3) });
var hmm = list.
Select(x => new
{
x.Orig,
Split = x.Split.Item2.
Aggregate(x.Split.Item1.ToEnumerable(), (y, i) => y.Concat(y.Last().Skip(1).Concat(i))).Skip(1)
}
);
var ooo = hmm.Select(x => new { x.Orig, Nums = x.Split.Select(MathsHelper.ConvertToDecimal) });
var primes = MathsHelper.GetPrimesUpTo(17).ToList();
var interesting = ooo.Where(x => x.Nums.Zip(primes, (a, b) => a % b).All(y => y == 0)).ToList();
var thingy = interesting.Select(x => x.Orig.Reverse().ToList()).ToList();
var hello = BigNumberHelper.AddListRepresentingNumbers(thingy);
}
private static IEnumerable <int> GetPerimetersOfPrimitivePythagoreanTriplets(int s)
{
//generate coprime m,n with exactly one m,n even
int m = 2;
int n = 1;
int mlimit = (int)Math.Sqrt(s / 2);
while (m <= mlimit)
{
n = m % 2 == 0 ? 1 : 2;
while (n < m)
{
if (MathsHelper.gcd(m, n) == 1)
{
yield return(2 * m * (m + n));
}
n += 2;
}
m++;
}
}
public int Problem37()
{
var truncatable = new Dictionary <int, IEnumerable <IEnumerable <int> > >();
IEnumerable <IEnumerable <int> > choices = new int[][] { new int[] { 1 }, new int[] { 3 }, new int[] { 7 }, new int[] { 9 } };
var tailElements = new HashSet <int>(new int[] { 3, 7 });
//var primes = new HashSet<int>(GetPrimesUpTo(1000000000));
//primes.
Func <IEnumerable <int>, int> getNumber = list => list.Reverse().Select((i, j) => i * MathsHelper.Power(10, j)).Sum();
Func <IEnumerable <int>, IEnumerable <IEnumerable <int> > > getRLSubsets = list => list.Select((i, j) => list.Skip(j));
truncatable.Add(1, new int[][] { new int[] { 2 }, new int[] { 3 }, new int[] { 5 }, new int[] { 7 } });
for (int q = 2; q < 20; q++)
{
truncatable[q] = truncatable[q - 1].SelectMany(p => choices, (r, t) => r.Concat(t));
truncatable[q] = truncatable[q].Where(x => MathsHelper.IsPrime((long)getNumber(x))).ToList();
truncatable[q - 1] = truncatable[q - 1].Where(x => getRLSubsets(x).Select(getNumber).All(y => MathsHelper.IsPrime((long)y)));
if (truncatable[q - 1].Count() == 0)
{
truncatable[q] = new List <IEnumerable <int> >();
break;
}
}
var tyy = truncatable.Where(x => x.Key >= 2).Select(x => x.Value).Select(x => x.Select(getNumber)).SelectMany(x => x).Sum();
IEnumerable <int> test = Enumerable.Range(1, 4);
var hg = test.Select((i, j) => test.Skip(j));
return(0);
}
public int Problem40()
{
int x = 1000000;
int mult = 1;
int start = 9;
int oldStart = start;
while (x > start)
{
int thing = 9 * MathsHelper.Power(10, mult);
mult++;
oldStart = start;
start = start + (thing * mult);
}
int num = x - oldStart - 1;
int f = MathsHelper.Power(10, mult - 1) + (num / mult);
int index = num % mult;
int answer = Int32.Parse(f.ToString()[index].ToString());
return(answer);
}
public int Problem41()
{
var primes = MathsHelper.GetPrimesUpTo(987654321);
return(primes.Last(this.IsPandigital));
}
public int Problem39()
{
return(MathsHelper.GetPythagTriplePerimeterCount(1000).
OrderByDescending(x => x.Item2).
First().Item1);
}
public int Problem75()
{
return(MathsHelper.GetPythagTriplePerimeterCount(1500000).
Count(x => x.Item2 == 1));
}
public int Problem36()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var binomialExpansionDictionary = GetBinomialExpansionLevelDictionary(10);
Func <int, bool> valid = i => i < 1000000 && IsPalindrome(i.ToString());
int rollingTotal = 1;
foreach (var kvp in binomialExpansionDictionary)
{
Func <int, int, IEnumerable <int> > g = ExpandPalindromicIndexEven;
Func <int, int, IEnumerable <int> > h = ExpandPalindromicIndexOdd;
var p = ApplyPartial(g, kvp.Key);
var q = ApplyPartial(h, kvp.Key);
foreach (var r in kvp.Value)
{
IEnumerable <int> th = new int[] { Increase(r, p), Increase(r, q), Increase(r, q) + MathsHelper.Power(2, kvp.Key + 1) };
foreach (var x in th)
{
if (valid(x))
{
rollingTotal += x;
}
}
}
}
sw.Stop();
return(rollingTotal);
}
public int Problem2()
{
return(MathsHelper.GetFibonacciSequenceUpTo(4000000).Where(x => x % 2 == 0).Sum());
}
/// <summary>
/// To get the upper limit we note that a number with n digits cannot have a digit factorial sum greater n * factorial(9).
/// We can propose an upper limit of 10^7 (this is an n-digit number greater than n * factorial(9)).
///
/// We can then show by induction that for all k > 10^7 that k > digitfacorialsum(k)
///
/// Result is true for k = 10^7
///
/// Assume true up to some k > 10^7
///
/// we know digitfactorialsum(k+1) is less than n * factorial(9)
///
/// Therefore k +1 > k > n * factorial(9) > digitfactorialsum(k+1)
/// Therefore k+1 > digitfactorialsum(k+1). QED.
/// </summary>
public void Problem34()
{
var answer = DigitSumEqual(MathsHelper.Power(10, 7), this.Factorial);
}
public long Problem10()
{
Func <long, int, long> func = (l, i) => l + i;
return(MathsHelper.GetPrimesUpTo(2000000).Aggregate(0, func));
}
/// <summary>
/// To get the upper limit see the comments for problem 34.
/// </summary>
public void Problem30()
{
var answer = DigitSumEqual(MathsHelper.Power(10, 6), x => MathsHelper.Power(x, 5));
}
