public long Solve()
{
var primes = new Utils.Prime(1000000L).PrimeList;
var posiblePrimes = new List<long>();
foreach (var prime in primes)
{
if (prime < 10)
{
posiblePrimes.Add(prime);
continue;
}
if (this.IsAllOdd(prime))
{
posiblePrimes.Add(prime);
}
}
var count = 0;
foreach (var posiblePrime in posiblePrimes)
{
var listOfPermutation = GetAllPermutation(posiblePrime);
if (listOfPermutation.All(posiblePrimes.Contains))
{
Console.WriteLine(posiblePrime);
count++;
}
}
return count;
}
public long Solve()
{
var primesFactorisation = new Dictionary<long, long>();
var primes = new Utils.Prime((long)Math.Sqrt(10) + 1).PrimeList;
foreach (var prime in primes)
{
primesFactorisation.Add(prime, 0);
}
for (var n = UpperNumber - DownNumber; n <= UpperNumber; n++)
{
var number = n;
foreach (var prime in primes)
{
if (number == 1)
break;
while (number % prime == 0)
{
number = number / prime;
primesFactorisation[prime]++;
}
}
}
return primesFactorisation.Sum(t => t.Key * t.Value);
}
public long Solve()
{
var max = 0L;
var product = 0L;
var primes = new Utils.Prime(1000L).PrimeList;
var maxPrime = new Utils.Prime(1000000L).PrimeList;
var posibleA = primes.Union(primes.Select(t => t * (-1)).ToList()).ToList();
Console.WriteLine(primes.Count);
Console.WriteLine(posibleA.Count);
foreach (var a in posibleA)
{
for (var b = -999; b < 1000; b = b + 2)
{
Func<long, long> func = n => (n * n) + (b * n) + a;
var currentMax = this.LongRow(func, maxPrime);
if (currentMax > max)
{
Console.WriteLine("{0} {1} {2}", max, a, b);
max = currentMax;
product = a * b;
}
}
}
return product;
}
public long Solve()
{
var primes = new Utils.Prime(PrimeLimit).PrimeList;
var solutions = new HashSet<long>();
this.AddHammingNumber(1, primes, solutions);
return solutions.Count;
}
public void GetDecomposition()
{
var primes = new Utils.Prime(1000L);
for (int n = 1; n <= 1000; n++)
{
var resultComputeed = primes.GetDecomposition(n);
var number = resultComputeed.Aggregate(1L, (result, t) => result * (long)Math.Pow(t.Key, t.Value));
Assert.AreEqual(number, n);
}
}
public long Solve()
{
var primes = new Utils.Prime(51L);
var squereFree = new HashSet<long>();
for (var row = 1; row <= 50; row++)
{
for (var number = 1; number <= row; number++)
{
squereFree.Add(this.GetSquereFreeBinomilaNumber(number, row, primes));
}
}
return squereFree.Sum();
}
public long Solve()
{
var number = 600851475143;
var primes = new Utils.Prime(10000L).PrimeList; // 10000 test
foreach (var prime in primes.OrderByDescending(t => t))
{
if (number % prime == 0)
return prime;
}
return number;
}
public long Solve()
{
var primes = new Utils.Prime((long)Math.Ceiling(Math.Sqrt(Limit))).PrimeList;
var sum = 2L;
for (int i = 3; i <= Limit; i = i + 2)
{
if (this.IsPrime(i, primes))
{
sum += i;
}
}
return sum;
}
public long Solve()
{
var sum = 0L;
var primes = new Utils.Prime((long)Math.Sqrt(Limit) * 10);
var truncatableHarshadNumbers = new List<long> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var nextTruncatableHarshadNumbers = new List<long>();
var strongTruncatableHarshadNumbers = new List<long>();
var digits = new List<int> { 1, 3, 7, 9 };
for (var i = 1; i <= Math.Log10(Limit); i++)
{
foreach (var number in truncatableHarshadNumbers)
{
for (var digit = 0; digit <= 9; digit++)
{
var newNumber = (number * 10) + digit;
if (this.IsHarshad(newNumber))
{
nextTruncatableHarshadNumbers.Add(newNumber);
if (this.IsStrongHarshad(newNumber, primes))
{
strongTruncatableHarshadNumbers.Add(newNumber);
}
}
}
}
truncatableHarshadNumbers = nextTruncatableHarshadNumbers.ToList();
nextTruncatableHarshadNumbers.Clear();
foreach (var number in strongTruncatableHarshadNumbers)
{
foreach (var digit in digits)
{
var newNumber = (number * 10) + digit;
if ((newNumber < Limit) && (primes.IsPrimeCompute(newNumber)))
{
Console.WriteLine(newNumber);
sum += newNumber;
}
}
}
strongTruncatableHarshadNumbers.Clear();
}
return sum;
}
public long Solve()
{
var primeUtils = new Utils.Prime(Limit + 1);
long sum = 0;
foreach (var prime in primeUtils.PrimeList)
{
if (prime > Limit)
continue;
if (this.IsPrimeGenerating(prime - 1, primeUtils))
sum += prime - 1;
}
return sum;
}
public long Solve()
{
Console.WriteLine("Start");
var primes = new Utils.Prime(Limit);
Console.WriteLine("Prime Konec");
var output = 1L;
foreach (var prime in primes.PrimeList.Where(t => t <= Limit))
{
var sumPower = GetPrimeMultipleFactorials(prime);
output = (output * PowerMultiply(prime, sumPower)) % Modulo;
}
return output;
}
public long Solve()
{
var primeList = new Utils.Prime(1000L).PrimeList;
for (var number = 10; number <= 100; number++)
{
var sum = 0;
for (var lenght = 2; lenght <= (number + 1) / 2; lenght++)
{
for (var minNumber = 0; primeList[minNumber] * lenght <= number; minNumber++)
{
sum += this.GetSumOfPosibilities(minNumber, lenght - 1, number - (int)primeList[minNumber], primeList);
}
}
if (sum >= 5000)
{
return number;
}
}
return 0;
}
public void MaxPrime()
{
var primes = new Utils.Prime(104395300L);
Assert.AreEqual(104395301, primes.PrimeList.Max());
}
public long Solve()
{
var primes = new Utils.Prime(10001);
return primes.PrimeList.Max(t => t);
}
