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 = []
+    char_count = 0
+    for char in plain_text:
+        # Edge Case: Ignore non-alphanumeric characters
+        if not char.isalnum():
+            continue
+        if char.isalpha():
+            # Convert to lowercase
+            char = char.lower()
+            # Get the index (0-25)
+            i = ord(char) - ord('a')
+            # Apply encryption formula
+            encrypted_index = (a * i + b) % m
+            # Convert back to character
+            encrypted_char = chr(encrypted_index + ord('a'))
+            result.append(encrypted_char)
+            char_count += 1
+        elif char.isdigit():
+            # Edge Case: Keep digits as they are
+            result.append(char)
+            char_count += 1
+        # Edge Case: Add space after every 5 characters
+        if char_count % 5 == 0 and char_count > 0:
+            result.append(' ')
+    # Edge Case: Remove trailing space if present
+    if result and result[-1] == ' ':
+        result.pop()
+    return ''.join(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(a, m) == 1, but just in case
+    if a_inv is None:
+        raise ValueError("Cannot find modular multiplicative inverse.")
+    result = []
+    for char in ciphered_text:
+        # Edge Case: Ignore spaces and non-alphanumeric characters
+        if not char.isalnum():
+            continue
+        if char.isalpha():
+            # Convert to lowercase
+            char = char.lower()
+            # Get the index (0-25)
+            y = ord(char) - ord('a')
+            # Apply decryption formula
+            decrypted_index = (a_inv * (y - b)) % m
+            # Convert back to character
+            decrypted_char = chr(decrypted_index + ord('a'))
+            result.append(decrypted_char)
+        elif char.isdigit():
+            # Edge Case: Keep digits as they are
+            result.append(char)
+    return ''.join(result)
+def gcd(a: int, b: int) -> int:
+    # Edge Case: Handle negative numbers by taking absolute values
+    a, b = abs(a), abs(b)
+    while b:
+        a, b = b, a % b
+    return a
+# Handled Edge Cases:
+# - Check if a and m are coprime in both encode and decode
+# - Ignore non-alphanumeric characters in both encode and decode
+# - Convert uppercase letters to lowercase
+# - Keep digits unchanged
+# - Add space after every 5 characters in encode
+# - Remove trailing space in encode
+# - Handle negative numbers in gcd function
+# - Raise ValueError when modular multiplicative inverse cannot be found

python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed