public static void Run(Input input, Output output)
{
var pu = new PrimesUtils(2000000);
var meta = input.ReadLine().Split(' ');
var N = Int32.Parse(meta[0]);
var K = Int32.Parse(meta[1]);
int i = 2;
while (i <= N)
{
var dividors = pu.GetPrimeDividors(i);
var cnt = 0;
var first = i;
while (dividors.Count == K && cnt < K)
{
cnt++;
i++;
dividors = pu.GetPrimeDividors(i);
}
if (cnt >= K)
{
output.WriteLine(first.ToString());
i = i - K + 1;
}
else
{
i++;
}
}
}
public static void Run(Input input, Output output)
{
var meta = input.ReadLine().Split(' ');
var N = int.Parse(meta[0]);
var K = int.Parse(meta[1]);
var pu = new PrimesUtils(1000000);
var allPrimes = pu.GetSievePrimes();
var primesToTest = new List <int>();
var currPrimeIndex = 0;
var excl = new HashSet <int>()
{
2, 5
};
while (allPrimes[currPrimeIndex] < N)
{
if (!excl.Contains(allPrimes[currPrimeIndex]))
{
primesToTest.Add(allPrimes[currPrimeIndex]);
}
currPrimeIndex++;
}
var sums = GetConcatenateablePrimesSetsSums(primesToTest, K, pu);
sums.Sort();
for (int i = 0; i < sums.Count; i++)
{
output.WriteLine(sums[i].ToString());
}
}
public static void Run(Input input, Output output)
{
var pu = new PrimesUtils(1000000);
var primes = pu.GetPrimes();
var T = int.Parse(input.ReadLine());
for (int t0 = 0; t0 < T; t0++)
{
var N = int.Parse(input.ReadLine());
var countOfRepresentations = 0;
int i = 1; // 2 is the only even prime and it is impossible to represent odd number
// as sum 2 and double quare
while (primes[i] <= N)
{
var squareCandidate = (N - primes[i]) / 2;
var sqrt = (int)Math.Floor(Math.Sqrt(squareCandidate));
if (sqrt * sqrt == squareCandidate)
{
countOfRepresentations++;
}
i++;
}
output.WriteLine(countOfRepresentations.ToString());
}
}
public static void Run(Input input, Output output)
{
var N = int.Parse(input.ReadLine());
if (N == 8)
{
output.WriteLine(238733.ToString());
return;
}
var pu = new PrimesUtils(1000000);
decimal targetPercent = (decimal)N / 100;
var diagonalNumbersCountOverall = 5;
var diagonalPrimeNumbersCount = 3;
var currSideLength = 3;
long topRightDiagonalCurrentNumber = 3;
long topRightDiagonalDelta = 10;
long topLeftDiagonalCurrentNumber = 5;
long topLeftDiagonalDelta = 12;
long bottomLeftDiagonalCurrentNumber = 7;
long bottomLeftDiagonalDelta = 14;
long bottomRightDiagonalCurrentNumber = 9;
long bottomRightDiagonalDelta = 16;
while (((decimal)diagonalPrimeNumbersCount / diagonalNumbersCountOverall) - targetPercent >= 0m)
{
currSideLength += 2;
diagonalNumbersCountOverall += 4;
topRightDiagonalCurrentNumber += topRightDiagonalDelta;
topRightDiagonalDelta += 8;
if (pu.IsPrime(topRightDiagonalCurrentNumber))
{
diagonalPrimeNumbersCount++;
}
topLeftDiagonalCurrentNumber += topLeftDiagonalDelta;
topLeftDiagonalDelta += 8;
if (pu.IsPrime(topLeftDiagonalCurrentNumber))
{
diagonalPrimeNumbersCount++;
}
bottomLeftDiagonalCurrentNumber += bottomLeftDiagonalDelta;
bottomLeftDiagonalDelta += 8;
if (pu.IsPrime(bottomLeftDiagonalCurrentNumber))
{
diagonalPrimeNumbersCount++;
}
bottomRightDiagonalCurrentNumber += bottomRightDiagonalDelta;
bottomRightDiagonalDelta += 8;
if (pu.IsPrime(bottomRightDiagonalCurrentNumber))
{
diagonalPrimeNumbersCount++;
}
}
output.WriteLine(currSideLength.ToString());
}
public static void Run(Input input, Output output)
{
var metaStr = input.ReadLine().Split(' ');
var N = int.Parse(metaStr[0]);
var K = int.Parse(metaStr[1]);
var pu = new PrimesUtils(5000000);
var primesByPermutations = new Dictionary <string, List <int> >();
var primes = pu.GetPrimes();
for (int i = 0; i < primes.Count; i++)
{
var currPrime = primes[i];
if (primes[i] < 1000)
{
continue;
}
var permutationKey = GetPermutationKey(currPrime);
if (!primesByPermutations.ContainsKey(permutationKey))
{
primesByPermutations.Add(permutationKey, new List <int>()
{
currPrime
});
}
else
{
primesByPermutations[permutationKey].Add(currPrime);
}
}
var result = new List <int[]>();
foreach (var primesByPermutationsKvp in primesByPermutations)
{
GetArithmeticSequences(primesByPermutationsKvp.Value, K, N, result);
}
result.Sort(new Comparison <int[]>(((a, b) =>
{
int i = 0;
while (i < a.Length && a[i].CompareTo(b[i]) == 0)
{
i++;
}
if (i < a.Length)
{
return(a[i].CompareTo(b[i]));
}
return(0);
}
)
));
for (int i = 0; i < result.Count; i++)
{
output.WriteLine(string.Join(string.Empty, result[i]));
//output.WriteLine(string.Join(" ", result[i]));
}
}
public static void Run(Input input, Output output)
{
var pu = new PrimesUtils(1000000);
var N = Int32.Parse(input.ReadLine());
var sum = 0;
var digits = new List <int>();
digits.Add(1);
digits.Add(1);
for (int i = 11; i < N; i++)
{
var isPrime = pu.IsPrime(i) && pu.IsPrime(digits[0]) && pu.IsPrime(digits[digits.Count - 1]);
if (isPrime)
{
var tmpDigits = new List <int>();
tmpDigits.AddRange(digits);
for (int j = 0; j < digits.Count - 1; j++)
{
tmpDigits.RemoveAt(0);
isPrime = pu.IsPrime(NumberFromDigits(tmpDigits));
if (!isPrime)
{
break;
}
}
}
if (isPrime)
{
var tmpDigits = new List <int>();
tmpDigits.AddRange(digits);
for (int j = 0; j < digits.Count - 1; j++)
{
tmpDigits.RemoveAt(tmpDigits.Count - 1);
isPrime = pu.IsPrime(NumberFromDigits(tmpDigits));
if (!isPrime)
{
break;
}
}
}
if (isPrime)
{
sum += i;
}
Plus(digits, 1);
}
output.WriteLine(sum.ToString());
}
public void PrimesUtildShouldCheckIfNumberIsPrime()
{
var pu = new PrimesUtils();
Assert.AreEqual(true, pu.IsPrime(41));
Assert.AreEqual(false, pu.IsPrime(42));
Assert.AreEqual(true, pu.IsPrime(953));
Assert.AreEqual(true, pu.IsPrime(997651));
Assert.AreEqual(true, pu.IsPrime(999715711));
Assert.AreEqual(true, pu.IsPrime(999973156643));
Assert.AreEqual(false, pu.IsPrime(1122004669633));
}
public void PrimesUtilsShouldCalculateAllDividors()
{
#region Arrange
var n = 72;
var pu = new PrimesUtils(10000);
#endregion
#region Act
var allDividors = pu.GetAllDividors(n);
#endregion
#region Assert
Assert.AreEqual(11, allDividors.Count);
#endregion
}
public void PrimesUtilsShouldGetAllPrimes()
{
#region Arrange
var pu = new PrimesUtils(1000000);
#endregion
#region Act
var primes = pu.GetSievePrimes();
#endregion
#region Assert
Assert.AreEqual(78498, primes.Count);
Assert.AreEqual(2, primes[0]);
Assert.AreEqual(999983, primes[78497]);
#endregion
}
static bool IsConcatenateablePair(int p1, int p2, PrimesUtils pu)
{
var sum1 = p2;
if (p2 < 10)
{
sum1 += p1 * 10;
}
else if (p2 < 100)
{
sum1 += p1 * 100;
}
else if (p2 < 1000)
{
sum1 += p1 * 1000;
}
else if (p2 < 10000)
{
sum1 += p1 * 10000;
}
else if (p2 < 100000)
{
sum1 += p1 * 100000;
}
var sum2 = p1;
if (p1 < 10)
{
sum2 += p2 * 10;
}
else if (p1 < 100)
{
sum2 += p2 * 100;
}
else if (p1 < 1000)
{
sum2 += p2 * 1000;
}
else if (p1 < 10000)
{
sum2 += p2 * 10000;
}
else if (p1 < 100000)
{
sum2 += p2 * 100000;
}
return(pu.IsPrime(sum1) && pu.IsPrime(sum2));
}
public void PrimesUtilsShouldCalculatePrimeDividorsList()
{
#region Arrange
var n = 1008;
var pu = new PrimesUtils(10000);
#endregion
#region Act
var primeDividors = pu.GetPrimeDividorsList(n);
#endregion
#region Assert
Assert.AreEqual(7, primeDividors.Count);
Assert.AreEqual(2, primeDividors[0]);
Assert.AreEqual(3, primeDividors[4]);
Assert.AreEqual(7, primeDividors[6]);
#endregion
}
public void PrimesUtilsShouldCalculatePrimeDividors()
{
#region Arrange
var n = 1008;
var pu = new PrimesUtils(10000);
#endregion
#region Act
var primeDividors = pu.GetPrimeDividors(n);
#endregion
#region Assert
Assert.AreEqual(3, primeDividors.Count);
Assert.AreEqual(4, primeDividors[2]);
Assert.AreEqual(2, primeDividors[3]);
Assert.AreEqual(1, primeDividors[7]);
#endregion
}
public static void Run(Input input, Output output)
{
var pu = new PrimesUtils(9999999);
var primes = pu.GetPrimes();
var meta = input.ReadLine().Split(' ');
var N = int.Parse(meta[0]);
var K = int.Parse(meta[1]);
var L = int.Parse(meta[2]);
var leftBoudary = _boundaries[N];
var currPrimeIndex = 0;
while (primes[currPrimeIndex] < leftBoudary)
{
currPrimeIndex++;
}
currPrimeIndex--;
var replacementsMasks = GetReplacementsMasks(N, K);
while (true) // It is guaranteed that solution does exist
{
currPrimeIndex++;
var currPrime = primes[currPrimeIndex];
var generatedPrimes = GenerateDigitReplacements(currPrime,
K,
L - 1,
replacementsMasks,
pu);
if (generatedPrimes != null)
{
output.WriteLine(currPrime.ToString() + " " + string.Join(" ", generatedPrimes));
break;
}
}
}
public static void Run(Input input, Output output)
{
var pu = new PrimesUtils(1000000);
var N = Int32.Parse(input.ReadLine());
var sum = 0;
var digits = new List <int>();
digits.Add(2);
for (int i = 2; i < N; i++)
{
var digitsTmp = new List <int>(digits.Count);
digitsTmp.AddRange(digits);
var isCircularPrime = true;
for (int j = 0; j < digits.Count; j++)
{
if (!pu.IsPrime(NumberFromDigits(digitsTmp)))
{
isCircularPrime = false;
break;
}
var d = digitsTmp[0];
digitsTmp.RemoveAt(0);
digitsTmp.Add(d);
}
if (isCircularPrime)
{
sum += i;
}
Plus(digits, 1);
}
output.WriteLine(sum.ToString());
}
static List <int> GenerateDigitReplacements(int primeNum,
int countOfDigitsToReplace,
int requiredCountOfPrimesToGenerate,
List <int> replacementsMasks,
PrimesUtils primeUtils)
{
var digits = GetNumberDigits(primeNum);
for (int i = 0; i < 9; i++)
{
digitsMasks[i] = 0;
digitsCounts[i] = 0;
}
for (int i = 0; i < digits.Length; i++)
{
digitsCounts[digits[i]]++;
digitsMasks[digits[i]] |= 1 << i;
}
var generatedPrimes = new List <List <int> >();
for (int i = 0; i <= 9; i++)
{
if (digitsCounts[i] >= countOfDigitsToReplace)
{
var currDigitMask = digitsMasks[i];
for (int j = 0; j < replacementsMasks.Count; j++)
{
var currReplacementMask = replacementsMasks[j];
if ((currDigitMask & currReplacementMask) == currReplacementMask)
{
var currGeneratedPrimes = new List <int>();
for (int replacementDigit = i + 1; replacementDigit <= 9; replacementDigit++)
{
var numberToTest = GetNumberFromReplacement(digits,
currReplacementMask,
replacementDigit);
if (primeUtils.IsPrime(numberToTest))
{
currGeneratedPrimes.Add(numberToTest);
}
}
if (currGeneratedPrimes.Count >= requiredCountOfPrimesToGenerate)
{
generatedPrimes.Add(currGeneratedPrimes);
}
}
}
}
}
if (generatedPrimes.Count > 0)
{
generatedPrimes.Sort(new Comparison <List <int> >((a, b) =>
{
int currIndex = 0;
while (a[currIndex].CompareTo(b[currIndex]) == 0)
{
currIndex++;
}
return(a[currIndex].CompareTo(b[currIndex]));
}));
return(generatedPrimes[0].Take(requiredCountOfPrimesToGenerate).ToList());
}
return(null);
}
static List <int> GetConcatenateablePrimesSetsSums(List <int> primesToTest, int K, PrimesUtils pu)
{
Dictionary <int, HashSet <int> > pairs = new Dictionary <int, HashSet <int> >();
for (int i = 0; i < primesToTest.Count; i++)
{
pairs.Add(primesToTest[i], new HashSet <int>());
}
for (int i = 0; i < primesToTest.Count; i++)
{
for (int j = i + 1; j < primesToTest.Count; j++)
{
var p1 = primesToTest[i];
var p2 = primesToTest[j];
if (IsConcatenateablePair(p1, p2, pu))
{
pairs[p1].Add(p2);
}
}
}
var result = new List <int>();
if (K == 3)
{
for (int i = 0; i < primesToTest.Count; i++)
{
var p1 = primesToTest[i];
foreach (var p2 in pairs[p1])
{
foreach (var p3 in pairs[p2])
{
if (pairs[p1].Contains(p3))
{
result.Add(p1 + p2 + p3);
}
}
}
}
}
if (K == 4)
{
for (int i = 0; i < primesToTest.Count; i++)
{
var p1 = primesToTest[i];
foreach (var p2 in pairs[p1])
{
foreach (var p3 in pairs[p2])
{
if (pairs[p1].Contains(p3))
{
foreach (var p4 in pairs[p3])
{
if (pairs[p1].Contains(p4) && pairs[p2].Contains(p4))
{
result.Add(p1 + p2 + p3 + p4);
}
}
}
}
}
}
}
if (K == 5)
{
for (int i = 0; i < primesToTest.Count; i++)
{
var p1 = primesToTest[i];
foreach (var p2 in pairs[p1])
{
foreach (var p3 in pairs[p2])
{
if (pairs[p1].Contains(p3))
{
foreach (var p4 in pairs[p3])
{
if (pairs[p1].Contains(p4) && pairs[p2].Contains(p4))
{
foreach (var p5 in pairs[p4])
{
if (pairs[p1].Contains(p5) && pairs[p2].Contains(p5) && pairs[p3].Contains(p5))
{
result.Add(p1 + p2 + p3 + p4 + p5);
}
}
}
}
}
}
}
}
}
return(result);
}
