





'''simple docstring'''



def 			lowercase__(		_UpperCamelCase	:			list					)-> list:






					"""simple docstring"""

					if len(__lowercase					) < 2:
										return collection

					def circle_sort_util(_UpperCamelCase	:			list			, _UpperCamelCase	:			int			, _UpperCamelCase	:			int					) -> bool:
										_UpperCamelCase									= False

										if low == high:
															return swapped

										_UpperCamelCase									= low
										_UpperCamelCase									= high

										while left < right:
															if collection[left] > collection[right]:
																				_UpperCamelCase									= (
																				    collection[right],
																				    collection[left],
																				)
																				_UpperCamelCase									= True

															left += 1
															right -= 1

										if left == right and collection[left] > collection[right + 1]:
															_UpperCamelCase									= (
															    collection[right + 1],
															    collection[left],
															)

															_UpperCamelCase									= True

										_UpperCamelCase									= low + int((high - low) / 2					)
										_UpperCamelCase									= circle_sort_util(__lowercase			, __lowercase			, __lowercase					)
										_UpperCamelCase									= circle_sort_util(__lowercase			, mid + 1			, __lowercase					)

										return swapped or left_swap or right_swap

					_UpperCamelCase									= True

					while is_not_sorted is True:
										_UpperCamelCase									= circle_sort_util(__lowercase			, 0			, len(__lowercase					) - 1					)

					return collection


if __name__ == "__main__":
			snake_case_ :	Any             =   input('''Enter numbers separated by a comma:\n''').strip()
			snake_case_ :	List[str]             =   [int(item) for item in user_input.split(''',''')]
			print(circle_sort(unsorted))











def  a__ (__lowercase							:str					,  __lowercase							:str   )		-> float:

				def get_matched_characters(__lowercase							:str					,  __lowercase							:str   ) -> str:
								_A	:				Union[str, Any]   =      []
								_A	:				Dict   =      min(len(_stra   )					,  len(_stra   )   ) // 2
								for i, l in enumerate(_stra   ):
												_A	:				Tuple   =      int(max(0					,  i - limit   )   )
												_A	:				Union[str, Any]   =      int(min(i + limit + 1					,  len(_stra   )   )   )
												if l in _stra[left:right]:
																matched.append(__lowercase   )
																_A	:				List[Any]   =      f"""{_stra[0:_stra.index(__lowercase   )]} {_stra[_stra.index(__lowercase   ) + 1:]}"""

								return "".join(__lowercase   )

				# matching characters
				_A	:				str   =      get_matched_characters(__lowercase					,  __lowercase   )
				_A	:				Optional[Any]   =      get_matched_characters(__lowercase					,  __lowercase   )
				_A	:				Any   =      len(__lowercase   )

				# transposition
				_A	:				str   =      (
				    len([(ca, ca) for ca, ca in zip(__lowercase					,  __lowercase   ) if ca != ca]   ) // 2
				)

				if not match_count:
								_A	:				Optional[int]   =      0.0
				else:
								_A	:				str   =      (
								    1
								    / 3
								    * (
								        match_count / len(__lowercase   )
								        + match_count / len(__lowercase   )
								        + (match_count - transpositions) / match_count
								    )
								)

				# common prefix up to 4 characters
				_A	:				Any   =      0
				for ca, ca in zip(stra[:4]					,  stra[:4]   ):
								if ca == ca:
												prefix_len += 1
								else:
												break

				return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(jaro_winkler('hello', 'world'))



