
from __future__ import annotations

from statistics import mean







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   list[int]:
       lowercase							:					Optional[Any]	     =				[0] * no_of_processes
       lowercase							:					Tuple	     =				[0] * no_of_processes

       # Initialize remaining_time to waiting_time.

       for i in range(SCREAMING_SNAKE_CASE__    ):
              lowercase							:					str	     =				burst_time[i]
       lowercase							:					list[int]	     =				[]

       lowercase							:					List[Any]	     =				0
       lowercase							:					Tuple	     =				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:
              lowercase							:					Tuple	     =				[]
              lowercase							:					Optional[Any]	     =				-1

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

              if len(SCREAMING_SNAKE_CASE__    ) > 0:
                     lowercase							:					str	     =				ready_process[0]
                     for i in ready_process:
                            if remaining_time[i] < remaining_time[target_process]:
                                   lowercase							:					List[str]	     =				i
                     total_time += burst_time[target_process]
                     completed += 1
                     lowercase							:					List[str]	     =				0
                     lowercase							:					Dict	     =				(
                         total_time - arrival_time[target_process] - burst_time[target_process]
                     )
              else:
                     total_time += 1

       return waiting_time







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   list[int]:
       lowercase							:					Tuple	     =				[0] * no_of_processes
       for i in range(SCREAMING_SNAKE_CASE__    ):
              lowercase							:					Union[str, Any]	     =				burst_time[i] + waiting_time[i]
       return turn_around_time


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

  lowercase  : Optional[int]						   =							4
  lowercase  : Optional[int]						   =							[2, 5, 3, 7]
  lowercase  : int						   =							[0, 0, 0, 0]
  lowercase  : Dict						   =							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}''')


def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   int:
       assert (
           isinstance(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ) and number_of_steps > 0
       ), f"number_of_steps needs to be positive integer, your input {number_of_steps}"
       if number_of_steps == 1:
              return 1
       lowercase     ,      lowercase							:					Tuple	     =				1, 1
       for _ in range(number_of_steps - 1    ):
              lowercase     ,      lowercase							:					str	     =				current + previous, current
       return current


if __name__ == "__main__":
  import doctest

  doctest.testmod()
