






"""simple docstring"""





from statistics import mean

import numpy as np



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

						# Sort by arrival time.
						__magic_name__:	Dict							=       [burst_time[i] for i in np.argsort(__UpperCAmelCase  )]
						__magic_name__:	str							=       [process_name[i] for i in np.argsort(__UpperCAmelCase  )]
						arrival_time.sort()

						while no_of_process > finished_process_count:
												__magic_name__:	Tuple							=       0
												while finished_process[i] == 1:
																		i += 1
												if current_time < arrival_time[i]:
																		__magic_name__:	Optional[Any]							=       arrival_time[i]

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

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

						return turn_around_time



def   a    (     __UpperCAmelCase      :    list      ,   __UpperCAmelCase      :    list      ,   __UpperCAmelCase      :    list      ,   __UpperCAmelCase      :    int  )    ->							list:
						__magic_name__:	List[str]							=       [0] * no_of_process
						for i in range(0      ,   __UpperCAmelCase  ):
												__magic_name__:	str							=       turn_around_time[i] - burst_time[i]
						return waiting_time


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

							__lowerCamelCase							=  calculate_turn_around_time(
							    process_name, arrival_time, burst_time, no_of_process
							)
							__lowerCamelCase							=  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   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    int  )    ->							int:
						while b:
												__magic_name__,			__magic_name__:	Optional[int]							=       b, a % b
						return a



def   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    int  )    ->							int:
						return a if b == 0 else euclidean_gcd_recursive(__UpperCAmelCase      ,   a % b  )



def   a    (     )    ->							List[Any]:
						print(f'euclidean_gcd(3, 5) = {euclidean_gcd(3      ,   5  )}'  )
						print(f'euclidean_gcd(5, 3) = {euclidean_gcd(5      ,   3  )}'  )
						print(f'euclidean_gcd(1, 3) = {euclidean_gcd(1      ,   3  )}'  )
						print(f'euclidean_gcd(3, 6) = {euclidean_gcd(3      ,   6  )}'  )
						print(f'euclidean_gcd(6, 3) = {euclidean_gcd(6      ,   3  )}'  )

						print(f'euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3      ,   5  )}'  )
						print(f'euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5      ,   3  )}'  )
						print(f'euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1      ,   3  )}'  )
						print(f'euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3      ,   6  )}'  )
						print(f'euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6      ,   3  )}'  )


if __name__ == "__main__":
							main()



