



def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   )			->			tuple[list[list[int]], list[list[str]]]:



						'''simple docstring'''






						UpperCAmelCase_					=	list(__UpperCAmelCase      )
						UpperCAmelCase_					=	list(__UpperCAmelCase      )
						UpperCAmelCase_					=	len(__UpperCAmelCase      )
						UpperCAmelCase_					=	len(__UpperCAmelCase      )

						UpperCAmelCase_					=	[
						    [0 for _ in range(len_destination_seq + 1      )] for _ in range(len_source_seq + 1      )
						]
						UpperCAmelCase_					=	[
						    ['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_					=	i * delete_cost
												UpperCAmelCase_					=	f"D{source_seq[i - 1]:c}"

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

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

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

						return costs, ops







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			list[str]:



						'''simple docstring'''






						if i == 0 and j == 0:
												return []
						else:
												if ops[i][j][0] == "C" or ops[i][j][0] == "R":
																		UpperCAmelCase_					=	assemble_transformation(__UpperCAmelCase				,   i - 1				,   j - 1      )
																		seq.append(ops[i][j]      )
																		return seq
												elif ops[i][j][0] == "D":
																		UpperCAmelCase_					=	assemble_transformation(__UpperCAmelCase				,   i - 1				,   __UpperCAmelCase      )
																		seq.append(ops[i][j]      )
																		return seq
												else:
																		UpperCAmelCase_					=	assemble_transformation(__UpperCAmelCase				,   __UpperCAmelCase				,   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))








def _a					(			SCREAMING_SNAKE_CASE						:     int						)       ->       int:

 """simple docstring"""






 return n * (2 * n - 1)







def _a					(			SCREAMING_SNAKE_CASE						:     int						)       ->       bool:

 """simple docstring"""






 __lowerCAmelCase:  List[Any]        = (1 + 24 * n) ** 0.5
 return ((1 + root) / 6) % 1 == 0







def _a					(			SCREAMING_SNAKE_CASE						:     int = 1_44						)       ->       int:

 """simple docstring"""






 __lowerCAmelCase:  Dict        = start
 __lowerCAmelCase:  List[str]        = hexagonal_num(SCREAMING_SNAKE_CASE						)
 while not is_pentagonal(SCREAMING_SNAKE_CASE						):
  n += 1
  __lowerCAmelCase:  Any        = hexagonal_num(SCREAMING_SNAKE_CASE						)
 return num


if __name__ == "__main__":
  print(f"{solution()} = ")





