protected override string Solve() { int result = 0; IEnumerable <long> primes = PrimeHelper.GeneratePrimes(999999); foreach (long prime in primes) { IEnumerable <long> rotations = NumberHelper.GetRotations(prime); int primeCount = 0; foreach (long rotation in rotations) { if (PrimeHelper.IsPrime(rotation)) { primeCount++; } } if (primeCount == rotations.Count()) { result++; } } return(result.ToString("0")); }
public void Primes() { var expected = 15485863; var actual = PrimeHelper.Primes().Skip(1000000 - 1).First(); Assert.Equal(expected, actual); }
//Problem 7: 10001st prime //By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. //What is the 10 001st prime number? //Answer: 104743 //First Time: 18 seconds //Second Time: 0.003 seconds public string GetAnswer() { var primes = PrimeHelper.FindPrimes_ToCount(10001); var answer = primes.Last(); return("Problem 7: " + answer.ToString()); }
//Problem 10: Summation of primes //The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. //Find the sum of all the primes below two million. //Problem 10 Answer: 142913828922 //First Elapsed Time (seconds): 4 hours something - forgot to sieve //Second Elapsed Time (seconds): 0.0190295 public string GetAnswer() { var primes = PrimeHelper.FindPrimes_ToLimit(2000000); var sum = primes.Sum(); return("Problem 10: " + sum.ToString()); }
void Resize() { int newSize = PrimeHelper.ToPrime((table.Length << 1) | 1); // allocate new hash table and link slots array var newTable = new int [newSize]; var newLinks = new Link [newSize]; for (int i = 0; i < table.Length; i++) { int current = table [i] - 1; while (current != NO_SLOT) { int hashCode = newLinks [current].HashCode = GetItemHashCode(slots [current]); int index = (hashCode & int.MaxValue) % newSize; newLinks [current].Next = newTable [index] - 1; newTable [index] = current + 1; current = links [current].Next; } } table = newTable; links = newLinks; // allocate new data slots, copy data var newSlots = new T [newSize]; Array.Copy(slots, 0, newSlots, 0, touched); slots = newSlots; threshold = (int)(newSize * DEFAULT_LOAD_FACTOR); }
private void Resize(int newSize) { // Hash table size needs to be prime. newSize = PrimeHelper.NextPrime(newSize); var newTable = new int[newSize]; var newSlots = new Slot[newSize]; // Copy current slots. Array.Copy(_slots, 0, newSlots, 0, _touchedSlots); // Update hash table and rebuild chains. for (int slotIndex = 0; slotIndex < _touchedSlots; slotIndex++) { int hashCode = GetHashCode(newSlots[slotIndex].ObjectA, newSlots[slotIndex].ObjectB); int tableIndex = hashCode % newSize; newSlots[slotIndex].Next = newTable[tableIndex] - 1; newTable[tableIndex] = slotIndex + 1; } _table = newTable; _slots = newSlots; if (_used != null) { var newUsed = new bool[newSize]; Array.Copy(_used, 0, newUsed, 0, _touchedSlots); _used = newUsed; } }
//The prime factors of 13195 are 5, 7, 13 and 29. //What is the largest prime factor of the number 600851475143 ? public static long Execute() { const long value = 600851475143; long largestPrime = 0; var max = Math.Ceiling(Math.Sqrt(value)); for (long i = 2; i < max; i++) { if (value % i != 0) { continue; } if (PrimeHelper.IsPrime(i)) { largestPrime = i; } var divider = value / i; if (!PrimeHelper.IsPrime(divider)) { continue; } largestPrime = divider; i = divider; } return(largestPrime); }
public void Get10001stPrime() { var findPrime = new PrimeHelper(); var result = findPrime.GetNthPrime(10001); Assert.True(result == 104743); }
protected override string Solve() { int result = 0; for (int i = 1; i < 10; i++) { string numberString = string.Empty; for (int j = 1; j <= i; j++) { numberString += j.ToString(); } int number = int.Parse(numberString); int[] permutations = number.GetPermutations(); foreach (int candidate in permutations) { if (PrimeHelper.IsPrime(candidate) && candidate > result) { result = candidate; } } } return(result.ToString("0")); }
public void Solve() { var ph = new PrimeHelper(); long result = ph.PrimesAtOrdinal(10001); Console.WriteLine($"Problem 7: {result}"); }
/// <summary> /// Sets the capacity of the <see cref="HashSetEx{T}"/> to a value suitable for the current /// number of elements in the set. /// </summary> /// <remarks> /// <para> /// This method can be used to minimize a collection's memory overhead if no new elements will /// be added to the collection. /// </para> /// <para> /// This method is an O(n) operation, where n is <see cref="Count"/>. /// </para> /// <para> /// To reset a <see cref="HashSetEx{T}"/> to its initial state, call the <see cref="Clear"/> /// method before calling <see cref="TrimExcess"/> method. Trimming an empty /// <see cref="HashSetEx{T}"/> sets the capacity of the <see cref="HashSetEx{T}"/> to the /// default capacity. /// </para> /// </remarks> public void TrimExcess() { // Similar to Resize(), except that TrimExcess() compacts the items and clears // the free list! int newSize = PrimeHelper.NextPrime((_count > 0) ? _count : InitialSize); int[] newTable = new int[newSize]; var newSlots = new Slot[newSize]; // Insert items in new hash table and slots (without recomputing the hash code). int newIndex = 0; for (int oldIndex = 0; oldIndex < _touchedSlots; oldIndex++) { if (_slots[oldIndex].HashCode >= 0) { newSlots[newIndex].HashCode = _slots[oldIndex].HashCode; newSlots[newIndex].Item = _slots[oldIndex].Item; int tableIndex = newSlots[newIndex].HashCode % newSize; newSlots[newIndex].Next = newTable[tableIndex] - 1; newTable[tableIndex] = newIndex + 1; newIndex++; } } _table = newTable; _slots = newSlots; _touchedSlots = newIndex; _freeList = -1; _version++; }
public BigInteger Solve(BigInteger?input = null) { int result = 0; int primesLimit = 100000; while (result == 0) { BigInteger numberOfPrimes = 0; bool[] test = PrimeHelper.FindPrimesUnderLimit(primesLimit); for (int i = 0; i < test.Length; i++) { if (test[i]) { numberOfPrimes++; if (numberOfPrimes == input) { result = i; } } } primesLimit += 100000; } return(result); }
private void Resize(int newSize) { // Similar to TrimAccess(), except that Resize() does not compact the items. // The free list remains! // Hash table size needs to be prime. newSize = PrimeHelper.NextPrime(newSize); var newTable = new int[newSize]; var newSlots = new Slot[newSize]; // Copy current slots. Array.Copy(_slots, 0, newSlots, 0, _touchedSlots); // Update hash table and rebuild chains. for (int slotIndex = 0; slotIndex < _touchedSlots; slotIndex++) { int tableIndex = newSlots[slotIndex].HashCode % newSize; newSlots[slotIndex].Next = newTable[tableIndex] - 1; newTable[tableIndex] = slotIndex + 1; } _table = newTable; _slots = newSlots; }
public void TestIsPrime() { var input = new[] { 18, 13, 68, 99, 93, 34, 11, 47, 64, 10, 809, 3420, 9391, 8999, 5154, 8934, 5416, 5669, 2755, 3159, 285080, 727881, 846232, 665370, 153194, 157833, 585896, 914054, 505284, 333258, 49086597, 78119724, 76928802, 23260170, 1955743, 39360664, 10885879, 30169506, 65889970, 95425647, 179424551, 179424571, 179424577, 179424601, 179424611, 179424617, 179424629, 179424667, 179424671, 179424673, 1683899352, 883641873, 114883641, 1000000007, 1000000009, 1000000021, 1000000033, 1000000087, 1000000093, 2147483629 }; var output = new[] { 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }; Assert.AreEqual(input.Length, output.Length, "setup"); for (var index = 0; index < output.Length; index++) { Assert.AreEqual(output[index] == 1, PrimeHelper.IsPrime(input[index])); } }
public void TestToPrime() { var input = new[] { 18, 13, 68, 99, 93, 34, 11, 47, 64, 10, 809, 3420, 9391, 8999, 5154, 8934, 5416, 5669, 2755, 3159, 285080, 727881, 846232, 665370, 153194, 157833, 585896, 914054, 505284, 333258, 49086597, 78119724, 76928802, 23260170, 1955743, 39360664, 10885879, 30169506, 65889970, 95425647, 179424551, 179424571, 179424577, 179424601, 179424611, 179424617, 179424629, 179424667, 179424671, 179424673, 1683899352, 883641873, 114883641, 1000000007, 1000000009, 1000000021, 1000000033, 1000000087, 1000000093 }; var output = new[] { 19, 13, 71, 101, 97, 37, 11, 47, 67, 11, 809, 3433, 9391, 8999, 5167, 8941, 5417, 5669, 2767, 3163, 285091, 727891, 846233, 665381, 153247, 157837, 585899, 914117, 505301, 333269, 49086613, 78119749, 76928807, 23260187, 1955747, 39360683, 10885891, 30169523, 65889997, 95425663, 179424551, 179424571, 179424577, 179424601, 179424611, 179424617, 179424629, 179424667, 179424671, 179424673, 1683899359, 883641893, 114883661, 1000000007, 1000000009, 1000000021, 1000000033, 1000000087, 1000000093 }; Assert.AreEqual(input.Length, output.Length, "setup"); for (var index = 0; index < output.Length; index++) { Assert.AreEqual(output[index], PrimeHelper.ToPrime(input[index])); Assert.IsTrue(PrimeHelper.IsPrime(output[index])); } }
public BigInteger Solve(BigInteger?input = null) { bool[] primesUnderAMillion = PrimeHelper.FindPrimesUnderLimit(1000000); BigInteger result = 0; for (int i = 2; i < 1000000; i++) { var testNumber = i; var circular = true; var testString = testNumber.ToString(); for (int j = 0; j <= i.ToString().Length + 1; j++) { if (!primesUnderAMillion[testNumber] || testNumber > 1000000) { circular = false; break; } testString = testString.Insert(testString.Length, testString.Substring(0, 1)); testString = testString.Remove(0, 1); testNumber = int.Parse(testString); } if (circular) { result++; } } return(result); }
private void btnGenerateSequenceToFile_Click(object sender, EventArgs e) { if (!IsFilterOpen) { return; } string filename = FormHelper.SaveFileDlg(FormHelper.FiletypeFilters.SequenceFiles); if (!string.IsNullOrWhiteSpace(filename)) { int randomNumber = rand.Next(50000); BigInteger randomIncrementValue = PrimeHelper.GetPreviousPrime(randomNumber); ByteGenerator.SequenceGenerator randomSequence = new ByteGenerator.SequenceGenerator(8, randomNumber, (int)randomIncrementValue); int counter = 0; int maxElements = filter.MaxElementsToHash / 2; List <string> elementsCollection = new List <string>(); while (counter < maxElements) { string nextElement = randomSequence.GetNext(); elementsCollection.Add(nextElement); counter++; } File.WriteAllLines(filename, elementsCollection); } }
public void TestBasicNonPrimes1To10() { int[] notPrimes = { 1, 4, 6, 8, 9, 10 }; foreach (int notPrime in notPrimes) { Assert.IsFalse(PrimeHelper.IsPrime(notPrime), $"{notPrime} was found to be prime"); } }
public void GetNthPrime(uint nthPrime, uint target) { var findPrime = new PrimeHelper(); var result = findPrime.GetNthPrime(nthPrime); Assert.True(result == target); }
public void TestBasicPrimes1To10() { int[] primes = { 2, 3, 5, 7 }; foreach (int prime in primes) { Assert.IsTrue(PrimeHelper.IsPrime(prime), $"{prime} was not found to be prime"); } }
/// <summary> /// Initializes a new instance of the <see cref="SynchronizedHashtable{TKey,TValue}"/> class. /// </summary> /// <param name="capacity">The number of buckets in the hash table.</param> /// <remarks> /// For efficiency the <paramref name="capacity"/> is automatically incremented to the next /// prime number. /// </remarks> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="capacity"/> is less than 1. /// </exception> public SynchronizedHashtable(int capacity) { if (capacity < 1) throw new ArgumentOutOfRangeException("capacity", "The initial capacity must be greater than 0."); capacity = PrimeHelper.NextPrime(capacity); _buckets = new Node[capacity]; }
public void TestGetLowestAndHighestFactor() { int number = 909; LowestAndHighestFactor factors = PrimeHelper.GetLowestAndHighestFactor(number); LowestAndHighestFactor expectedFactors = new LowestAndHighestFactor(3, 303); Assert.AreEqual(expectedFactors.lowest, factors.lowest, $"The lowest factor of {number} was incorrect"); Assert.AreEqual(expectedFactors.highest, factors.highest, $"The highest factor of {number} was incorrect"); }
public void Solve() { var helper = new PrimeHelper(); long input = 600851475143; List <long> primeFactorisation = helper.PrimeFactorisation(input); Console.WriteLine($"Problem 3: {primeFactorisation.Max ()}"); }
public static int ExpandPrime(int oldSize) { int num = 2 * oldSize; if (num > 2146435069 && 2146435069 > oldSize) { return(2146435069); } return(PrimeHelper.GetPrime(num)); }
protected override string Solve() { long result = 0; IEnumerable <long> primes = PrimeHelper.GeneratePrimes(1999999); result = primes.Sum(); return(result.ToString("0")); }
public void PrimesRepeatability() { var primes = PrimeHelper.Primes().Take(20).ToArray(); var p2 = PrimeHelper.Primes().Take(20).ToArray(); for (var i = 0; i < p2.Length; i++) { Assert.Equal(primes[i], p2[i]); } }
public void GetAllTruncatablePrimes_WhenCalled_ReturnsExpectedNumberOfPrimes() { // Arrange var expectedNumberOfTruncatablePrimes = 11; // Act var result = PrimeHelper.GetAllTruncatablePrimes(); // Result result.Should().HaveCount(expectedNumberOfTruncatablePrimes); }
private void Initialize(int capacity) { capacity = PrimeHelper.NextPrime(capacity); _table = new int[capacity]; _slots = new Slot[capacity]; _touchedSlots = 0; _freeList = -1; _count = 0; _version = 0; }
public void TestPrimeBounds() { // 2147483629 is tha last prime below int.MaxValue Assert.AreEqual(2, PrimeHelper.NextPrime(-1)); Assert.AreEqual(3, PrimeHelper.NextPrime(2)); Assert.Throws <OverflowException>(() => PrimeHelper.NextPrime(2147483629)); // 2147483629 is tha last prime below int.MaxValue Assert.AreEqual(2, PrimeHelper.ToPrime(-1)); Assert.AreEqual(2, PrimeHelper.ToPrime(2)); Assert.AreEqual(2147483629, PrimeHelper.ToPrime(2147483629)); }
protected override string Solve() { //stab in the dark here, the 10001st prime is probably below 10million? //could check numbers incrementally as prime or not, but a Sieve would be faster still IList <long> primes = PrimeHelper.GeneratePrimes(10000000).ToList(); primes.OrderBy(o => o); return(primes[10000].ToString("0")); }