

def      a__	(						UpperCAmelCase				:     list[int]     )    ->		int:
  if len(UpperCAmelCase     ) > 1:
    UpperCAmelCase			:				int										=					len(UpperCAmelCase     ) // 2  # Finds the middle of the array
    UpperCAmelCase			:				List[str]										=					arr[
        :middle_length
    ]  # Creates an array of the elements in the first half.
    UpperCAmelCase			:				List[str]										=					arr[
        middle_length:
    ]  # Creates an array of the elements in the second half.
    UpperCAmelCase			:				int										=					len(UpperCAmelCase     )
    UpperCAmelCase			:				Dict										=					len(UpperCAmelCase     )
    merge(UpperCAmelCase     )  # Starts sorting the left.
    merge(UpperCAmelCase     )  # Starts sorting the right
    UpperCAmelCase			:				List[str]										=					0  # Left Counter
    UpperCAmelCase			:				str										=					0  # Right Counter
    UpperCAmelCase			:				Any										=					0  # Position Counter
    while (
        left_index < left_size and right_index < right_size
    ):  # Runs until the lowers size of the left and right are sorted.
      if left_array[left_index] < right_array[right_index]:
        UpperCAmelCase			:				Any										=					left_array[left_index]
        left_index += 1
      else:
        UpperCAmelCase			:				List[str]										=					right_array[right_index]
        right_index += 1
      index += 1
    while (
        left_index < left_size
    ):  # Adds the left over elements in the left half of the array
      UpperCAmelCase			:				Dict										=					left_array[left_index]
      left_index += 1
      index += 1
    while (
        right_index < right_size
    ):  # Adds the left over elements in the right half of the array
      UpperCAmelCase			:				Dict										=					right_array[right_index]
      right_index += 1
      index += 1
  return arr


if __name__ == "__main__":
     import doctest

     doctest.testmod()











"""simple docstring"""

from __future__ import annotations




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					__snake_case        =						[0] * len(lowerCAmelCase		)
					for i in range(1					,       len(lowerCAmelCase		)		):
										__snake_case        =						duration_times[i - 1] + waiting_times[i - 1]
					return waiting_times




def    snake_case__						(							lowerCAmelCase :		list[int]					,       lowerCAmelCase :		list[int]		):
					return [
					    duration_time + waiting_times[i]
					    for i, duration_time in enumerate(lowerCAmelCase		)
					]




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					return sum(lowerCAmelCase		) / len(lowerCAmelCase		)




def    snake_case__						(							lowerCAmelCase :		list[int]		):
					return sum(lowerCAmelCase		) / len(lowerCAmelCase		)


if __name__ == "__main__":
		# process id's
		UpperCamelCase__			:     str			       =				[1, 2, 3]

		# ensure that we actually have processes
		if len(processes) == 0:
				print("Zero amount of processes")
				raise SystemExit(0)

		# duration time of all processes
		UpperCamelCase__			:     Any			       =				[19, 8, 9]

		# ensure we can match each id to a duration time
		if len(duration_times) != len(processes):
				print("Unable to match all id's with their duration time")
				raise SystemExit(0)

		# get the waiting times and the turnaround times
		UpperCamelCase__			:     Optional[int]			       =				calculate_waiting_times(duration_times)
		UpperCamelCase__			:     Any			       =				calculate_turnaround_times(duration_times, waiting_times)

		# get the average times
		UpperCamelCase__			:     Optional[Any]			       =				calculate_average_waiting_time(waiting_times)
		UpperCamelCase__			:     Dict			       =				calculate_average_turnaround_time(turnaround_times)

		# print all the results
		print("Process ID\tDuration Time\tWaiting Time\tTurnaround Time")
		for i, process in enumerate(processes):
				print(
				    f'{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t'
				    f'{turnaround_times[i]}'
				)
		print(f'Average waiting time = {average_waiting_time}')
		print(f'Average turn around time = {average_turnaround_time}')


