def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      )	->	tuple[list[list[int]], list[list[str]]]:
     a  :    int				=						list(lowerCAmelCase_       )
     a  :    Any				=						list(lowerCAmelCase_       )
     a  :    int				=						len(lowerCAmelCase_       )
     a  :    List[Any]				=						len(lowerCAmelCase_       )

     a  :    str				=						[
         [0 for _ in range(len_destination_seq + 1       )] for _ in range(len_source_seq + 1       )
     ]
     a  :    Optional[int]				=						[
         ['''0''' for _ in range(len_destination_seq + 1       )] for _ in range(len_source_seq + 1       )
     ]

     for i in range(1						,      len_source_seq + 1       ):
          a  :    Dict				=						i * delete_cost
          a  :    List[Any]				=						f"""D{source_seq[i - 1]:c}"""

     for i in range(1						,      len_destination_seq + 1       ):
          a  :    str				=						i * insert_cost
          a  :    List[Any]				=						f"""I{destination_seq[i - 1]:c}"""

     for i in range(1						,      len_source_seq + 1       ):
          for j in range(1						,      len_destination_seq + 1       ):
               if source_seq[i - 1] == destination_seq[j - 1]:
                    a  :    int				=						costs[i - 1][j - 1] + copy_cost
                    a  :    Union[str, Any]				=						f"""C{source_seq[i - 1]:c}"""
               else:
                    a  :    Any				=						costs[i - 1][j - 1] + replace_cost
                    a  :    int				=						f"""R{source_seq[i - 1]:c}""" + str(destination_seq[j - 1]       )

               if costs[i - 1][j] + delete_cost < costs[i][j]:
                    a  :    Any				=						costs[i - 1][j] + delete_cost
                    a  :    int				=						f"""D{source_seq[i - 1]:c}"""

               if costs[i][j - 1] + insert_cost < costs[i][j]:
                    a  :    Dict				=						costs[i][j - 1] + insert_cost
                    a  :    Union[str, Any]				=						f"""I{destination_seq[j - 1]:c}"""

     return costs, ops







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	list[str]:
     if i == 0 and j == 0:
          return []
     else:
          if ops[i][j][0] == "C" or ops[i][j][0] == "R":
               a  :    Optional[Any]				=						assemble_transformation(lowerCAmelCase_						,      i - 1						,      j - 1       )
               seq.append(ops[i][j]       )
               return seq
          elif ops[i][j][0] == "D":
               a  :    Optional[int]				=						assemble_transformation(lowerCAmelCase_						,      i - 1						,      lowerCAmelCase_       )
               seq.append(ops[i][j]       )
               return seq
          else:
               a  :    Union[str, Any]				=						assemble_transformation(lowerCAmelCase_						,      lowerCAmelCase_						,      j - 1       )
               seq.append(ops[i][j]       )
               return seq


if __name__ == "__main__":
  UpperCAmelCase   ,  UpperCAmelCase							   =      compute_transform_tables("""Python""", """Algorithms""", -1, 1, 2, 2)

  UpperCAmelCase							   =      len(operations)
  UpperCAmelCase							   =      len(operations[0])
  UpperCAmelCase							   =      assemble_transformation(operations, m - 1, n - 1)

  UpperCAmelCase							   =      list("""Python""")
  UpperCAmelCase							   =      0
  UpperCAmelCase							   =      0

  with open("""min_cost.txt""", """w""") as file:
    for op in sequence:
      print("""""".join(string))

      if op[0] == "C":
        file.write("""%-16s""" % """Copy %c""" % op[1])
        file.write("""\t\t\t""" + """""".join(string))
        file.write("""\r\n""")

        cost -= 1
      elif op[0] == "R":
        UpperCAmelCase							   =      op[2]

        file.write("""%-16s""" % ("""Replace %c""" % op[1] + """ with """ + str(op[2])))
        file.write("""\t\t""" + """""".join(string))
        file.write("""\r\n""")

        cost += 1
      elif op[0] == "D":
        string.pop(i)

        file.write("""%-16s""" % """Delete %c""" % op[1])
        file.write("""\t\t\t""" + """""".join(string))
        file.write("""\r\n""")

        cost += 2
      else:
        string.insert(i, op[1])

        file.write("""%-16s""" % """Insert %c""" % op[1])
        file.write("""\t\t\t""" + """""".join(string))
        file.write("""\r\n""")

        cost += 2

      i += 1

    print("""""".join(string))
    print("""Cost: """, cost)

    file.write("""\r\nMinimum cost: """ + str(cost))
from __future__ import annotations

UpperCAmelCase							   =      [2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]






class 							_SCREAMING_SNAKE_CASE:
   def __init__(    self							,     lowerCAmelCase_    )	->None:
        a  :    int				=						-1
        a  :    int				=						-1
        a  :    list[int]				=						[-1] * length
        a  :    Node | None				=						None
        a  :    Node | None				=						None


   def __repr__(    self    )	->str:
        return F"""Node(min_value={self.minn} max_value={self.maxx})"""







def 	UpperCAmelCase       (		lowerCAmelCase_       )	->	Node | None:
     a  :    Dict				=						Node(len(lowerCAmelCase_       )       )
     a			,							a  :    Tuple				=						min(lowerCAmelCase_       ), max(lowerCAmelCase_       )
     # Leaf node case where the node contains only one unique value
     if root.minn == root.maxx:
          return root
     a  :    Optional[Any]				=						(root.minn + root.maxx) // 2

     a  :    list[int]				=						[]
     a  :    list[int]				=						[]

     for index, num in enumerate(lowerCAmelCase_       ):
          if num <= pivot:
               left_arr.append(lowerCAmelCase_       )
          else:
               right_arr.append(lowerCAmelCase_       )
          a  :    int				=						len(lowerCAmelCase_       )
     a  :    List[str]				=						build_tree(lowerCAmelCase_       )
     a  :    List[str]				=						build_tree(lowerCAmelCase_       )
     return root







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	int:
     if index < 0 or node is None:
          return 0
     # Leaf node cases
     if node.minn == node.maxx:
          return index + 1 if node.minn == num else 0
     a  :    List[Any]				=						(node.minn + node.maxx) // 2
     if num <= pivot:
          # go the left subtree and map index to the left subtree
          return rank_till_index(node.left						,      lowerCAmelCase_						,      node.map_left[index] - 1       )
     else:
          # go to the right subtree and map index to the right subtree
          return rank_till_index(node.right						,      lowerCAmelCase_						,      index - node.map_left[index]       )







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	int:
     if start > end:
          return 0
     a  :    Optional[Any]				=						rank_till_index(lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )
     a  :    Any				=						rank_till_index(lowerCAmelCase_						,      lowerCAmelCase_						,      start - 1       )
     return rank_till_end - rank_before_start







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	int:
     if index > (end - start) or start > end or node is None:
          return -1
     # Leaf node case
     if node.minn == node.maxx:
          return node.minn
     # Number of elements in the left subtree in interval [start, end]
     a  :    Optional[int]				=						node.map_left[end] - (
         node.map_left[start - 1] if start else 0
     )
     if num_elements_in_left_tree > index:
          return quantile(
              node.left						,      lowerCAmelCase_						,      (node.map_left[start - 1] if start else 0)						,      node.map_left[end] - 1						,      )
     else:
          return quantile(
              node.right						,      index - num_elements_in_left_tree						,      start - (node.map_left[start - 1] if start else 0)						,      end - node.map_left[end]						,      )







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	int:
     if (
         start > end
         or node is None
         or start_num > end_num
         or node.minn > end_num
         or node.maxx < start_num
     ):
          return 0
     if start_num <= node.minn and node.maxx <= end_num:
          return end - start + 1
     a  :    Tuple				=						range_counting(
         node.left						,      (node.map_left[start - 1] if start else 0)						,      node.map_left[end] - 1						,      lowerCAmelCase_						,      lowerCAmelCase_						,      )
     a  :    int				=						range_counting(
         node.right						,      start - (node.map_left[start - 1] if start else 0)						,      end - node.map_left[end]						,      lowerCAmelCase_						,      lowerCAmelCase_						,      )
     return left + right


if __name__ == "__main__":
  import doctest

  doctest.testmod()