From da81529d4eff570d1eb09adaeba9af688ab74d25 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Fri, 11 Apr 2025 14:38:18 +0000 Subject: [PATCH 1/7] Add prime number checker implementation --- src/prime_checker.py | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 src/prime_checker.py diff --git a/src/prime_checker.py b/src/prime_checker.py new file mode 100644 index 00000000..7923ee13 --- /dev/null +++ b/src/prime_checker.py @@ -0,0 +1,40 @@ +def is_prime(n): + """ + Check if a given number is prime. + + A prime number is a natural number greater than 1 that is only divisible by 1 and itself. + + Args: + n (int): The number to check for primality. + + Returns: + bool: True if the number is prime, False otherwise. + + Raises: + TypeError: If the input is not an integer. + ValueError: If the input is less than or equal to 0. + """ + # Check input type + if not isinstance(n, int): + raise TypeError("Input must be an integer") + + # Check input range + if n <= 0: + raise ValueError("Input must be a positive integer greater than 0") + + # Handle small prime numbers + if n == 1: + return False + if n <= 3: + return True + + # Optimize for even numbers + if n % 2 == 0: + return False + + # Check for divisibility up to the square root of n + for i in range(3, int(n**0.5) + 1, 2): + if n % i == 0: + return False + + return True \ No newline at end of file From f7706b9bdf51ca65fac894573a182ad14683e06c Mon Sep 17 00:00:00 2001 From: momstrosity Date: Fri, 11 Apr 2025 14:39:03 +0000 Subject: [PATCH 2/7] Add tests for prime number checker --- tests/test_prime_checker.py | 38 +++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 tests/test_prime_checker.py diff --git a/tests/test_prime_checker.py b/tests/test_prime_checker.py new file mode 100644 index 00000000..f39f35dd --- /dev/null +++ b/tests/test_prime_checker.py @@ -0,0 +1,38 @@ +import pytest +from src.prime_checker import is_prime + +def test_prime_numbers(): + """Test known prime numbers""" + prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] + for num in prime_numbers: + assert is_prime(num) is True, f"{num} should be prime" + +def test_non_prime_numbers(): + """Test known non-prime numbers""" + non_prime_numbers = [1, 4, 6, 8, 9, 10, 12, 14, 15, 16] + for num in non_prime_numbers: + assert is_prime(num) is False, f"{num} should not be prime" + +def test_large_prime_number(): + """Test a larger prime number""" + assert is_prime(997) is True + +def test_large_non_prime_number(): + """Test a larger non-prime number""" + assert is_prime(1000) is False + +def test_invalid_input_types(): + """Test invalid input types""" + with pytest.raises(TypeError): + is_prime(3.14) + with pytest.raises(TypeError): + is_prime("7") + with pytest.raises(TypeError): + is_prime([7]) + +def test_invalid_input_range(): + """Test invalid input ranges""" + with pytest.raises(ValueError): + is_prime(0) + with pytest.raises(ValueError): + is_prime(-5) \ No newline at end of file From 61c3d961ab08b7b8e2b1c9aefce1186d6ebff787 Mon Sep 17 00:00:00 2001 From: momstrosity Date: Fri, 11 Apr 2025 15:11:38 +0000 Subject: [PATCH 3/7] Add prime factorization implementation --- src/prime_factorization.py | 47 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 src/prime_factorization.py diff --git a/src/prime_factorization.py b/src/prime_factorization.py new file mode 100644 index 00000000..e509c1e6 --- /dev/null +++ b/src/prime_factorization.py @@ -0,0 +1,47 @@ +def prime_factorization(n): + """ + Compute the prime factorization of a given positive integer. + + Args: + n (int): A positive integer to factorize. + + Returns: + list: A list of prime factors in ascending order. + + Raises: + ValueError: If the input is not a positive integer. + """ + # Validate input + if not isinstance(n, int): + raise ValueError("Input must be an integer") + + if n <= 0: + raise ValueError("Input must be a positive integer") + + # Special case for 1 + if n == 1: + return [] + + # Initialize list to store prime factors + factors = [] + + # Handle 2 as a special case to optimize the loop + while n % 2 == 0: + factors.append(2) + n //= 2 + + # Check for odd prime factors + # We only need to check up to sqrt(n) + factor = 3 + while factor * factor <= n: + if n % factor == 0: + factors.append(factor) + n //= factor + else: + factor += 2 + + # If n is a prime number greater than 2 + if n > 2: + factors.append(n) + + return factors \ No newline at end of file From eba21ed50ce6060be07cabaccfb2e91629472b4f Mon Sep 17 00:00:00 2001 From: momstrosity Date: Fri, 11 Apr 2025 15:11:48 +0000 Subject: [PATCH 4/7] Add tests for prime factorization function --- tests/test_prime_factorization.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 tests/test_prime_factorization.py diff --git a/tests/test_prime_factorization.py b/tests/test_prime_factorization.py new file mode 100644 index 00000000..3e24a673 --- /dev/null +++ b/tests/test_prime_factorization.py @@ -0,0 +1,31 @@ +import pytest +from src.prime_factorization import prime_factorization + +def test_prime_factorization_basic(): + assert prime_factorization(12) == [2, 2, 3] + assert prime_factorization(15) == [3, 5] + assert prime_factorization(100) == [2, 2, 5, 5] + +def test_prime_factorization_prime_numbers(): + assert prime_factorization(7) == [7] + assert prime_factorization(11) == [11] + assert prime_factorization(23) == [23] + +def test_prime_factorization_one(): + assert prime_factorization(1) == [] + +def test_prime_factorization_large_number(): + assert prime_factorization(84) == [2, 2, 3, 7] + +def test_prime_factorization_edge_cases(): + with pytest.raises(ValueError): + prime_factorization(0) + + with pytest.raises(ValueError): + prime_factorization(-5) + + with pytest.raises(ValueError): + prime_factorization(3.14) + + with pytest.raises(ValueError): + prime_factorization("not a number") \ No newline at end of file From 1785651e06aab6f07c34c819e3049879f8f37cc7 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Fri, 11 Apr 2025 15:40:19 +0000 Subject: [PATCH 5/7] Implement GCD calculator using prime factorization --- src/gcd_calculator.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 src/gcd_calculator.py diff --git a/src/gcd_calculator.py b/src/gcd_calculator.py new file mode 100644 index 00000000..8b50cb9c --- /dev/null +++ b/src/gcd_calculator.py @@ -0,0 +1,32 @@ +from src.prime_factorization import prime_factorization + +def gcd_using_prime_factors(a: int, b: int) -> int: + """ + Calculate the Greatest Common Divisor (GCD) of two numbers using prime factorization. + + Args: + a (int): First positive integer + b (int): Second positive integer + + Returns: + int: The Greatest Common Divisor of a and b + + Raises: + ValueError: If either input is less than or equal to 0 + """ + # Validate inputs + if a <= 0 or b <= 0: + raise ValueError("Inputs must be positive integers") + + # Get prime factorizations of both numbers + a_factors = prime_factorization(a) + b_factors = prime_factorization(b) + + # Find common prime factors + gcd = 1 + for prime, count in a_factors.items(): + if prime in b_factors: + # Take the minimum count of each common prime factor + gcd *= prime ** min(count, b_factors[prime]) + + return gcd \ No newline at end of file From 2b96b53f7cbf4175c63539bd1a7f273ca563a771 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Fri, 11 Apr 2025 15:40:29 +0000 Subject: [PATCH 6/7] Add tests for GCD calculator using prime factorization --- tests/test_gcd_calculator.py | 38 ++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 tests/test_gcd_calculator.py diff --git a/tests/test_gcd_calculator.py b/tests/test_gcd_calculator.py new file mode 100644 index 00000000..7487a48e --- /dev/null +++ b/tests/test_gcd_calculator.py @@ -0,0 +1,38 @@ +import pytest +from src.gcd_calculator import gcd_using_prime_factors + +def test_gcd_using_prime_factors_basic(): + """Test basic GCD calculations""" + assert gcd_using_prime_factors(48, 18) == 6 + assert gcd_using_prime_factors(54, 24) == 6 + assert gcd_using_prime_factors(17, 23) == 1 + assert gcd_using_prime_factors(100, 75) == 25 + +def test_gcd_using_prime_factors_same_number(): + """Test GCD when both numbers are the same""" + assert gcd_using_prime_factors(7, 7) == 7 + assert gcd_using_prime_factors(100, 100) == 100 + +def test_gcd_using_prime_factors_one_is_multiple(): + """Test GCD when one number is a multiple of the other""" + assert gcd_using_prime_factors(12, 36) == 12 + assert gcd_using_prime_factors(36, 12) == 12 + +def test_gcd_using_prime_factors_coprime(): + """Test GCD of coprime numbers""" + assert gcd_using_prime_factors(5, 11) == 1 + assert gcd_using_prime_factors(7, 13) == 1 + +def test_gcd_using_prime_factors_invalid_input(): + """Test error handling for invalid inputs""" + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(0, 5) + + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(5, 0) + + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(-5, 5) + + with pytest.raises(ValueError, match="Inputs must be positive integers"): + gcd_using_prime_factors(5, -5) \ No newline at end of file From fdf7947d292b4ea35d46f48722666597f5069a18 Mon Sep 17 00:00:00 2001 From: labrocadabro Date: Fri, 11 Apr 2025 15:40:48 +0000 Subject: [PATCH 7/7] Update GCD calculator to use Counter with prime factorization --- src/gcd_calculator.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/gcd_calculator.py b/src/gcd_calculator.py index 8b50cb9c..61261907 100644 --- a/src/gcd_calculator.py +++ b/src/gcd_calculator.py @@ -1,4 +1,5 @@ from src.prime_factorization import prime_factorization +from collections import Counter def gcd_using_prime_factors(a: int, b: int) -> int: """ @@ -19,8 +20,8 @@ def gcd_using_prime_factors(a: int, b: int) -> int: raise ValueError("Inputs must be positive integers") # Get prime factorizations of both numbers - a_factors = prime_factorization(a) - b_factors = prime_factorization(b) + a_factors = Counter(prime_factorization(a)) + b_factors = Counter(prime_factorization(b)) # Find common prime factors gcd = 1