





'''simple docstring'''

from __future__ import annotations

import pandas as pd

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )    ->       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(__UpperCAmelCase   ):
      __SCREAMING_SNAKE_CASE   				=							burst_time[i]

   __SCREAMING_SNAKE_CASE   				=							0
   __SCREAMING_SNAKE_CASE   				=							0
   __SCREAMING_SNAKE_CASE   				=							999999999
   __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   				=							999999999

      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     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )    ->       list[int]:

   '''simple docstring'''







   __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     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )    ->       None:

   '''simple docstring'''







   __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   	=    int(input())
    a   	=    [0] * no_of_processes
    a   	=    [0] * no_of_processes
    a   	=    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   	=    map(int, input().split())

    a   	=    calculate_waitingtime(arrival_time, burst_time, no_of_processes)

    a   	=    burst_time
    a   	=    no_of_processes
    a   	=    waiting_time
    a   	=    calculate_turnaroundtime(bt, n, wt)

    calculate_average_times(waiting_time, turn_around_time, no_of_processes)

    a   	=    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 datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def     __magic_name__							(				)    ->       Union[str, Any]:

   '''simple docstring'''







   import os as original_os
   from os import path as original_path
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join

   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_mock__"""
   with patch_submodule(_test_patching				,						"""os.path.join"""				,						__UpperCAmelCase   ):
      # Every way to access os.path.join must be patched, and the rest must stay untouched

      # check os.path.join
      assert isinstance(_test_patching.os				,						_PatchedModuleObj   )
      assert isinstance(_test_patching.os.path				,						_PatchedModuleObj   )
      assert _test_patching.os.path.join is mock

      # check path.join
      assert isinstance(_test_patching.path				,						_PatchedModuleObj   )
      assert _test_patching.path.join is mock

      # check join
      assert _test_patching.join is mock

      # check that the other attributes are untouched
      assert _test_patching.os.rename is original_rename
      assert _test_patching.path.dirname is original_dirname
      assert _test_patching.os.path.dirname is original_dirname

      # Even renamed modules or objects must be patched

      # check renamed_os.path.join
      assert isinstance(_test_patching.renamed_os				,						_PatchedModuleObj   )
      assert isinstance(_test_patching.renamed_os.path				,						_PatchedModuleObj   )
      assert _test_patching.renamed_os.path.join is mock

      # check renamed_path.join
      assert isinstance(_test_patching.renamed_path				,						_PatchedModuleObj   )
      assert _test_patching.renamed_path.join is mock

      # check renamed_join
      assert _test_patching.renamed_join is mock

      # check that the other attributes are untouched
      assert _test_patching.renamed_os.rename is original_rename
      assert _test_patching.renamed_path.dirname is original_dirname
      assert _test_patching.renamed_os.path.dirname is original_dirname

   # check that everthing is back to normal when the patch is over

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join

def     __magic_name__							(				)    ->       Tuple:

   '''simple docstring'''







   assert _test_patching.open is open

   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_builtin_mock__"""
   # _test_patching has "open" in its globals
   assert _test_patching.open is open
   with patch_submodule(_test_patching				,						"""open"""				,						__UpperCAmelCase   ):
      assert _test_patching.open is mock

   # check that everthing is back to normal when the patch is over

   assert _test_patching.open is open

def     __magic_name__							(				)    ->       Any:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_missing_mock__"""
   with patch_submodule(_test_patching				,						"""pandas.read_csv"""				,						__UpperCAmelCase   ):
      pass

def     __magic_name__							(				)    ->       Dict:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_missing_builtin_mock__"""
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching				,						"""len"""				,						__UpperCAmelCase   ) is None
   with patch_submodule(_test_patching				,						"""len"""				,						__UpperCAmelCase   ):
      assert _test_patching.len is mock
   assert _test_patching.len is len

def     __magic_name__							(				)    ->       Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_start_and_stop_mock__"""
   __SCREAMING_SNAKE_CASE   				=							patch_submodule(_test_patching				,						"""open"""				,						__UpperCAmelCase   )
   assert _test_patching.open is open
   patch.start()
   assert _test_patching.open is mock
   patch.stop()
   assert _test_patching.open is open

def     __magic_name__							(				)    ->       Union[str, Any]:

   '''simple docstring'''







   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_successive_join__"""
   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_successive_dirname__"""
   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_successive_rename__"""
   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename

   with patch_submodule(_test_patching				,						"""os.path.join"""				,						__UpperCAmelCase   ):
      with patch_submodule(_test_patching				,						"""os.rename"""				,						__UpperCAmelCase   ):
         with patch_submodule(_test_patching				,						"""os.path.dirname"""				,						__UpperCAmelCase   ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

    # try another order
   with patch_submodule(_test_patching				,						"""os.rename"""				,						__UpperCAmelCase   ):
      with patch_submodule(_test_patching				,						"""os.path.join"""				,						__UpperCAmelCase   ):
         with patch_submodule(_test_patching				,						"""os.path.dirname"""				,						__UpperCAmelCase   ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename







def     __magic_name__							(				)    ->       str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							"""__test_patch_submodule_doesnt_exist_mock__"""
   with patch_submodule(_test_patching				,						"""__module_that_doesn_exist__.__attribute_that_doesn_exist__"""				,						__UpperCAmelCase   ):
      pass
   with patch_submodule(_test_patching				,						"""os.__attribute_that_doesn_exist__"""				,						__UpperCAmelCase   ):
      pass





