static BigInt Calculate(int n)
{
var calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes(n / 2);
var sqr = Math.Sqrt(n);
int numLessSqr = 0;
while (primes[numLessSqr] < sqr)
numLessSqr++;
BigInt sum = numLessSqr * (numLessSqr+1) / 2;
for (int i = 0; i < numLessSqr; i++)
{
Console.WriteLine(i);
int tmp = 0;
for (int j = numLessSqr; j < primes.Count; j++)
{
if (primes[i] * primes[j] < n)
tmp++;
else
break;
}
sum += tmp;
}
return sum;
}
static void Main(string[] args)
{
PrimeCalculator calc = new PrimeCalculator();
calc.GetAllPrimes(10000);
for (int n = 1000; n < 10000; n++)
{
int d1 = n % 10;
int d2 = (n / 10) % 10;
int d3 = (n / 100) % 10;
int d4 = n / 1000;
var permutations = Permutator.Permutate(new int[] {d1, d2, d3, d4}.ToList());
var numbers = new List<int>();
foreach (var perm in permutations)
{
var num = perm[0] + perm[1] * 10 + perm[2] * 100 + perm[3] * 1000;
if (calc.IsPrime((ulong)num) && !numbers.Contains(num) && num>999 && num>=n)
numbers.Add(num);
}
numbers.Sort();
for (int i = 1; i < numbers.Count-1; i++)
{
for (int j = i+1; j < numbers.Count; j++)
{
if (numbers[j]-numbers[i]==numbers[i]-numbers[0])
Console.Write("{0}{1}{2}\n", numbers[0], numbers[i], numbers[j]);
}
}
}
}
static int Calculate(int n)
{
PrimeCalculator calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes((int)Math.Sqrt(n));
bool[] numbers = new bool[n+1];
for (int i = 0; i < primes.Count; i++)
{
var pi = primes[i];
var i4 = pi * pi * pi* pi;
if (i4 > n)
break;
for (int j = 0; j < primes.Count; j++)
{
var pj = primes[j];
var j3 = pj * pj * pj;
if (i4+j3 > n)
break;
for (int k = 0; k < primes.Count; k++)
{
var pk = primes[k];
var k2 = pk*pk;
if (i4+j3+k2 > n)
break;
numbers[i4 + j3 + k2] = true;
}
}
}
return numbers.Count(x => x);
}
public BigInt GetSumPrimes(int min, int max)
{
PrimeCalculator calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes(max);
BigInt sum = 0;
foreach (var prime in primes)
{
BigInt p = prime;
for (;;)
{
var l = checked ((max / p - (min - 1) / p) * prime);
if (l > 0)
sum += l;
else
{
break;
}
p *= prime;
}
}
return sum;
}
static void Main(string[] args)
{
int maxCheck = 1000;
SortedList<int, int>[] variants = new SortedList<int, int>[maxCheck];
PrimeCalculator calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes(maxCheck*2);
variants[0] = variants[1] = new SortedList<int, int>();
for (int i = 2; i < maxCheck; i++)
{
variants[i] = new SortedList<int, int>();
int primeIndex = 0;
int prime = 0;
for(;;)
{
prime = primes[primeIndex++];
if (prime > i)
break;
if (prime == i)
variants[i].Add(prime*prime*prime*prime*prime*prime, prime*prime*prime*prime*prime*prime);
else
{
foreach (var variant in variants[i-prime])
{
var value = variant.Key + prime * prime * prime *prime*prime*prime;
if (!variants[i].ContainsKey(value))
variants[i].Add(value, value);
}
}
if (variants[i].Count >= 5000)
{
for (int j=0; j<=i; j++)
Console.WriteLine(variants[j].Count);
Console.WriteLine(i);
return;
}
}
}
//Console.WriteLine(variants[10].Count);
}
public int Calculate(int n, int k)
{
PrimeCalculator calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes(n);
var primeCounts = new Dictionary<int, int>();
for (int i=n-k+1; i<=n; i++)
{
if (i%10000==0)
Console.WriteLine(i);
var factors = calculator.Factor(i);
foreach (int factor in factors)
{
if (primeCounts.ContainsKey(factor))
primeCounts[factor] = primeCounts[factor] + 1;
else
{
primeCounts.Add(factor, 1);
}
}
}
for (int i = 2; i <= k; i++)
{
var factors = calculator.Factor(i);
foreach (int factor in factors)
{
primeCounts[factor] = primeCounts[factor] - 1;
}
}
int sum = 0;
foreach (var primeCount in primeCounts)
{
sum += primeCount.Key * primeCount.Value;
}
return sum;
}
static BigInt Calculate(int n)
{
SortedList<int, int> foundPrimes = new SortedList<int, int>();
SortedList<int, int> beingProcessed = new SortedList<int, int>();
SortedList<int, int> processQueue = new SortedList<int, int>();
PrimeCalculator calculator = new PrimeCalculator();
var primes = calculator.GetAllPrimes(n);
processQueue.Add(2,2);
while (processQueue.Count > 0)
{
var number = processQueue.Keys[0];
var maxNumber = processQueue.Values[0];
processQueue.RemoveAt(0);
foreach (var neighbour in GetNeighbours(number))
{
if (neighbour > n)
continue;
if (neighbour == n)
continue;
if (foundPrimes.ContainsKey(neighbour))
continue;
if (primes.BinarySearch(neighbour) < 0)
continue;
if (processQueue.ContainsKey(neighbour))
{
if (processQueue[neighbour] < neighbour)
continue;
}
else
processQueue.Remove(neighbour);
if (neighbour > maxNumber)
{
foundPrimes.Add(neighbour, neighbour);
processQueue.Add(neighbour, Math.Max(maxNumber, neighbour));
}
else
{
int currentMax = int.MaxValue;
if (beingProcessed.ContainsKey(neighbour))
{
currentMax = beingProcessed[neighbour];
}
if (maxNumber < currentMax)
{
processQueue.Add(neighbour, Math.Max(maxNumber, neighbour));
beingProcessed[neighbour] = maxNumber;
}
}
}
}
BigInt result = 0;
foreach (var prime in primes)
{
result += prime;
}
foreach (var foundPrime in foundPrimes)
{
result -= foundPrime.Key;
}
return result-2;
}
