code: 
  
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  from statistics import mean
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	2
      _lowercase     =	list(_lowercase      )
      _lowercase     =	[0] * len(_lowercase      )
      _lowercase     =	0
      while True:
          _lowercase     =	True
          for i, burst_time in enumerate(_lowercase      ):
              if rem_burst_times[i] > 0:
                  _lowercase     =	False
                  if rem_burst_times[i] > quantum:
                      t += quantum
                      rem_burst_times[i] -= quantum
                  else:
                      t += rem_burst_times[i]
                      _lowercase     =	t - burst_time
                      _lowercase     =	0
          if done is True:
              return waiting_times
  def        UpperCAmelCase      (   _lowercase,      _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      return [burst + waiting for burst, waiting in zip(_lowercase,      _lowercase      )]
  
  
  if __name__ == "__main__":
     lowerCamelCase										=  [3, 5, 7]
     lowerCamelCase										=  calculate_waiting_times(burst_times)
     lowerCamelCase										=  calculate_turn_around_times(burst_times, waiting_times)
     print('''Process ID \tBurst Time \tWaiting Time \tTurnaround Time''')
     for i, burst_time in enumerate(burst_times):
        print(
            f"  {i + 1}\t\t  {burst_time}\t\t  {waiting_times[i]}\t\t  "
            f"{turn_around_times[i]}"
        )
     print(f"\nAverage waiting time = {mean(waiting_times):.5f}")
     print(f"Average turn around time = {mean(turn_around_times):.5f}")
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  def        UpperCAmelCase      (   _lowercase,      _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	[None] * (len(_lowercase      ) + len(_lowercase      ))
  
      _lowercase     =	0  # pointer to current index for left Half
      _lowercase     =	0  # pointer to current index for the right Half
      _lowercase     =	0  # pointer to current index for the sorted array Half
  
      while pointera < len(_lowercase      ) and pointera < len(_lowercase      ):
          if left_half[pointera] < right_half[pointera]:
              _lowercase     =	left_half[pointera]
              pointera += 1
              index += 1
          else:
              _lowercase     =	right_half[pointera]
              pointera += 1
              index += 1
      while pointera < len(_lowercase      ):
          _lowercase     =	left_half[pointera]
          pointera += 1
          index += 1
  
      while pointera < len(_lowercase      ):
          _lowercase     =	right_half[pointera]
          pointera += 1
          index += 1
  
      return sorted_array
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      if len(_lowercase      ) <= 1:
          return array
      # the actual formula to calculate the middle element = left + (right - left) // 2
      # this avoids integer overflow in case of large N
      _lowercase     =	0 + (len(_lowercase      ) - 0) // 2
  
      # Split the array into halves till the array length becomes equal to One
      # merge the arrays of single length returned by mergeSort function and
      # pass them into the merge arrays function which merges the array
      _lowercase     =	array[:middle]
      _lowercase     =	array[middle:]
  
      return merge(merge_sort(_lowercase      ),      merge_sort(_lowercase      )      )
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  