





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

import pandas as pd


def 	_lowerCAmelCase (						_UpperCamelCase						:					List[str]							,			_UpperCamelCase						:					Any							,			_UpperCamelCase						:					Union[str, Any]    )				->      list[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =[0] * no_of_processes
     _SCREAMING_SNAKE_CASE							   =[0] * no_of_processes
     # Copy the burst time into remaining_time[]
     for i in range(a_    ):
          _SCREAMING_SNAKE_CASE							   =burst_time[i]

     _SCREAMING_SNAKE_CASE							   =0
     _SCREAMING_SNAKE_CASE							   =0
     _SCREAMING_SNAKE_CASE							   =9_99_99_99_99
     _SCREAMING_SNAKE_CASE							   =0
     _SCREAMING_SNAKE_CASE							   =False

     # Process until all processes are completed
     while complete != no_of_processes:
          for j in range(a_    ):
               if arrival_time[j] <= increment_time and remaining_time[j] > 0:
                    if remaining_time[j] < minm:
                         _SCREAMING_SNAKE_CASE							   =remaining_time[j]
                         _SCREAMING_SNAKE_CASE							   =j
                         _SCREAMING_SNAKE_CASE							   =True

          if not check:
               increment_time += 1
               continue
          remaining_time[short] -= 1

          _SCREAMING_SNAKE_CASE							   =remaining_time[short]
          if minm == 0:
               _SCREAMING_SNAKE_CASE							   =9_99_99_99_99

          if remaining_time[short] == 0:
               complete += 1
               _SCREAMING_SNAKE_CASE							   =False

               # Find finish time of current process
               _SCREAMING_SNAKE_CASE							   =increment_time + 1

               # Calculate waiting time
               _SCREAMING_SNAKE_CASE							   =finish_time - arrival_time[short]
               _SCREAMING_SNAKE_CASE							   =finar - burst_time[short]

               if waiting_time[short] < 0:
                    _SCREAMING_SNAKE_CASE							   =0

        # Increment time
          increment_time += 1
     return waiting_time


def 	_lowerCAmelCase (						_UpperCamelCase						:					str							,			_UpperCamelCase						:					Optional[Any]							,			_UpperCamelCase						:					Any    )				->      list[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =[0] * no_of_processes
     for i in range(a_    ):
          _SCREAMING_SNAKE_CASE							   =burst_time[i] + waiting_time[i]
     return turn_around_time


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict							,			_UpperCamelCase						:					str							,			_UpperCamelCase						:					Any    )				->      None:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =0
     _SCREAMING_SNAKE_CASE							   =0
     for i in range(a_    ):
          _SCREAMING_SNAKE_CASE							   =total_waiting_time + waiting_time[i]
          _SCREAMING_SNAKE_CASE							   =total_turn_around_time + turn_around_time[i]
     print(f"Average waiting time = {total_waiting_time / no_of_processes:.5f}"    )
     print('Average turn around time ='							,			total_turn_around_time / no_of_processes    )


if __name__ == "__main__":
     print("Enter how many process you want to analyze")
     lowerCamelCase			:				Any 			=					int(input())
     lowerCamelCase			:				Tuple 			=					[0] * no_of_processes
     lowerCamelCase			:				str 			=					[0] * no_of_processes
     lowerCamelCase			:				List[str] 			=					list(range(1, no_of_processes + 1))

     for i in range(no_of_processes):
          print("Enter the arrival time and burst time for process:--" + str(i + 1))
          lowerCamelCase			,   lowerCamelCase			:				Optional[Any] 			=					map(int, input().split())

     lowerCamelCase			:				Optional[Any] 			=					calculate_waitingtime(arrival_time, burst_time, no_of_processes)

     lowerCamelCase			:				Union[str, Any] 			=					burst_time
     lowerCamelCase			:				Tuple 			=					no_of_processes
     lowerCamelCase			:				str 			=					waiting_time
     lowerCamelCase			:				Optional[Any] 			=					calculate_turnaroundtime(bt, n, wt)

     calculate_average_times(waiting_time, turn_around_time, no_of_processes)

     lowerCamelCase			:				Optional[int] 			=					pd.DataFrame(
         list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
         columns=[
             "Process",
             "BurstTime",
             "ArrivalTime",
             "WaitingTime",
             "TurnAroundTime",
         ],
     )

     # Printing the dataFrame
     pd.set_option("display.max_rows", fcfs.shape[0] + 1)
     print(fcfs)



'''simple docstring'''
from ..utils import DummyObject, requires_backends







class 							A__   (	metaclass=A__  ):
  A__					=    ['note_seq']





  def __init__(		self				:     List[str]							, *_a				:     Any							, **_a				:     Dict			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(self							, ['note_seq']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     str							, **_a				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['note_seq']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Optional[Any]							, **_a				:     Optional[int]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['note_seq']			)
