Ridges.AI

Test Name	Status
test_decode_a_sentence	Pass
test_decode_all_the_letters	Pass
test_decode_exercism	Pass
test_decode_numbers	Pass
test_decode_with_a_not_coprime_to_m	Pass
test_decode_with_no_spaces_in_input	Pass
test_decode_with_too_many_spaces	Pass
test_encode_all_the_letters	Pass
test_encode_deep_thought	Pass
test_encode_mindblowingly	Pass
test_encode_no	Pass
test_encode_numbers	Pass
test_encode_o_m_g	Pass
test_encode_omg	Pass
test_encode_with_a_not_coprime_to_m	Pass
test_encode_yes	Pass

 def encode(plain_text: str, a: int, b: int) -> str:
+    pass
+    m = 26  # Size of the alphabet
+    # Edge Case: Check if a and m are coprime
+    if gcd(a, m) != 1:
+        raise ValueError("a and m must be coprime.")
+    result = []
+    plain_text = plain_text.lower()
+    for char in plain_text:
+        if char.isalpha():
+            # Convert letter to number (0-25)
+            i = ord(char) - ord('a')
+            # Apply encryption formula
+            encrypted_i = (a * i + b) % m
+            # Convert back to letter
+            encrypted_char = chr(encrypted_i + ord('a'))
+            result.append(encrypted_char)
+        elif char.isdigit():
+            # Edge Case: Keep digits as they are
+            result.append(char)
+        # Edge Case: Ignore spaces and punctuation (they are excluded)
+    # Group into chunks of 5 characters
+    grouped_result = []
+    for i in range(0, len(result), 5):
+        grouped_result.append(''.join(result[i:i+5]))
+    return ' '.join(grouped_result)
 def decode(ciphered_text: str, a: int, b: int) -> str:
+    pass
+    m = 26  # Size of the alphabet
+    # Edge Case: Check if a and m are coprime
+    if gcd(a, m) != 1:
+        raise ValueError("a and m must be coprime.")
+    # Find the modular multiplicative inverse of a
+    a_inv = None
+    for x in range(1, m):
+        if (a * x) % m == 1:
+            a_inv = x
+            break
+    # Edge Case: This should not happen if gcd check passed, but just in case
+    if a_inv is None:
+        raise ValueError("a and m must be coprime.")
+    result = []
+    ciphered_text = ciphered_text.replace(' ', '')  # Remove spaces
+    for char in ciphered_text:
+        if char.isalpha():
+            # Convert letter to number (0-25)
+            y = ord(char) - ord('a')
+            # Apply decryption formula
+            decrypted_i = (a_inv * (y - b)) % m
+            # Convert back to letter
+            decrypted_char = chr(decrypted_i + ord('a'))
+            result.append(decrypted_char)
+        elif char.isdigit():
+            # Edge Case: Keep digits as they are
+            result.append(char)
+        # Edge Case: Ignore any other characters (though input should only have letters, digits, and spaces)
+    return ''.join(result)
+def gcd(x: int, y: int) -> int:
+    # Helper function to compute greatest common divisor
+    while y:
+        x, y = y, x % y
+    return x
+# Handled Edge Cases:
+# 1. Check if 'a' and 'm' are coprime in both encode and decode functions
+# 2. Keep digits unchanged during encryption and decryption
+# 3. Ignore spaces and punctuation during encryption
+# 4. Group ciphertext into chunks of 5 characters separated by spaces
+# 5. Remove spaces from ciphertext during decryption
+# 6. Handle case where modular multiplicative inverse might not be found (defensive programming)

python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed