Updated Sieve of Eratosthenes to utilize Hashset instead of list internally. Now returns an IEnumerable instead of list. Implemented unit tests

Author: Matthew Detweiler

Algorithms/Numeric/SieveOfEratosthenes.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 /***
 * Generates all prime numbers up to a given number
@@ -14,43 +15,43 @@ public static class SieveOfEratosthenes
         /// <summary>
         /// Calculate primes up to a given number
         /// </summary>
-        public static List<int> GeneratePrimesUpTo(int x)
+        public static IEnumerable<int> GeneratePrimesUpTo(int x)
         {
 
-            //The list of primes that will be returned
-            List<int> primesList = new List<int>();
+            //The hash of primes that will be returned
+            var primes = new HashSet<int>();
 
             //Returns an empty list if x is a value under 2
             if (x < 2)
             {
-                return primesList;
+                return primes.ToList();
             }
 
-            //Adds every number between 2 and x to the list
+            //Adds every number between 2 and x to the hashset
             for (int i = 2; i <= x; i++)
             {
-                primesList.Add(i);
+                primes.Add(i);
             }
 
-            //integer that all multiples of will be removed from the list
+            //integer that all multiples of will be removed from the hashset
             int removeMultiplesOf;
 
-            //Finds the next number in the list that hasn't been removed and removes all multiples of that number 
-            //from the list
+            //Finds the next number that hasn't been removed and removes all multiples of that number 
+            //from the hashset
             for (int i = 2; i <= Math.Sqrt(x); i++)
             {
-                if (primesList.Contains(i))
+                if (primes.Contains(i))
                 {
                     removeMultiplesOf = i;
-                    for (int j = removeMultiplesOf*removeMultiplesOf; j <= x; j += removeMultiplesOf)
+                    for (int j = removeMultiplesOf * removeMultiplesOf; j <= x; j += removeMultiplesOf)
                     {
-                        primesList.Remove(j);
+                        primes.Remove(j);
                     }
                 }
             }
 
             //The list of primes is returned
-            return primesList;
+            return primes.ToList();
         }
 
     }

UnitTest/AlgorithmsTests/SieveOfEratosthenesTests.cs

@@ -0,0 +1,35 @@
+using Algorithms.Numeric;
+using System.Linq;
+using Xunit;
+
+namespace UnitTest.AlgorithmsTests
+{
+    public class SieveOfEratosthenesTests
+    {
+        private const int MaxNumber = 100;
+
+        [Fact]
+        public void SieveOfEratosthenesGeneratesCorrectResults()
+        {
+            var results = SieveOfEratosthenes.GeneratePrimesUpTo(MaxNumber);
+            Assert.NotNull(results);
+            Assert.True(results.Any());
+            Assert.Equal(results.Count(), 25);
+            Assert.DoesNotContain(1, results);
+            Assert.Contains(2, results);
+            Assert.Contains(7, results);
+            Assert.Contains(23, results);
+            Assert.Contains(41, results);
+            Assert.Contains(97, results);
+
+        }
+
+        [Fact]
+        public void SieveOfEratosthenesReturnsEmptyListWhenGiven0()
+        {
+            var results = SieveOfEratosthenes.GeneratePrimesUpTo(0);
+            Assert.NotNull(results);
+            Assert.False(results.Any());
+        }
+    }
+}