'''simple docstring'''






from statistics import mean

import numpy as np






def  UpperCamelCase__					(					_lowercase    :				list   ,    _lowercase    :				list   ,    _lowercase    :				list   ,    _lowercase    :				int     )							->	list:
  __UpperCAmelCase:					List[Any]		= 0
  # Number of processes finished
  __UpperCAmelCase:					Optional[int]		= 0
  # Displays the finished process.
  # If it is 0, the performance is completed if it is 1, before the performance.
  __UpperCAmelCase:					Tuple		= [0] * no_of_process
  # List to include calculation results
  __UpperCAmelCase:					List[str]		= [0] * no_of_process

  # Sort by arrival time.
  __UpperCAmelCase:					Union[str, Any]		= [burst_time[i] for i in np.argsort(_lowercase     )]
  __UpperCAmelCase:					Union[str, Any]		= [process_name[i] for i in np.argsort(_lowercase     )]
  arrival_time.sort()

  while no_of_process > finished_process_count:
    __UpperCAmelCase:					List[Any]		= 0
    while finished_process[i] == 1:
      i += 1
    if current_time < arrival_time[i]:
      __UpperCAmelCase:					List[Any]		= arrival_time[i]

    __UpperCAmelCase:					List[Any]		= 0
    # Index showing the location of the process being performed
    __UpperCAmelCase:					int		= 0
    # Saves the current response ratio.
    __UpperCAmelCase:					Tuple		= 0
    for i in range(0   ,    _lowercase     ):
      if finished_process[i] == 0 and arrival_time[i] <= current_time:
        __UpperCAmelCase:					List[Any]		= (burst_time[i] + (current_time - arrival_time[i])) / burst_time[
            i
        ]
      if response_ratio < temp:
        __UpperCAmelCase:					Union[str, Any]		= temp
        __UpperCAmelCase:					str		= i

        # Calculate the turn around time
    __UpperCAmelCase:					Optional[Any]		= current_time + burst_time[loc] - arrival_time[loc]
    current_time += burst_time[loc]
    # Indicates that the process has been performed.
    __UpperCAmelCase:					str		= 1
    # Increase finished_process_count by 1
    finished_process_count += 1

  return turn_around_time






def  UpperCamelCase__					(					_lowercase    :				list   ,    _lowercase    :				list   ,    _lowercase    :				list   ,    _lowercase    :				int     )							->	list:
  __UpperCAmelCase:					Optional[int]		= [0] * no_of_process
  for i in range(0   ,    _lowercase     ):
    __UpperCAmelCase:					Union[str, Any]		= turn_around_time[i] - burst_time[i]
  return waiting_time


if __name__ == "__main__":
    SCREAMING_SNAKE_CASE_	   =			5
    SCREAMING_SNAKE_CASE_	   =			['A', 'B', 'C', 'D', 'E']
    SCREAMING_SNAKE_CASE_	   =			[1, 2, 3, 4, 5]
    SCREAMING_SNAKE_CASE_	   =			[1, 2, 3, 4, 5]

    SCREAMING_SNAKE_CASE_	   =			calculate_turn_around_time(
        process_name, arrival_time, burst_time, no_of_process
    )
    SCREAMING_SNAKE_CASE_	   =			calculate_waiting_time(
        process_name, turn_around_time, burst_time, no_of_process
    )

    print('Process name \tArrival time \tBurst time \tTurn around time \tWaiting time')
    for i in range(0, no_of_process):
        print(
            F"""{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t"""
            F"""{turn_around_time[i]}\t\t\t{waiting_time[i]}"""
        )

    print(F"""average waiting time : {mean(waiting_time):.5f}""")
    print(F"""average turn around time : {mean(turn_around_time):.5f}""")
'''simple docstring'''






def  UpperCamelCase__					(					_lowercase    :				list     )							->	list:
  if len(_lowercase     ) <= 1:
    return lst

  __UpperCAmelCase:					List[str]		= 1

  while i < len(_lowercase     ):
    if lst[i - 1] <= lst[i]:
      i += 1
    else:
      __UpperCAmelCase, __UpperCAmelCase:					Tuple		= lst[i], lst[i - 1]
      i -= 1
      if i == 0:
        __UpperCAmelCase:					List[str]		= 1

  return lst


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