code: 
  
  '''simple docstring'''
  
  
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if right <= left:
  		return
  	UpperCAmelCase__:  List[Any]		       =   left
  	UpperCAmelCase__:  Optional[Any]		       =   right
  	UpperCAmelCase__:  Union[str, Any]		       =   sorting[left]
  	while i <= b:
  		if sorting[i] < pivot:
  			UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   sorting[i], sorting[a]
  			a += 1
  			i += 1
  		elif sorting[i] > pivot:
  			UpperCAmelCase__       ,	UpperCAmelCase__:  Optional[int]		       =   sorting[i], sorting[b]
  			b -= 1
  		else:
  			i += 1
  	quick_sort_apartition(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,a - 1			)
  	quick_sort_apartition(SCREAMING_SNAKE_CASE  ,b + 1  ,SCREAMING_SNAKE_CASE			)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if left < right:
  		UpperCAmelCase__:  Optional[Any]		       =   lomuto_partition(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  		quick_sort_lomuto_partition(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,pivot_index - 1			)
  		quick_sort_lomuto_partition(SCREAMING_SNAKE_CASE  ,pivot_index + 1  ,SCREAMING_SNAKE_CASE			)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Tuple		       =   sorting[right]
  	UpperCAmelCase__:  List[Any]		       =   left
  	for i in range(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  		if sorting[i] < pivot:
  			UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   sorting[i], sorting[store_index]
  			store_index += 1
  	UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   sorting[store_index], sorting[right]
  	return store_index
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	if len(SCREAMING_SNAKE_CASE			) <= 1:
  		return sorting
  	return (
  	    three_way_radix_quicksort([i for i in sorting if i < sorting[0]]			)
  	    + [i for i in sorting if i == sorting[0]]
  	    + three_way_radix_quicksort([i for i in sorting if i > sorting[0]]			)
  	)
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod(verbose=True)
  
  					_lowerCAmelCase     :			Any    =input("""Enter numbers separated by a comma:\n""").strip()
  					_lowerCAmelCase     :			Union[str, Any]    =[int(item) for item in user_input.split(""",""")]
  					quick_sort_apartition(unsorted, 0, len(unsorted) - 1)
  					print(unsorted)
style_context: 
  
  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))