






'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




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

      return "".join(_UpperCamelCase							)

   # matching characters
   lowercase_	:    int           =     get_matched_characters(_UpperCamelCase						,		_UpperCamelCase							)
   lowercase_	:    List[str]           =     get_matched_characters(_UpperCamelCase						,		_UpperCamelCase							)
   lowercase_	:    Union[str, Any]           =     len(_UpperCamelCase							)

   # transposition
   lowercase_	:    Union[str, Any]           =     (
       len([(ca, ca) for ca, ca in zip(_UpperCamelCase						,		_UpperCamelCase							) if ca != ca]							) // 2
   )

   if not match_count:
      lowercase_	:    Tuple           =     0.0
   else:
      lowercase_	:    Tuple           =     (
          1
          / 3
          * (
              match_count / len(_UpperCamelCase							)
              + match_count / len(_UpperCamelCase							)
              + (match_count - transpositions) / match_count
          )
      )

   # common prefix up to 4 characters
   lowercase_	:    Union[str, 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'))












'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Any           =     False
   while is_sorted is False:  # Until all the indices are traversed keep looping
      lowercase_	:    List[str]           =     True
      for i in range(0						,		len(_UpperCamelCase							) - 1						,		2							):  # iterating over all even indices
         if input_list[i] > input_list[i + 1]:
            lowercase_    ,		lowercase_	:    Union[str, Any]           =     input_list[i + 1], input_list[i]
            # swapping if elements not in order
            lowercase_	:    Any           =     False

      for i in range(1						,		len(_UpperCamelCase							) - 1						,		2							):  # iterating over all odd indices
         if input_list[i] > input_list[i + 1]:
            lowercase_    ,		lowercase_	:    Tuple           =     input_list[i + 1], input_list[i]
            # swapping if elements not in order
            lowercase_	:    List[Any]           =     False
   return input_list


if __name__ == "__main__":
 print('Enter list to be sorted')
 UpperCamelCase__ =			[int(x) for x in input().split()]
 # inputing elements of the list in one line
 UpperCamelCase__ =			odd_even_sort(input_list)
 print('The sorted list is')
 print(sorted_list)




