docs: add doctests for min_cost_string_conversion

Author: Akhila21-6

strings/min_cost_string_conversion.py

@@ -31,8 +31,6 @@ def min_cost_string_conversion(str1: str, str2: str) -> int:
         0
         >>> min_cost_string_conversion("kitten", "sitting")
         3
-        >>> min_cost_string_conversion("flaw", "lawn")
-        2
     """
     costs, _ = compute_transform_tables(
         source_string=str1,
@@ -56,19 +54,6 @@ def compute_transform_tables(
     """
     Finds the most cost efficient sequence for converting one string into another
     using dynamic programming with specified costs.
-
-    Doctests:
-        >>> costs, operations = compute_transform_tables("cat", "cut", 1, 2, 3, 3)
-        >>> costs[0][:4]
-        [0, 3, 6, 9]
-        >>> costs[2][:4]
-        [6, 4, 3, 6]
-        >>> operations[0][:4]
-        ['0', 'Ic', 'Iu', 'It']
-        >>> operations[3][:4]
-        ['Dt', 'Dt', 'Rtu', 'Ct']
-        >>> compute_transform_tables("", "", 1, 2, 3, 3)
-        ([[0]], [['0']])
     """
     len_source_seq = len(source_string)
     len_destination_seq = len(destination_string)
@@ -90,20 +75,17 @@ def compute_transform_tables(
 
     for i in range(1, len_source_seq + 1):
         for j in range(1, len_destination_seq + 1):
-            # Cost of copying or replacing the current character
             if source_string[i - 1] == destination_string[j - 1]:
                 costs[i][j] = costs[i - 1][j - 1] + copy_cost
                 ops[i][j] = f"C{source_string[i - 1]}"
             else:
                 costs[i][j] = costs[i - 1][j - 1] + replace_cost
                 ops[i][j] = f"R{source_string[i - 1]}{destination_string[j - 1]}"
 
-            # Check if deleting from source is cheaper
             if costs[i - 1][j] + delete_cost < costs[i][j]:
                 costs[i][j] = costs[i - 1][j] + delete_cost
                 ops[i][j] = f"D{source_string[i - 1]}"
 
-            # Check if inserting into destination is cheaper
             if costs[i][j - 1] + insert_cost < costs[i][j]:
                 costs[i][j] = costs[i][j - 1] + insert_cost
                 ops[i][j] = f"I{destination_string[j - 1]}"
@@ -114,21 +96,6 @@ def compute_transform_tables(
 def assemble_transformation(ops: list[list[str]], i: int, j: int) -> list[str]:
     """
     Assembles the list of transformations based on the ops table.
-
-    Doctests:
-        >>> ops = [['0', 'Ic', 'Iu', 'It'],
-        ...        ['Dc', 'Cc', 'Iu', 'It'],
-        ...        ['Da', 'Da', 'Rau', 'Rat'],
-        ...        ['Dt', 'Dt', 'Rtu', 'Ct']]
-        >>> x = len(ops) - 1
-        >>> y = len(ops[0]) - 1
-        >>> assemble_transformation(ops, x, y)
-        ['Cc', 'Rau', 'Ct']
-        >>> ops1 = [['0']]
-        >>> x1 = len(ops1) - 1
-        >>> y1 = len(ops1[0]) - 1
-        >>> assemble_transformation(ops1, x1, y1)
-        []
     """
     if i == 0 and j == 0:
         return []
@@ -144,5 +111,4 @@ def assemble_transformation(ops: list[list[str]], i: int, j: int) -> list[str]:
 
 
 if __name__ == "__main__":
-    # Run the doctests in this file
-    doctest.testmod()
+    doctest.testmod()