





from __future__ import annotations

from statistics import mean







def    A				(							UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase				):
					_snake_case       :					List[Any]				       =   [0] * no_of_processes
					_snake_case       :					int				       =   [0] * no_of_processes

					# Initialize remaining_time to waiting_time.

					for i in range(UpperCAmelCase				):
										_snake_case       :					int				       =   burst_time[i]
					_snake_case       :					list[int]				       =   []

					_snake_case       :					List[str]				       =   0
					_snake_case       :					List[Any]				       =   0

					# When processes are not completed,
					# A process whose arrival time has passed \
					# and has remaining execution time is put into the ready_process.
					# The shortest process in the ready_process, target_process is executed.

					while completed != no_of_processes:
										_snake_case       :					Optional[int]				       =   []
										_snake_case       :					Union[str, Any]				       =   -1

										for i in range(UpperCAmelCase				):
															if (arrival_time[i] <= total_time) and (remaining_time[i] > 0):
																				ready_process.append(UpperCAmelCase				)

										if len(UpperCAmelCase				) > 0:
															_snake_case       :					Optional[Any]				       =   ready_process[0]
															for i in ready_process:
																				if remaining_time[i] < remaining_time[target_process]:
																									_snake_case       :					Any				       =   i
															total_time += burst_time[target_process]
															completed += 1
															_snake_case       :					int				       =   0
															_snake_case       :					Union[str, Any]				       =   (
															    total_time - arrival_time[target_process] - burst_time[target_process]
															)
										else:
															total_time += 1

					return waiting_time







def    A				(							UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase				):
					_snake_case       :					Tuple				       =   [0] * no_of_processes
					for i in range(UpperCAmelCase				):
										_snake_case       :					List[str]				       =   burst_time[i] + waiting_time[i]
					return turn_around_time


if __name__ == "__main__":
							print('[TEST CASE 01]')

							__lowerCAmelCase :int     =    4
							__lowerCAmelCase :List[Any]     =    [2, 5, 3, 7]
							__lowerCAmelCase :List[str]     =    [0, 0, 0, 0]
							__lowerCAmelCase :str     =    calculate_waitingtime(arrival_time, burst_time, no_of_processes)
							__lowerCAmelCase :List[Any]     =    calculate_turnaroundtime(
							    burst_time, no_of_processes, waiting_time
							)

							# Printing the Result
							print('PID\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time')
							for i, process_id in enumerate(list(range(1, 5))):
														print(
														    F'''{process_id}\t{burst_time[i]}\t\t\t{arrival_time[i]}\t\t\t\t'''
														    F'''{waiting_time[i]}\t\t\t\t{turn_around_time[i]}'''
														)
							print(F'''\nAverage waiting time = {mean(waiting_time):.5f}''')
							print(F'''Average turnaround time = {mean(turn_around_time):.5f}''')






from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

__lowerCAmelCase :Union[str, Any]     =    typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
__lowerCAmelCase :Optional[Any]     =    typing.Union[np.floataa, int, float]  # noqa: UP007







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					return np.sqrt(np.sum((np.asarray(UpperCAmelCase				) - np.asarray(UpperCAmelCase				)) ** 2				)				)







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					return sum((va - va) ** 2 for va, va in zip(UpperCAmelCase  ,  UpperCAmelCase				)				) ** (1 / 2)


if __name__ == "__main__":







							def    A				(							):
												from timeit import timeit

												print("Without Numpy"				)
												print(
												    timeit(
												        "euclidean_distance_no_np([1, 2, 3], [4, 5, 6])"  ,  number=10_000  ,  globals=globals()  ,  )				)
												print("With Numpy"				)
												print(
												    timeit(
												        "euclidean_distance([1, 2, 3], [4, 5, 6])"  ,  number=10_000  ,  globals=globals()  ,  )				)

							benchmark()