




from __future__ import annotations

from statistics import mean




def 							_UpperCAmelCase  (UpperCamelCase_ : list[int]      ,    UpperCamelCase_ : list[int]      ,    UpperCamelCase_ : int       ):
				'''simple docstring'''
				_lowerCAmelCase    :    int										=      [0] * no_of_processes
				_lowerCAmelCase    :    str										=      [0] * no_of_processes

				# Initialize remaining_time to waiting_time.

				for i in range(UpperCamelCase_       ):
								_lowerCAmelCase    :    Optional[int]										=      burst_time[i]
				_lowerCAmelCase    :    list[int]										=      []

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

				return waiting_time




def 							_UpperCAmelCase  (UpperCamelCase_ : list[int]      ,    UpperCamelCase_ : int      ,    UpperCamelCase_ : list[int]       ):
				'''simple docstring'''
				_lowerCAmelCase    :    Union[str, Any]										=      [0] * no_of_processes
				for i in range(UpperCamelCase_       ):
								_lowerCAmelCase    :    str										=      burst_time[i] + waiting_time[i]
				return turn_around_time


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

	_lowerCamelCase      :  Dict      						=						4
	_lowerCamelCase      :  List[str]      						=						[2, 5, 3, 7]
	_lowerCamelCase      :  str      						=						[0, 0, 0, 0]
	_lowerCamelCase      :  List[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}''')







def 							_UpperCAmelCase  (UpperCamelCase_ : str      ,    UpperCamelCase_ : bool = False       ):
				'''simple docstring'''

				if not isinstance(UpperCamelCase_      ,    UpperCamelCase_       ):
								_lowerCAmelCase    :    Tuple										=      F"Expected string as input, found {type(UpperCamelCase_       )}"
								raise ValueError(UpperCamelCase_       )
				if not isinstance(UpperCamelCase_      ,    UpperCamelCase_       ):
								_lowerCAmelCase    :    Optional[Any]										=      F"Expected boolean as use_pascal parameter, found {type(UpperCamelCase_       )}"
								raise ValueError(UpperCamelCase_       )

				_lowerCAmelCase    :    Any										=      input_str.split("""_"""       )

				_lowerCAmelCase    :    str										=      0 if use_pascal else 1

				_lowerCAmelCase    :    Any										=      words[start_index:]

				_lowerCAmelCase    :    List[str]										=      [word[0].upper() + word[1:] for word in words_to_capitalize]

				_lowerCAmelCase    :    Any										=      """""" if use_pascal else words[0]

				return "".join([initial_word, *capitalized_words]       )


if __name__ == "__main__":
	from doctest import testmod

	testmod()

