


'''simple docstring'''
from __future__ import annotations

from statistics import mean







def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ ):
							A_			    =		[0] * no_of_processes
							A_			    =		[0] * no_of_processes

							# Initialize remaining_time to waiting_time.

							for i in range(UpperCamelCase_ ):
														A_			    =		burst_time[i]
							A_			    =		[]

							A_			    =		0
							A_			    =		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:
														A_			    =		[]
														A_			    =		-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:
																					A_			    =		ready_process[0]
																					for i in ready_process:
																												if remaining_time[i] < remaining_time[target_process]:
																																			A_			    =		i
																					total_time += burst_time[target_process]
																					completed += 1
																					A_			    =		0
																					A_			    =		(
																					    total_time - arrival_time[target_process] - burst_time[target_process]
																					)
														else:
																					total_time += 1

							return waiting_time







def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ ):
							A_			    =		[0] * no_of_processes
							for i in range(UpperCamelCase_ ):
														A_			    =		burst_time[i] + waiting_time[i]
							return turn_around_time


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

							__SCREAMING_SNAKE_CASE					:				List[str]									=		4
							__SCREAMING_SNAKE_CASE					:				Optional[int]									=		[2, 5, 3, 7]
							__SCREAMING_SNAKE_CASE					:				Tuple									=		[0, 0, 0, 0]
							__SCREAMING_SNAKE_CASE					:				List[Any]									=		calculate_waitingtime(arrival_time, burst_time, no_of_processes)
							__SCREAMING_SNAKE_CASE					:				Tuple									=		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}")









'''simple docstring'''
def       a_				(	UpperCamelCase_ ):

							if length <= 0 or not isinstance(UpperCamelCase_						,  UpperCamelCase_ ):
														raise ValueError("Length must be a positive integer." )
							return [n * (2 * n - 1) for n in range(UpperCamelCase_ )]


if __name__ == "__main__":
							print(hexagonal_numbers(length=5))
							print(hexagonal_numbers(length=10))





