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));
}
//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 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);
}
public int PowerUp(IEnumerable <int> t)
{
int result = 0;
foreach (int i in t)
{
result += MathsHelper.Power(2, i);
}
return(result);
}
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);
}
/// <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));
}
/// <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 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 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);
}