Merge pull request #5 from eliasailenei/solution2

Solution2

Author: eliasailenei

__pycache__/sol2.cpython-313.pyc

@@ -2,21 +2,40 @@
 import matplotlib.pyplot as plt
 import sol2  # Assuming sol2 is provided
 import sol1  # Assuming sol1 is provided
-import sol3  # Since sol3 is nearly identical to sol2, we alias it for clarity
+import sol3  # Assuming sol3 is provided and similar to sol2
+
+def run_case(binary_str, n, solution, header):
+    start_time = time.perf_counter_ns()  
+    output_sol = solution.extract_primes(binary_str, n)
+    elapsed_time_ns = time.perf_counter_ns() - start_time  
+
+    if elapsed_time_ns < 1_000:  # Less than 1µs
+        formatted_time = f"{elapsed_time_ns} ns"
+    elif elapsed_time_ns < 1_000_000:  # Less than 1ms
+        formatted_time = f"{elapsed_time_ns / 1_000:.3f} µs"
+    elif elapsed_time_ns < 1_000_000_000:  # Less than 1s
+        formatted_time = f"{elapsed_time_ns / 1_000_000:.3f} ms"
+    else:
+        formatted_time = f"{elapsed_time_ns / 1_000_000_000:.6f} s"
+
+    elapsed_time_s = elapsed_time_ns / 1_000_000_000  # Convert to seconds
+    return f" {header}: \n  Time taken: {formatted_time} \n  Answer: {output_sol}", elapsed_time_s
+
+# Define test cases
 test_cases = [
-    ("0100001101001111", 999999), # 1
-    ("01000011010011110100110101010000", 999999), # 2
-    ("1111111111111111111111111111111111111111", 999999), # 3
-    ("010000110100111101001101010100000011000100111000", 999999999), # 4
-    ("01000011010011110100110101010000001100010011100000110001", 123456789012), # 5
-    ("0100001101001111010011010101000000110001001110000011000100111001", 123456789012345), # 6
-    ("010000110100111101001101010100000011000100111000001100010011100100100001", 123456789012345678), # 7
-    ("01000011010011110100110101010000001100010011100000110001001110010010000101000001", 1234567890123456789), # 8
-    ("0100001101001111010011010101000000110001001110000011000100111001001000010100000101000100", 1234567890123456789), # 9
-    ("010000110100111101001101010100000011000100111000001100010011100100100001010000010100010001010011", 12345678901234567890) # 10
+    ("0100001101001111", 999999),
+    ("01000011010011110100110101010000", 999999),
+    ("1111111111111111111111111111111111111111", 999999),
+    ("010000110100111101001101010100000011000100111000", 999999999),
+    ("01000011010011110100110101010000001100010011100000110001", 123456789012),
+    ("0100001101001111010011010101000000110001001110000011000100111001", 123456789012345),
+    ("010000110100111101001101010100000011000100111000001100010011100100100001", 123456789012345678),
+    ("01000011010011110100110101010000001100010011100000110001001110010010000101000001", 1234567890123456789),
+    ("0100001101001111010011010101000000110001001110000011000100111001001000010100000101000100", 1234567890123456789),
+    ("010000110100111101001101010100000011000100111000001100010011100100100001010000010100010001010011", 12345678901234567890),
 ]
 
-# Store execution times and results for each solution
+# Store execution times
 execution_times_sol1 = []
 execution_times_sol2 = []
 execution_times_sol3 = []
@@ -25,41 +44,42 @@
 # Run performance tests
 for idx, (binary_str, n) in enumerate(test_cases):
     print(f"Test Case {idx + 1}")
+    
+    result, time_sol1 = run_case(binary_str, n, sol1, "Solution 1")
+    execution_times_sol1.append(time_sol1)
+    print(result)
 
-    # Solution 1
-    start_time = time.time()
-    output_sol1 = sol1.extract_primes(binary_str, n)
-    elapsed_time_sol1 = time.time() - start_time
-    execution_times_sol1.append(elapsed_time_sol1)
-    print(f"Solution 1 - trail only:\n  Time taken: {elapsed_time_sol1:.6f}s\n  Answer: {output_sol1}")
+    result, time_sol2 = run_case(binary_str, n, sol2, "Solution 2")
+    execution_times_sol2.append(time_sol2)
+    print(result)
 
-    # Solution 2
-    start_time = time.time()
-    output_sol2 = sol2.extract_primes(binary_str, n)
-    elapsed_time_sol2 = time.time() - start_time
-    execution_times_sol2.append(elapsed_time_sol2)
-    print(f"Solution 2 -sieve only:\n  Time taken: {elapsed_time_sol2:.6f}s\n  Answer: {output_sol2}")
-
-    # Solution2 - old version BAD
-    start_time = time.time()
-    output_sol3 = sol3.extract_primes(binary_str, n)
-    elapsed_time_sol3 = time.time() - start_time
-    execution_times_sol3.append(elapsed_time_sol3)
-    print(f"Solution 2- the holy trinity:\n  Time taken: {elapsed_time_sol3:.6f}s\n  Answer: {output_sol3}\n")
+    result, time_sol3 = run_case(binary_str, n, sol3, "Solution 2 - holy trinity")
+    execution_times_sol3.append(time_sol3)
+    print(result)
 
 # Plot execution times
 plt.figure(figsize=(10, 5))
-plt.plot(test_case_indices, execution_times_sol1, marker='o', linestyle='-', label="Solution 1- trial only")
-plt.plot(test_case_indices, execution_times_sol2, marker='s', linestyle='--', label="Solution 2 - sieve only")
-plt.plot(test_case_indices, execution_times_sol3, marker='d', linestyle='-.', label="Solution 2- the holy trinity")
+plt.plot(test_case_indices, execution_times_sol1, marker='o', linestyle='-', label="Solution 1")
+plt.plot(test_case_indices, execution_times_sol2, marker='s', linestyle='--', label="Solution 2")
+plt.plot(test_case_indices, execution_times_sol3, marker='d', linestyle='-.', label="Solution 2 - the holy trinity")
+
+plt.xlabel("Test Case Number")
+plt.ylabel("Execution Time (s)")
+plt.title("Execution Time Comparison: Solution 1, 2, and 3")
+plt.xticks(test_case_indices)
+plt.grid(True)
+plt.legend()
+plt.show()
+
+# Plot execution times for only Solution 2 - holy trinity
+plt.figure(figsize=(10, 5))
+plt.plot(test_case_indices, execution_times_sol3, marker='d', linestyle='-.', color='r', label="Solution 2 - the holy trinity")
 
-# Labels and title
 plt.xlabel("Test Case Number")
 plt.ylabel("Execution Time (s)")
-plt.title("Performance of extract_primes Function Across Test Cases")
+plt.title("Execution Time: Solution 2 - The Holy Trinity")
 plt.xticks(test_case_indices)
 plt.grid(True)
 plt.legend()
+plt.show()
 
-# Show the plot
-plt.show() 

__pycache__/sol3.cpython-313.pyc

@@ -1,59 +1,59 @@
-import math,random 
-def sieve_segment(low, high):
-    sieve_range = high - low + 1
-    is_prime = [True] * sieve_range
+import math,random # built-in libs, allowed by spec
+def sieve_segment(low, high): # sieve is going to gen numbers from x to y instead of 1 to n
+    sieve_range = high - low + 1 
+    is_prime = [True] * sieve_range # this will set all numbers to prime
     if low == 1: is_prime[0] = False
     limit = int(math.sqrt(high))
-    small_primes = sieve_upto(limit)[1]
-    for prime in small_primes:
-        start = max(prime * prime, low + (prime - low % prime) % prime)
-        for j in range(start, high + 1, prime):
+    small_primes = sieve_upto(limit)[1] # this will get the prime numbers
+    for prime in small_primes: # this will iterate through the prime numbers
+        start = max(prime * prime, low + (prime - low % prime) % prime) # this will get the start of the prime number
+        for j in range(start, high + 1, prime): 
             is_prime[j - low] = False
-    return is_prime, [low + i for i in range(sieve_range) if is_prime[i]]
-def sieve_upto(n):
+    return is_prime, [low + i for i in range(sieve_range) if is_prime[i]] # this will return the prime numbers
+def sieve_upto(n): # the main sieve function
     is_prime = [True] * (n + 1)
     is_prime[0] = is_prime[1] = False
     for i in range(2, int(n ** 0.5) + 1):
         if is_prime[i]:
             for j in range(i * i, n + 1, i):
                 is_prime[j] = False
     return is_prime, [x for x in range(2, n + 1) if is_prime[x]]
-def is_prime_trial(n):
+def is_prime_trial(n): # this is a simple trial division method to check if the number is prime
     if n < 2: return False
     if n in (2, 3): return True
     if n % 2 == 0 or n % 3 == 0: return False
-    limit = int(math.sqrt(n))
+    limit = int(math.sqrt(n)) # this will get the square root of the number and set the limit
     i = 5
     while i <= limit:
         if n % i == 0 or n % (i + 2) == 0: return False
         i += 6
     return True
-def is_prime_fermat(n, k=5):
+def is_prime_fermat(n, k=5): # this is the fermat primality test to check if the number is prime
     if n < 2: return False
     if n in (2, 3): return True
     if n % 2 == 0 or n % 3 == 0: return False
-    for _ in range(k):
+    for _ in range(k): # this will iterate through the number
         a = random.randint(2, n - 2)
         if pow(a, n - 1, n) != 1: return False
     return True
-def pollards_rho(n):
+def pollards_rho(n): # this is the pollards rho algorithm to check if the number is prime
     if n % 2 == 0: return 2
     x = random.randint(2, n - 1); y = x; c = random.randint(1, n - 1); d = 1
     def f(x): return (x * x + c) % n
-    while d == 1: x = f(x); y = f(f(y)); d = math.gcd(abs(x - y), n)
+    while d == 1: x = f(x); y = f(f(y)); d = math.gcd(abs(x - y), n) # using the greatest common divisor to check if the number is prime
     return d if d != n else None
-def is_prime_large(n):
+def is_prime_large(n): # this is the main function to check if the number is prime for a large N
     if is_prime_fermat(n): return True
     factor = pollards_rho(n)
     if factor and factor != n: return False
     return True
-def extract_primes(binary_str, N):
-    if not all(index in "01" for index in binary_str): return "0: Invalid binary strings"
-    if type(N) is not int: return "0: Invalid N given"
-    candidates = set()
+def extract_primes(binary_str, N): # the main function
+    if not all(index in "01" for index in binary_str): return "0: Invalid binary strings" # edge case : only 0 and 1 are allowed
+    if type(N) is not int: return "0: Invalid N given" # edge case : N must be an integer
+    candidates = set() # no dupes allowed
     length = len(binary_str)
     prefix = [0] * (length + 1)
-    for i in range(length):
+    for i in range(length): # this will convert the binary string to a decimal number
         prefix[i+1] = (prefix[i] << 1) + (binary_str[i] == '1')
     for start in range(length):
         for end in range(start + 1, length + 1):
@@ -62,25 +62,25 @@ def extract_primes(binary_str, N):
             if val > 1: candidates.add(val)
     if not candidates: return "No primes found."
     max_candidate = max(candidates)
-    TRIAL_THRESHOLD = 10_000
-    SIEVE_THRESHOLD = 10_000_000
+    TRIAL_THRESHOLD = 10_000 # this is the threshold for the trial division (balanced)
+    SIEVE_THRESHOLD = 10_000_000 # this is the threshold for the sieve (balanced)
     primes_found = []
     trial_checked = set()
-    for val in sorted(candidates):
-        if val <= TRIAL_THRESHOLD:
-            if is_prime_trial(val):
+    for val in sorted(candidates): # this will iterate through the candidates
+        if val <= TRIAL_THRESHOLD: # if the number is less than the threshold, then it will use the trial division
+            if is_prime_trial(val):  # if the number is prime, then it will add it to the list
                 primes_found.append(val)
             trial_checked.add(val)
-    medium_candidates = sorted(n for n in candidates if TRIAL_THRESHOLD < n <= SIEVE_THRESHOLD)
-    if medium_candidates:
-        low, high = min(medium_candidates), max(medium_candidates)
-        is_prime_segmented, primes_from_sieve = sieve_segment(low, high)
-        for val in medium_candidates:
-            if val - low >= 0 and is_prime_segmented[val - low]:
+    medium_candidates = sorted(n for n in candidates if TRIAL_THRESHOLD < n <= SIEVE_THRESHOLD) # this will get the medium candidates
+    if medium_candidates: # if there are medium candidates
+        low, high = min(medium_candidates), max(medium_candidates) # get the min and max of the medium candidates
+        is_prime_segmented, primes_from_sieve = sieve_segment(low, high)  # this will get the prime numbers from a limit
+        for val in medium_candidates: 
+            if val - low >= 0 and is_prime_segmented[val - low]: # if the number is prime, then it will add it to the list
                 primes_found.append(val)
-    for val in sorted(n for n in candidates if n > SIEVE_THRESHOLD):
+    for val in sorted(n for n in candidates if n > SIEVE_THRESHOLD): # if the number is greater than the threshold, then it will use the hybrid approach
         if is_prime_large(val):
-            primes_found.append(val)
+            primes_found.append(val) # if the number is prime, then it will add it to the list
     if not primes_found:
         return "No primes found."
     count = len(primes_found)
@@ -90,4 +90,5 @@ def extract_primes(binary_str, N):
         return (f"6: {primes_found[0]}, {primes_found[1]}, {primes_found[2]}, ..., "
                 f"{primes_found[-3]}, {primes_found[-2]}, {primes_found[-1]}")
 if __name__ == "__main__":
-    print(extract_primes(input("Enter binary string: "), int(input("Enter N: "))))
+    print(extract_primes(input("Enter binary string: "), int(input("Enter N: "))))
+    # Code made and maintained by Elias Andrew Ailenei (github.com/eliasailenei)