





'''simple docstring'''




from __future__ import annotations

from statistics import mean






def 	_lowerCAmelCase      (  __snake_case  :			list[int]			,							__snake_case  :			list[int]			,							__snake_case  :			int      )					->					list[int]:
     __A						:			Any								=	[0] * no_of_processes
     __A						:			Dict								=	[0] * no_of_processes

     # Initialize remaining_time to waiting_time.

     for i in range(__snake_case      ):
          __A						:			Tuple								=	burst_time[i]
     __A						:			list[int]								=	[]

     __A						:			int								=	0
     __A						:			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:
          __A						:			Tuple								=	[]
          __A						:			Any								=	-1

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

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

     return waiting_time






def 	_lowerCAmelCase      (  __snake_case  :			list[int]			,							__snake_case  :			int			,							__snake_case  :			list[int]      )					->					list[int]:
     __A						:			int								=	[0] * no_of_processes
     for i in range(__snake_case      ):
          __A						:			Tuple								=	burst_time[i] + waiting_time[i]
     return turn_around_time


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

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






'''simple docstring'''




lowercase__   :				Any      =   {'''a''': ['''c''', '''b'''], '''b''': ['''d''', '''e'''], '''c''': [], '''d''': [], '''e''': []}
lowercase__   :				List[Any]      =   ['''a''', '''b''', '''c''', '''d''', '''e''']






def 	_lowerCAmelCase      (  __snake_case  :			str			,							__snake_case  :			Tuple			,							__snake_case  :			int      )					->					Tuple:
     __A						:			List[str]								=	start
     # add current to visited
     visited.append(__snake_case      )
     __A						:			Optional[int]								=	edges[current]
     for neighbor in neighbors:
          # if neighbor not in visited, visit
          if neighbor not in visited:
               __A						:			int								=	topological_sort(__snake_case			,							__snake_case			,							__snake_case      )
    # if all neighbors visited add current to sort
     sort.append(__snake_case      )
     # if all vertices haven't been visited select a new one to visit
     if len(__snake_case      ) != len(__snake_case      ):
          for vertice in vertices:
               if vertice not in visited:
                    __A						:			Dict								=	topological_sort(__snake_case			,							__snake_case			,							__snake_case      )
    # return sort
     return sort


if __name__ == "__main__":
  lowercase__   :				Tuple      =   topological_sort('''a''', [], [])
  print(sort)