

'''simple docstring'''





from __future__ import annotations



def  _A  (			SCREAMING_SNAKE_CASE			):
	if len(SCREAMING_SNAKE_CASE			) == 0:
		raise ValueError("find_max() arg is an empty sequence"			)
	UpperCAmelCase__:  Optional[int]		       =   nums[0]
	for x in nums:
		if x > max_num:
			UpperCAmelCase__:  int		       =   x
	return max_num


if __name__ == "__main__":
					import doctest

					doctest.testmod(verbose=True)


def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,):
	UpperCAmelCase__:  Tuple		       =   list(SCREAMING_SNAKE_CASE			)
	UpperCAmelCase__:  int		       =   list(SCREAMING_SNAKE_CASE			)
	UpperCAmelCase__:  Dict		       =   len(SCREAMING_SNAKE_CASE			)
	UpperCAmelCase__:  int		       =   len(SCREAMING_SNAKE_CASE			)

	UpperCAmelCase__:  Any		       =   [
	    [0 for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
	]
	UpperCAmelCase__:  List[Any]		       =   [
	    ["0" for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
	]

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

	for i in range(1  ,len_destination_seq + 1			):
		UpperCAmelCase__:  Union[str, Any]		       =   i * insert_cost
		UpperCAmelCase__:  Optional[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]:
				UpperCAmelCase__:  Any		       =   costs[i - 1][j - 1] + copy_cost
				UpperCAmelCase__:  Tuple		       =   f"C{source_seq[i - 1]:c}"
			else:
				UpperCAmelCase__:  Union[str, Any]		       =   costs[i - 1][j - 1] + replace_cost
				UpperCAmelCase__:  Optional[int]		       =   f"R{source_seq[i - 1]:c}" + str(destination_seq[j - 1]			)

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

			if costs[i][j - 1] + insert_cost < costs[i][j]:
				UpperCAmelCase__:  Any		       =   costs[i][j - 1] + insert_cost
				UpperCAmelCase__:  Tuple		       =   f"I{destination_seq[j - 1]:c}"

	return costs, ops



def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
	if i == 0 and j == 0:
		return []
	else:
		if ops[i][j][0] == "C" or ops[i][j][0] == "R":
			UpperCAmelCase__:  Union[str, Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,j - 1			)
			seq.append(ops[i][j]			)
			return seq
		elif ops[i][j][0] == "D":
			UpperCAmelCase__:  Optional[Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,SCREAMING_SNAKE_CASE			)
			seq.append(ops[i][j]			)
			return seq
		else:
			UpperCAmelCase__:  Dict		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,j - 1			)
			seq.append(ops[i][j]			)
			return seq


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

					_lowerCAmelCase     :			List[Any]    =len(operations)
					_lowerCAmelCase     :			Optional[int]    =len(operations[0])
					_lowerCAmelCase     :			Dict    =assemble_transformation(operations, m - 1, n - 1)

					_lowerCAmelCase     :			int    =list("""Python""")
					_lowerCAmelCase     :			Optional[int]    =0
					_lowerCAmelCase     :			List[Any]    =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":
																				_lowerCAmelCase     :			Tuple    =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))