public static long PandigitalMultiples(long n)
{
long maxpandigital = 1;
for (int i = 1; i < n; i++)
{
long mult = i;
int k = 2;
while (mult < 1000000000)
{
mult = CombinatoricFunctions.concatenatenum(mult, k * i);
if (mult > 100000000 && mult < 1000000000)
{
if (MiscFunctions.IsPandigital((int)mult))
{
if (mult > maxpandigital)
{
maxpandigital = mult;
}
}
}
k++;
}
}
return(maxpandigital);
}
public static int SmallestMultiple(int n)
{
PrimeFunctions.GeneratePrimesTillNToList(n);
List <int> FactorList = new List <int>();
//Loop until highest multiple
for (int i = 2; i <= n; i++)
{
//Find all the factors of the number
List <int> factors = PrimeFunctions.PrimeFactor(i, false);
//If the list of factors doesn't contain the factor or as many factors, then add it to the list
foreach (int factor in factors)
{
if (MiscFunctions.ReturnDistinctCountList(factors, factor) > MiscFunctions.ReturnDistinctCountList(FactorList, factor))
{
FactorList.Add(factor);
}
}
}
//Loop through the minimum required factors and multiply them all
int mult = 1;
foreach (int factor in FactorList)
{
mult *= factor;
}
return(mult);
}
public static List <List <int> > GenerateTriangles(int n)
{
List <int> squares = new List <int>();
List <List <int> > triangles = new List <List <int> >();
for (int i = 1; i <= n; i++)
{
squares.Add(i * i);
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (squares.Contains(squares[i] - squares[j]))
{
List <int> triple = new List <int>();
triple.Add((int)Math.Sqrt(squares[i]));
triple.Add((int)Math.Sqrt(squares[j]));
triple.Add((int)Math.Sqrt(squares[i] - squares[j]));
triple.Sort();
triangles.Add(triple);
}
}
}
var finalList = MiscFunctions.removedupes(triangles);
return(finalList);
}
public static int DigitCancellingFractions(int n)
{
int numerator = 1;
int denominator = 1;
for (int i = 10; i < 99; i++)
{
for (int j = i + 1; j < 99; j++)
{
if (i % 10 == 0 && j % 10 == 0)
{
break;
}
double frac = (double)i / (double)j;
double frac2 = MiscFunctions.CancelOutSameDigit(i, j);
if (Math.Abs(frac - frac2) < 0.001)
{
Console.WriteLine("{0} {1}", i, j);
numerator *= i;
denominator *= j;
}
}
}
int[] fracarr = new int[2] {
numerator, denominator
};
MiscFunctions.Simplify(fracarr);
return(fracarr[1]);
}
public static long SumSquareDifference(int n)
{
long sum = MiscFunctions.AddFrom1toN(n);
long squaresum = sum * sum;
long sumsquare = 0;
for (int i = 1; i <= n; i++)
{
sumsquare += (i * i);
}
return(squaresum - sumsquare);
}
public static bool Amicability(int n)
{
int a = MiscFunctions.ProperDivisors(n).Sum();
if (a != n)
{
return(MiscFunctions.ProperDivisors(a).Sum() == n);
}
else
{
return(false);
}
}
public static int HighlyDivisibleTriangularNumber(int n)
{
List <long> triangles = SpecialSequences.triangularnumbers(n * n);
foreach (int triangle in triangles)
{
if (MiscFunctions.Divisors(triangle).Count() > n)
{
return(triangle);
}
}
return(0);
}
public static bool IsPandigital(int n)
{
if (n > 1000000000)
{
return(false);
}
int[] nums = MiscFunctions.DigitsFromInt(n);
int[] dig = new int[nums.Length];
for (int i = 0; i < dig.Length; i++)
{
dig[i] = i + 1;
}
return(nums.OrderBy(x => x).ToArray().SequenceEqual(dig));
}
public static List <int> rotations(int n)
{
List <int> rots = new List <int>();
List <int> startingint = MiscFunctions.DigitsFromInt(n).ToList();
rots.Add(n);
for (int i = 1; i < startingint.Count; i++)
{
startingint.Add(startingint[0]);
startingint.RemoveAt(0);
rots.Add(MiscFunctions.ListToInt(startingint));
}
return(rots);
}
public static int PandigitalPrime(int n)
{
List <int> PanPrimes = new List <int>();
PrimeFunctions.GeneratePrimesTillNToList(n);
for (int i = 0; i < PrimeFunctions.PrimeList.Count; i++)
{
if (MiscFunctions.IsPandigital(PrimeFunctions.PrimeList[i]))
{
PanPrimes.Add(PrimeFunctions.PrimeList[i]);
}
}
return(PanPrimes.Max());
}
public static string LexicographicPermutations(int n, int k)
{
List <int> nums = new List <int>();
for (int i = 0; i <= n; i++)
{
nums.Add(i);
}
//IEnumerable<IEnumerable<int>> numper = CombinatoricFunctions.GetPermutations(nums, n+1);
IEnumerable <IEnumerable <int> > numper = SomeExtensions.GetPermutations(nums);
List <List <int> > list = numper.Select(c => c.ToList()).ToList();
return(MiscFunctions.ListToString(list[k - 1]));
}
public static int DigitFifthPowers(int n)
{
List <int> digits = new List <int>();
int limit = (int)Math.Pow(10, n) * 100;
for (int i = 2; i < limit; i++)
{
int[] arr = MiscFunctions.DigitsFromInt(i);
if (PowerSum(arr, n) == i)
{
digits.Add(i);
}
}
return(digits.Sum());
}
public static long SubstringDivisibility()
{
long sum = 0;
var perm = SomeExtensions.GetPermutations(nums);
List <List <int> > list = FileFunctions.ienumtolist(perm);
foreach (List <int> num in list)
{
if (SubStringTest(num))
{
sum += MiscFunctions.ListToLong(num);
}
}
return(sum);
}
public static int OddComposite()
{
int comp = 0;
List <int> primes = PrimeFunctions.GeneratePrimes(10000);
HashSet <int> primeshash = MiscFunctions.ListToHash(primes);
List <int> squares = SpecialSequences.squares(1000);
HashSet <int> squareshash = MiscFunctions.ListToHash(squares);
int i = 3;
bool found = false;
while (comp == 0)
{
found = false;
i += 2;
if (primeshash.Contains(i))
{
continue;
}
for (int j = 0; j < primes.Count; j++)
{
if (primes[j] > i)
{
break;
}
for (int k = 0; k < squares.Count; k++)
{
if (squares[k] * 2 > i)
{
break;
}
if (primes[j] + (squares[k] * 2) == i)
{
found = true;
}
}
}
if (!found)
{
comp = i;
}
}
return(comp);
}
public static double CancelOutSameDigit(int a, int b)
{
List <int> digitsa = MiscFunctions.DigitsFromInt(a).ToList();
List <int> digitsb = MiscFunctions.DigitsFromInt(b).ToList();
List <int> intersect = digitsa.Intersect(digitsb).ToList();
if (intersect.Count == 1)
{
digitsa.Remove(intersect[0]);
digitsb.Remove(intersect[0]);
if (digitsb[0] != 0)
{
return((double)digitsa[0] / (double)digitsb[0]);
}
}
return(0);
}
public static int CodedTriangleNumbers(string n)
{
int count = 0;
string str = FileFunctions.readfileintostring("Problem42");
str = str.Replace("/", "");
str = str.Replace("\"", "");
string[] arr = str.Split(',');
List <long> triangles = SpecialSequences.triangularnumbers(1000);
foreach (string word in arr)
{
if (triangles.Contains(MiscFunctions.UppercaseWordValue(word)))
{
count++;
}
}
return(count);
}
public static int DigitFactorials(int n)
{
int sum = 0;
CombinatoricFunctions.generatefactorial(10);
for (int i = 3; i < n; i++)
{
int[] digits = MiscFunctions.DigitsFromInt(i);
BigInteger tempsum = 0;
foreach (int digit in digits)
{
tempsum += CombinatoricFunctions.factorial(digit);
}
if (tempsum == i)
{
sum += i;
}
}
return(sum);
}
public static int PandigitalProducts()
{
HashSet <int> products = new HashSet <int>();
for (int i = 1; i < 5000; i++)
{
for (int j = 1; j < 5000; j++)
{
List <int> tempdigits = new List <int>();
tempdigits.AddRange(MiscFunctions.DigitsFromInt(i));
tempdigits.AddRange(MiscFunctions.DigitsFromInt(j));
tempdigits.AddRange(MiscFunctions.DigitsFromInt(i * j));
if (MiscFunctions.IsPandigital(tempdigits))
{
products.Add(i * j);
}
}
}
return(products.Sum());
}
public static int DistinctPrimeFactors()
{
PrimeFunctions.GeneratePrimesToList(100000);
int i = 2;
int count = 0;
while (count < 4)
{
i++;
List <int> primes = PrimeFunctions.PrimeFactor(i);
HashSet <int> factors = MiscFunctions.ListToHash(primes);
if (factors.Count == 4)
{
count++;
}
else
{
count = 0;
}
}
return(i - 3);
}
public static bool Abundant(int n)
{
return(MiscFunctions.ProperDivisors(n).Sum() > n);
}
public static int FactorialDigitSum(int n)
{
return(MiscFunctions.SumOfDigits(CombinatoricFunctions.factorial(n)));
}
