eratosthenes prime test exercise

python/sieve/.exercism/metadata.json

@@ -0,0 +1 @@
+{"track":"python","exercise":"sieve","id":"9e38df44da5b4bc48d2d6e57ac7b5c2a","url":"https://exercism.io/my/solutions/9e38df44da5b4bc48d2d6e57ac7b5c2a","handle":"Xevion","is_requester":true,"auto_approve":false}

python/sieve/README.md

@@ -0,0 +1,79 @@
+# Sieve
+
+Use the Sieve of Eratosthenes to find all the primes from 2 up to a given
+number.
+
+The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
+prime numbers up to any given limit. It does so by iteratively marking as
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
+
+Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
+
+The algorithm consists of repeating the following over and over:
+
+- take the next available unmarked number in your list (it is prime)
+- mark all the multiples of that number (they are not prime)
+
+Repeat until you have processed each number in your range.
+
+When the algorithm terminates, all the numbers in the list that have not
+been marked are prime.
+
+The wikipedia article has a useful graphic that explains the algorithm:
+https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
+
+Notice that this is a very specific algorithm, and the tests don't check
+that you've implemented the algorithm, only that you've come up with the
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
+
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you should write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Running the tests
+
+To run the tests, run the appropriate command below ([why they are different](https://github.com/pytest-dev/pytest/issues/1629#issue-161422224)):
+
+- Python 2.7: `py.test sieve_test.py`
+- Python 3.4+: `pytest sieve_test.py`
+
+Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version):
+`python -m pytest sieve_test.py`
+
+### Common `pytest` options
+
+- `-v` : enable verbose output
+- `-x` : stop running tests on first failure
+- `--ff` : run failures from previous test before running other test cases
+
+For other options, see `python -m pytest -h`
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/sieve` directory.
+
+You can find your Exercism workspace by running `exercism debug` and looking for the line that starts with `Workspace`.
+
+For more detailed information about running tests, code style and linting,
+please see [Running the Tests](http://exercism.io/tracks/python/tests).
+
+## Source
+
+Sieve of Eratosthenes at Wikipedia [http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes](http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

python/sieve/sieve.py

@@ -0,0 +1,7 @@
+def primes(limit):
+    v = [False] * 2 + [True] * (limit+1)
+    for (i, prime) in enumerate(v):
+        if prime:
+            for x in range(i * i, limit+1, i):
+                v[x] = False
+    return [x for x, y in enumerate(v) if y and x <= limit]

python/sieve/sieve_test.py

@@ -0,0 +1,42 @@
+import unittest
+
+from sieve import primes
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
+class SieveTest(unittest.TestCase):
+    def test_no_primes_under_two(self):
+        self.assertEqual(primes(1), [])
+
+    def test_find_first_prime(self):
+        self.assertEqual(primes(2), [2])
+
+    def test_find_primes_up_to_10(self):
+        self.assertEqual(primes(10), [2, 3, 5, 7])
+
+    def test_limit_is_prime(self):
+        self.assertEqual(primes(13), [2, 3, 5, 7, 11, 13])
+
+    def test_find_primes_up_to_1000(self):
+        self.assertEqual(
+            primes(1000), [
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
+                61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
+                131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
+                193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257,
+                263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331,
+                337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401,
+                409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,
+                479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
+                569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631,
+                641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709,
+                719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797,
+                809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877,
+                881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967,
+                971, 977, 983, 991, 997
+            ])
+
+
+if __name__ == '__main__':
+    unittest.main()