

from __future__ import annotations

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  list  ,      lowerCAmelCase:  int  ,      lowerCAmelCase:  int  ,      lowerCAmelCase:  int )   ->       list:
				_UpperCAmelCase       :		str 		=    []
				_UpperCAmelCase       :		Any 		=    input_list[low:mid], input_list[mid : high + 1]
				while left and right:
								result.append((left if left[0] <= right[0] else right).pop(0 ) )
				_UpperCAmelCase       :		Any 		=    result + left + right
				return input_list

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  list )   ->       list:
				if len(lowerCAmelCase ) <= 1:
								return input_list
				_UpperCAmelCase       :		List[Any] 		=    list(lowerCAmelCase )

				# iteration for two-way merging
				_UpperCAmelCase       :		List[Any] 		=    2
				while p <= len(lowerCAmelCase ):
								# getting low, high and middle value for merge-sort of single list
								for i in range(0  ,      len(lowerCAmelCase )  ,      lowerCAmelCase ):
												_UpperCAmelCase       :		Union[str, Any] 		=    i
												_UpperCAmelCase       :		Optional[int] 		=    i + p - 1
												_UpperCAmelCase       :		Union[str, Any] 		=    (low + high + 1) // 2
												_UpperCAmelCase       :		Any 		=    merge(lowerCAmelCase  ,      lowerCAmelCase  ,      lowerCAmelCase  ,      lowerCAmelCase )
								# final merge of last two parts
								if p * 2 >= len(lowerCAmelCase ):
												_UpperCAmelCase       :		Tuple 		=    i
												_UpperCAmelCase       :		List[str] 		=    merge(lowerCAmelCase  ,      0  ,      lowerCAmelCase  ,      len(lowerCAmelCase ) - 1 )
												break
								p *= 2

				return input_list


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





from __future__ import annotations

import pandas as pd

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  list[int]  ,      lowerCAmelCase:  list[int]  ,      lowerCAmelCase:  int )   ->       list[int]:
				_UpperCAmelCase       :		List[Any] 		=    [0] * no_of_processes
				_UpperCAmelCase       :		Dict 		=    [0] * no_of_processes
				# Copy the burst time into remaining_time[]
				for i in range(lowerCAmelCase ):
								_UpperCAmelCase       :		List[str] 		=    burst_time[i]

				_UpperCAmelCase       :		Any 		=    0
				_UpperCAmelCase       :		Union[str, Any] 		=    0
				_UpperCAmelCase       :		str 		=    9_9999_9999
				_UpperCAmelCase       :		List[Any] 		=    0
				_UpperCAmelCase       :		Any 		=    False

				# Process until all processes are completed
				while complete != no_of_processes:
								for j in range(lowerCAmelCase ):
												if arrival_time[j] <= increment_time and remaining_time[j] > 0:
																if remaining_time[j] < minm:
																				_UpperCAmelCase       :		Optional[int] 		=    remaining_time[j]
																				_UpperCAmelCase       :		int 		=    j
																				_UpperCAmelCase       :		Tuple 		=    True

								if not check:
												increment_time += 1
												continue
								remaining_time[short] -= 1

								_UpperCAmelCase       :		List[Any] 		=    remaining_time[short]
								if minm == 0:
												_UpperCAmelCase       :		List[Any] 		=    9_9999_9999

								if remaining_time[short] == 0:
												complete += 1
												_UpperCAmelCase       :		int 		=    False

												# Find finish time of current process
												_UpperCAmelCase       :		Optional[int] 		=    increment_time + 1

												# Calculate waiting time
												_UpperCAmelCase       :		str 		=    finish_time - arrival_time[short]
												_UpperCAmelCase       :		Union[str, Any] 		=    finar - burst_time[short]

												if waiting_time[short] < 0:
																_UpperCAmelCase       :		Optional[int] 		=    0

        # Increment time
								increment_time += 1
				return waiting_time

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  list[int]  ,      lowerCAmelCase:  int  ,      lowerCAmelCase:  list[int] )   ->       list[int]:
				_UpperCAmelCase       :		str 		=    [0] * no_of_processes
				for i in range(lowerCAmelCase ):
								_UpperCAmelCase       :		str 		=    burst_time[i] + waiting_time[i]
				return turn_around_time

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  list[int]  ,      lowerCAmelCase:  list[int]  ,      lowerCAmelCase:  int )   ->       None:
				_UpperCAmelCase       :		Dict 		=    0
				_UpperCAmelCase       :		List[str] 		=    0
				for i in range(lowerCAmelCase ):
								_UpperCAmelCase       :		Union[str, Any] 		=    total_waiting_time + waiting_time[i]
								_UpperCAmelCase       :		int 		=    total_turn_around_time + turn_around_time[i]
				print(F'Average waiting time = {total_waiting_time / no_of_processes:.5f}' )
				print("Average turn around time ="  ,      total_turn_around_time / no_of_processes )


if __name__ == "__main__":
					print('Enter how many process you want to analyze')
					SCREAMING_SNAKE_CASE_        =      int(input())
					SCREAMING_SNAKE_CASE_        =      [0] * no_of_processes
					SCREAMING_SNAKE_CASE_        =      [0] * no_of_processes
					SCREAMING_SNAKE_CASE_        =      list(range(1, no_of_processes + 1))

					for i in range(no_of_processes):
										print('Enter the arrival time and burst time for process:--' + str(i + 1))
										SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_        =      map(int, input().split())

					SCREAMING_SNAKE_CASE_        =      calculate_waitingtime(arrival_time, burst_time, no_of_processes)

					SCREAMING_SNAKE_CASE_        =      burst_time
					SCREAMING_SNAKE_CASE_        =      no_of_processes
					SCREAMING_SNAKE_CASE_        =      waiting_time
					SCREAMING_SNAKE_CASE_        =      calculate_turnaroundtime(bt, n, wt)

					calculate_average_times(waiting_time, turn_around_time, no_of_processes)

					SCREAMING_SNAKE_CASE_        =      pd.DataFrame(
					    list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
					    columns=[
					        'Process',
					        'BurstTime',
					        'ArrivalTime',
					        'WaitingTime',
					        'TurnAroundTime',
					    ],
					)

					# Printing the dataFrame
					pd.set_option('display.max_rows', fcfs.shape[0] + 1)
					print(fcfs)


