code: 
  """simple docstring"""
  
  
  
  
  
  def 			__a  (	__lowerCamelCase						):
     UpperCAmelCase_      :      Optional[int]      =					len(__lowerCamelCase						)
     for cycle_start in range(0,	array_len - 1						):
        UpperCAmelCase_      :      str      =					array[cycle_start]
  
        UpperCAmelCase_      :      str      =					cycle_start
        for i in range(cycle_start + 1,	__lowerCamelCase						):
           if array[i] < item:
              pos += 1
  
        if pos == cycle_start:
           continue
  
        while item == array[pos]:
           pos += 1
  
        UpperCAmelCase_      :      Optional[Any]      =					item, array[pos]
        while pos != cycle_start:
           UpperCAmelCase_      :      Tuple      =					cycle_start
           for i in range(cycle_start + 1,	__lowerCamelCase						):
              if array[i] < item:
                 pos += 1
  
           while item == array[pos]:
              pos += 1
  
           UpperCAmelCase_      :      Optional[int]      =					item, array[pos]
  
     return array
  
  
  if __name__ == "__main__":
      assert cycle_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
      assert cycle_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]
  
  
  
style_context: 
  """simple docstring"""
  
  
  
  
  
  from __future__ import annotations
  
  from statistics import mean
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase						):
     UpperCAmelCase_      :      Dict      =					2
     UpperCAmelCase_      :      Any      =					list(__lowerCamelCase						)
     UpperCAmelCase_      :      List[Any]      =					[0] * len(__lowerCamelCase						)
     UpperCAmelCase_      :      str      =					0
     while True:
        UpperCAmelCase_      :      int      =					True
        for i, burst_time in enumerate(__lowerCamelCase						):
           if rem_burst_times[i] > 0:
              UpperCAmelCase_      :      List[Any]      =					False
              if rem_burst_times[i] > quantum:
                 t += quantum
                 rem_burst_times[i] -= quantum
              else:
                 t += rem_burst_times[i]
                 UpperCAmelCase_      :      Optional[int]      =					t - burst_time
                 UpperCAmelCase_      :      Union[str, Any]      =					0
        if done is True:
           return waiting_times
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase						):
     return [burst + waiting for burst, waiting in zip(__lowerCamelCase,	__lowerCamelCase						)]
  
  
  if __name__ == "__main__":
      _a	 =							[3, 5, 7]
      _a	 =							calculate_waiting_times(burst_times)
      _a	 =							calculate_turn_around_times(burst_times, waiting_times)
      print('Process ID \tBurst Time \tWaiting Time \tTurnaround Time')
      for i, burst_time in enumerate(burst_times):
          print(
              f"""  {i + 1}\t\t  {burst_time}\t\t  {waiting_times[i]}\t\t  """
              f"""{turn_around_times[i]}"""
          )
      print(f"""\nAverage waiting time = {mean(waiting_times):.5f}""")
      print(f"""Average turn around time = {mean(turn_around_times):.5f}""")
  
  
  