






from __future__ import annotations

from statistics import mean

def _UpperCAmelCase   (	a						:	list[int]  ,					a						:	list[int]  ,					a						:	int ):
							snake_case__	  =       [0] * no_of_processes
							snake_case__	  =       [0] * no_of_processes

							# Initialize remaining_time to waiting_time.

							for i in range(a ):
														snake_case__	  =       burst_time[i]
							snake_case__	  =       []

							snake_case__	  =       0
							snake_case__	  =       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__	  =       []
														snake_case__	  =       -1

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

														if len(a ) > 0:
																					snake_case__	  =       ready_process[0]
																					for i in ready_process:
																												if remaining_time[i] < remaining_time[target_process]:
																																			snake_case__	  =       i
																					total_time += burst_time[target_process]
																					completed += 1
																					snake_case__	  =       0
																					snake_case__	  =       (
																					    total_time - arrival_time[target_process] - burst_time[target_process]
																					)
														else:
																					total_time += 1

							return waiting_time

def _UpperCAmelCase   (	a						:	list[int]  ,					a						:	int  ,					a						:	list[int] ):
							snake_case__	  =       [0] * no_of_processes
							for i in range(a ):
														snake_case__	  =       burst_time[i] + waiting_time[i]
							return turn_around_time


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

	a__       =     4
	a__       =     [2, 5, 3, 7]
	a__       =     [0, 0, 0, 0]
	a__       =     calculate_waitingtime(arrival_time, burst_time, no_of_processes)
	a__       =     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}''')








def _UpperCAmelCase   (	a						:	int = 400_0000 ):
							snake_case__	  =       [0, 1]
							snake_case__	  =       0
							while fib[i] <= n:
														fib.append(fib[i] + fib[i + 1] )
														if fib[i + 2] > n:
																					break
														i += 1
							snake_case__	  =       0
							for j in range(len(a ) - 1 ):
														if fib[j] % 2 == 0:
																					total += fib[j]

							return total


if __name__ == "__main__":
	print(F'''{solution() = }''')
