From c4ae30d8c5a15af97d0da207f3b8223ae06f7060 Mon Sep 17 00:00:00 2001 From: Ricardo Martinez Peinado Date: Tue, 10 Oct 2023 22:00:00 +0200 Subject: [PATCH 1/3] Update the doctest of primelib.py --- maths/primelib.py | 251 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 247 insertions(+), 4 deletions(-) diff --git a/maths/primelib.py b/maths/primelib.py index cf01750cf912..c15de9e1a1b3 100644 --- a/maths/primelib.py +++ b/maths/primelib.py @@ -46,6 +46,19 @@ def is_prime(number: int) -> bool: """ input: positive integer 'number' returns true if 'number' is prime otherwise false. + + >>> is_prime(3) + True + >>> is_prime(10) + False + >>> is_prime(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and positive + >>> is_prime("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and positive """ # precondition @@ -83,6 +96,18 @@ def sieve_er(n): This function implements the algorithm called sieve of erathostenes. + >>> sieve_er(8) + [2, 3, 5, 7] + >>> sieve_er(2) + [2] + >>> sieve_er(-1) + Traceback (most recent call last): + ... + AssertionError: 'N' must been an int and > 2 + >>> sieve_er("test") + Traceback (most recent call last): + ... + AssertionError: 'N' must been an int and > 2 """ # precondition @@ -116,6 +141,19 @@ def get_prime_numbers(n): input: positive integer 'N' > 2 returns a list of prime numbers from 2 up to N (inclusive) This function is more efficient as function 'sieveEr(...)' + + >>> get_prime_numbers(8) + [2, 3, 5, 7] + >>> get_prime_numbers(2) + [2] + >>> get_prime_numbers(-1) + Traceback (most recent call last): + ... + AssertionError: 'n' must been an int and > 2 + >>> get_prime_numbers("test") + Traceback (most recent call last): + ... + AssertionError: 'n' must been an int and > 2 """ # precondition @@ -142,6 +180,21 @@ def prime_factorization(number): """ input: positive integer 'number' returns a list of the prime number factors of 'number' + + >>> prime_factorization(0) + [0] + >>> prime_factorization(8) + [2, 2, 2] + >>> prime_factorization(287) + [7, 41] + >>> prime_factorization(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 + >>> prime_factorization("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 """ # precondition @@ -183,12 +236,27 @@ def greatest_prime_factor(number): """ input: positive integer 'number' >= 0 returns the greatest prime number factor of 'number' + + >>> greatest_prime_factor(0) + 0 + >>> greatest_prime_factor(8) + 2 + >>> greatest_prime_factor(287) + 41 + >>> greatest_prime_factor(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 + >>> greatest_prime_factor("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 """ # precondition assert isinstance(number, int) and ( number >= 0 - ), "'number' bust been an int and >= 0" + ), "'number' must been an int and >= 0" ans = 0 @@ -210,12 +278,27 @@ def smallest_prime_factor(number): """ input: integer 'number' >= 0 returns the smallest prime number factor of 'number' + + >>> smallest_prime_factor(0) + 0 + >>> smallest_prime_factor(8) + 2 + >>> smallest_prime_factor(287) + 7 + >>> smallest_prime_factor(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 + >>> smallest_prime_factor("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 0 """ # precondition assert isinstance(number, int) and ( number >= 0 - ), "'number' bust been an int and >= 0" + ), "'number' must been an int and >= 0" ans = 0 @@ -237,11 +320,24 @@ def is_even(number): """ input: integer 'number' returns true if 'number' is even, otherwise false. + + >>> is_even(0) + True + >>> is_even(8) + True + >>> is_even(287) + False + >>> is_even(-1) + False + >>> is_even("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int """ # precondition assert isinstance(number, int), "'number' must been an int" - assert isinstance(number % 2 == 0, bool), "compare bust been from type bool" + assert isinstance(number % 2 == 0, bool), "compare must been from type bool" return number % 2 == 0 @@ -253,11 +349,24 @@ def is_odd(number): """ input: integer 'number' returns true if 'number' is odd, otherwise false. + + >>> is_odd(0) + False + >>> is_odd(8) + False + >>> is_odd(287) + True + >>> is_odd(-1) + True + >>> is_odd("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int """ # precondition assert isinstance(number, int), "'number' must been an int" - assert isinstance(number % 2 != 0, bool), "compare bust been from type bool" + assert isinstance(number % 2 != 0, bool), "compare must been from type bool" return number % 2 != 0 @@ -270,6 +379,22 @@ def goldbach(number): Goldbach's assumption input: a even positive integer 'number' > 2 returns a list of two prime numbers whose sum is equal to 'number' + >>> goldbach(8) + [3, 5] + >>> goldbach(824) + [3, 821] + >>> goldbach(0) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int, even and > 2 + >>> goldbach(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int, even and > 2 + >>> goldbach("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int, even and > 2 """ # precondition @@ -323,6 +448,22 @@ def kg_v(number1, number2): Least common multiple input: two positive integer 'number1' and 'number2' returns the least common multiple of 'number1' and 'number2' + >>> kg_v(8,10) + 40 + >>> kg_v(824,67) + 55208 + >>> kg_v(0) + Traceback (most recent call last): + ... + TypeError: kg_v() missing 1 required positional argument: 'number2' + >>> kg_v(10,-1) + Traceback (most recent call last): + ... + AssertionError: 'number1' and 'number2' must been positive integer. + >>> kg_v("test","test2") + Traceback (most recent call last): + ... + AssertionError: 'number1' and 'number2' must been positive integer. """ # precondition @@ -395,6 +536,21 @@ def get_prime(n): Gets the n-th prime number. input: positive integer 'n' >= 0 returns the n-th prime number, beginning at index 0 + + >>> get_prime(0) + 2 + >>> get_prime(8) + 23 + >>> get_prime(824) + 6337 + >>> get_prime(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been a positive int + >>> get_prime("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been a positive int """ # precondition @@ -430,6 +586,25 @@ def get_primes_between(p_number_1, p_number_2): pNumber1 < pNumber2 returns a list of all prime numbers between 'pNumber1' (exclusive) and 'pNumber2' (exclusive) + + >>> get_primes_between(3,67) + [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61] + >>> get_primes_between(0) + Traceback (most recent call last): + ... + TypeError: get_primes_between() missing 1 required positional argument: 'p_number_2' + >>> get_primes_between(0,1) + Traceback (most recent call last): + ... + AssertionError: The arguments must been prime numbers and 'pNumber1' < 'pNumber2' + >>> get_primes_between(-1,3) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and positive + >>> get_primes_between("test","test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and positive """ # precondition @@ -473,6 +648,19 @@ def get_divisors(n): """ input: positive integer 'n' >= 1 returns all divisors of n (inclusive 1 and 'n') + + >>> get_divisors(8) + [1, 2, 4, 8] + >>> get_divisors(824) + [1, 2, 4, 8, 103, 206, 412, 824] + >>> get_divisors(-1) + Traceback (most recent call last): + ... + AssertionError: 'n' must been int and >= 1 + >>> get_divisors("test") + Traceback (most recent call last): + ... + AssertionError: 'n' must been int and >= 1 """ # precondition @@ -497,6 +685,19 @@ def is_perfect_number(number): """ input: positive integer 'number' > 1 returns true if 'number' is a perfect number otherwise false. + + >>> is_perfect_number(28) + True + >>> is_perfect_number(824) + False + >>> is_perfect_number(-1) + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 1 + >>> is_perfect_number("test") + Traceback (most recent call last): + ... + AssertionError: 'number' must been an int and >= 1 """ # precondition @@ -525,6 +726,17 @@ def simplify_fraction(numerator, denominator): input: two integer 'numerator' and 'denominator' assumes: 'denominator' != 0 returns: a tuple with simplify numerator and denominator. + + >>> simplify_fraction(10,20) + (1,2) + >>> simplify_fraction(10,-1) + Traceback (most recent call last): + ... + AssertionError: The arguments must been from type int and 'denominator' != 0" + >>> simplify_fraction("test","test") + Traceback (most recent call last): + ... + AssertionError: The arguments must been from type int and 'denominator' != 0" """ # precondition @@ -554,6 +766,19 @@ def factorial(n): """ input: positive integer 'n' returns the factorial of 'n' (n!) + + >>> factorial(0) + 1 + >>> factorial(20) + 2432902008176640000 + >>> factorial(-1) + Traceback (most recent call last): + ... + AssertionError: 'n' must been a int and >= 0 + >>> factorial("test") + Traceback (most recent call last): + ... + AssertionError: 'n' must been a int and >= 0 """ # precondition @@ -574,6 +799,19 @@ def fib(n): """ input: positive integer 'n' returns the n-th fibonacci term , indexing by 0 + + >>> fib(0) + 1 + >>> fib(20) + 10946 + >>> fib(-1) + Traceback (most recent call last): + ... + AssertionError: 'n' must been an int and >= 0 + >>> fib("test") + Traceback (most recent call last): + ... + AssertionError: 'n' must been an int and >= 0 """ # precondition @@ -589,3 +827,8 @@ def fib(n): fib1 = tmp return ans + +if __name__ == "__main__": + import doctest + + doctest.testmod() From 73598a7b258ad0a923b8bbf46a4852969c997ed7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 10 Oct 2023 20:07:48 +0000 Subject: [PATCH 2/3] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- maths/primelib.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/maths/primelib.py b/maths/primelib.py index c15de9e1a1b3..798808ccd16f 100644 --- a/maths/primelib.py +++ b/maths/primelib.py @@ -586,7 +586,7 @@ def get_primes_between(p_number_1, p_number_2): pNumber1 < pNumber2 returns a list of all prime numbers between 'pNumber1' (exclusive) and 'pNumber2' (exclusive) - + >>> get_primes_between(3,67) [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61] >>> get_primes_between(0) @@ -828,6 +828,7 @@ def fib(n): return ans + if __name__ == "__main__": import doctest From 57979a096a72ea0a79d7e88ab4dab47210a41160 Mon Sep 17 00:00:00 2001 From: Ricardo Martinez Peinado Date: Wed, 11 Oct 2023 10:57:49 +0200 Subject: [PATCH 3/3] Correct errors for the doctest of primelib.py --- maths/primelib.py | 88 +++++++++++++++++++++++------------------------ 1 file changed, 43 insertions(+), 45 deletions(-) diff --git a/maths/primelib.py b/maths/primelib.py index c15de9e1a1b3..dc4ceed18401 100644 --- a/maths/primelib.py +++ b/maths/primelib.py @@ -98,15 +98,13 @@ def sieve_er(n): >>> sieve_er(8) [2, 3, 5, 7] - >>> sieve_er(2) - [2] >>> sieve_er(-1) Traceback (most recent call last): - ... + ... AssertionError: 'N' must been an int and > 2 >>> sieve_er("test") Traceback (most recent call last): - ... + ... AssertionError: 'N' must been an int and > 2 """ @@ -144,16 +142,14 @@ def get_prime_numbers(n): >>> get_prime_numbers(8) [2, 3, 5, 7] - >>> get_prime_numbers(2) - [2] >>> get_prime_numbers(-1) Traceback (most recent call last): - ... - AssertionError: 'n' must been an int and > 2 + ... + AssertionError: 'N' must been an int and > 2 >>> get_prime_numbers("test") Traceback (most recent call last): - ... - AssertionError: 'n' must been an int and > 2 + ... + AssertionError: 'N' must been an int and > 2 """ # precondition @@ -189,11 +185,11 @@ def prime_factorization(number): [7, 41] >>> prime_factorization(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 >>> prime_factorization("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 """ @@ -245,11 +241,11 @@ def greatest_prime_factor(number): 41 >>> greatest_prime_factor(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 >>> greatest_prime_factor("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 """ @@ -287,11 +283,11 @@ def smallest_prime_factor(number): 7 >>> smallest_prime_factor(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 >>> smallest_prime_factor("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 0 """ @@ -331,7 +327,7 @@ def is_even(number): False >>> is_even("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int """ @@ -360,7 +356,7 @@ def is_odd(number): True >>> is_odd("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int """ @@ -379,21 +375,22 @@ def goldbach(number): Goldbach's assumption input: a even positive integer 'number' > 2 returns a list of two prime numbers whose sum is equal to 'number' + >>> goldbach(8) [3, 5] >>> goldbach(824) [3, 821] >>> goldbach(0) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int, even and > 2 >>> goldbach(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int, even and > 2 >>> goldbach("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int, even and > 2 """ @@ -448,21 +445,22 @@ def kg_v(number1, number2): Least common multiple input: two positive integer 'number1' and 'number2' returns the least common multiple of 'number1' and 'number2' + >>> kg_v(8,10) 40 >>> kg_v(824,67) 55208 >>> kg_v(0) Traceback (most recent call last): - ... + ... TypeError: kg_v() missing 1 required positional argument: 'number2' >>> kg_v(10,-1) Traceback (most recent call last): - ... + ... AssertionError: 'number1' and 'number2' must been positive integer. >>> kg_v("test","test2") Traceback (most recent call last): - ... + ... AssertionError: 'number1' and 'number2' must been positive integer. """ @@ -545,11 +543,11 @@ def get_prime(n): 6337 >>> get_prime(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been a positive int >>> get_prime("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been a positive int """ @@ -586,24 +584,24 @@ def get_primes_between(p_number_1, p_number_2): pNumber1 < pNumber2 returns a list of all prime numbers between 'pNumber1' (exclusive) and 'pNumber2' (exclusive) - - >>> get_primes_between(3,67) + + >>> get_primes_between(3, 67) [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61] >>> get_primes_between(0) Traceback (most recent call last): - ... + ... TypeError: get_primes_between() missing 1 required positional argument: 'p_number_2' - >>> get_primes_between(0,1) + >>> get_primes_between(0, 1) Traceback (most recent call last): - ... + ... AssertionError: The arguments must been prime numbers and 'pNumber1' < 'pNumber2' - >>> get_primes_between(-1,3) + >>> get_primes_between(-1, 3) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and positive >>> get_primes_between("test","test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and positive """ @@ -655,11 +653,11 @@ def get_divisors(n): [1, 2, 4, 8, 103, 206, 412, 824] >>> get_divisors(-1) Traceback (most recent call last): - ... + ... AssertionError: 'n' must been int and >= 1 >>> get_divisors("test") Traceback (most recent call last): - ... + ... AssertionError: 'n' must been int and >= 1 """ @@ -692,11 +690,11 @@ def is_perfect_number(number): False >>> is_perfect_number(-1) Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 1 >>> is_perfect_number("test") Traceback (most recent call last): - ... + ... AssertionError: 'number' must been an int and >= 1 """ @@ -727,15 +725,15 @@ def simplify_fraction(numerator, denominator): assumes: 'denominator' != 0 returns: a tuple with simplify numerator and denominator. - >>> simplify_fraction(10,20) - (1,2) - >>> simplify_fraction(10,-1) + >>> simplify_fraction(10, 20) + (1, 2) + >>> simplify_fraction(10, -1) Traceback (most recent call last): - ... + ... AssertionError: The arguments must been from type int and 'denominator' != 0" >>> simplify_fraction("test","test") Traceback (most recent call last): - ... + ... AssertionError: The arguments must been from type int and 'denominator' != 0" """ @@ -773,11 +771,11 @@ def factorial(n): 2432902008176640000 >>> factorial(-1) Traceback (most recent call last): - ... + ... AssertionError: 'n' must been a int and >= 0 >>> factorial("test") Traceback (most recent call last): - ... + ... AssertionError: 'n' must been a int and >= 0 """