






from __future__ import annotations

import pandas as pd






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase				,							_UpperCAmelCase):
			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(UpperCamelCase__):
						SCREAMING_SNAKE_CASE							=			burst_time[i]

			SCREAMING_SNAKE_CASE							=			0
			SCREAMING_SNAKE_CASE							=			0
			SCREAMING_SNAKE_CASE							=			9_9999_9999
			SCREAMING_SNAKE_CASE							=			0
			SCREAMING_SNAKE_CASE							=			False

			# Process until all processes are completed
			while complete != no_of_processes:
						for j in range(UpperCamelCase__):
									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_9999_9999

						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				,							_UpperCAmelCase				,							_UpperCAmelCase):
			SCREAMING_SNAKE_CASE							=			[0] * no_of_processes
			for i in range(UpperCamelCase__):
						SCREAMING_SNAKE_CASE							=			burst_time[i] + waiting_time[i]
			return turn_around_time






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase				,							_UpperCAmelCase):
			SCREAMING_SNAKE_CASE							=			0
			SCREAMING_SNAKE_CASE							=			0
			for i in range(UpperCamelCase__):
						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')
				a_		:    List[Any]   							=     int(input())
				a_		:    int   							=     [0] * no_of_processes
				a_		:    List[str]   							=     [0] * no_of_processes
				a_		:    Any   							=     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))
								a_							,       a_		:    Optional[int]   							=     map(int, input().split())

				a_		:    Dict   							=     calculate_waitingtime(arrival_time, burst_time, no_of_processes)

				a_		:    List[str]   							=     burst_time
				a_		:    Optional[int]   							=     no_of_processes
				a_		:    int   							=     waiting_time
				a_		:    Union[str, Any]   							=     calculate_turnaroundtime(bt, n, wt)

				calculate_average_times(waiting_time, turn_around_time, no_of_processes)

				a_		:    Tuple   							=     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)










import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


__A								=       {
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}







def      lowerCamelCase_						(			UpperCamelCase__							: List[str]					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: Any					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: int )	->			List[Any]:





				"""simple docstring"""


				if got_ver is None or want_ver is None:
								raise ValueError(
								    F"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
								    F""" reinstalling {pkg}.""" )
				if not ops[op](version.parse(UpperCamelCase__ )					,	version.parse(UpperCamelCase__ ) ):
								raise ImportError(
								    F"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}""" )







def      lowerCamelCase_						(			UpperCamelCase__							: str					,	UpperCamelCase__							: Optional[str] = None )	->			None:





				"""simple docstring"""


				__lowerCamelCase									=       F"""\n{hint}""" if hint is not None else ''

				# non-versioned check
				if re.match(R'^[\w_\-\d]+$'					,	UpperCamelCase__ ):
								__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase									=       requirement, None, None
				else:
								__lowerCamelCase									=       re.findall(R'^([^!=<>\s]+)([\s!=<>]{1,2}.+)'					,	UpperCamelCase__ )
								if not match:
												raise ValueError(
												    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'
												    F""" got {requirement}""" )
								__lowerCamelCase			,		__lowerCamelCase									=       match[0]
								__lowerCamelCase									=       want_full.split(',' )  # there could be multiple requirements
								__lowerCamelCase									=       {}
								for w in want_range:
												__lowerCamelCase									=       re.findall(R'^([\s!=<>]{1,2})(.+)'					,	UpperCamelCase__ )
												if not match:
																raise ValueError(
																    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'
																    F""" but got {requirement}""" )
												__lowerCamelCase			,		__lowerCamelCase									=       match[0]
												__lowerCamelCase									=       want_ver
												if op not in ops:
																raise ValueError(F"""{requirement}: need one of {list(ops.keys() )}, but got {op}""" )

    # special case
				if pkg == "python":
								__lowerCamelCase									=       '.'.join([str(UpperCamelCase__ ) for x in sys.version_info[:3]] )
								for op, want_ver in wanted.items():
												_compare_versions(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__ )
								return

				# check if any version is installed
				try:
								__lowerCamelCase									=       importlib.metadata.version(UpperCamelCase__ )
				except importlib.metadata.PackageNotFoundError:
								raise importlib.metadata.PackageNotFoundError(
								    F"""The '{requirement}' distribution was not found and is required by this application. {hint}""" )

				# check that the right version is installed if version number or a range was provided
				if want_ver is not None:
								for op, want_ver in wanted.items():
												_compare_versions(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__ )







def      lowerCamelCase_						(			UpperCamelCase__							: Optional[int] )	->			Optional[int]:





				"""simple docstring"""


				__lowerCamelCase									=       'Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'
				return require_version(UpperCamelCase__					,	UpperCamelCase__ )


