

from __future__ import annotations

from statistics import mean

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	SCREAMING_SNAKE_CASE :   List[Any]					  =							[0] * no_of_processes
	SCREAMING_SNAKE_CASE :   Tuple					  =							[0] * no_of_processes

	# Initialize remaining_time to waiting_time.

	for i in range(_a):
		SCREAMING_SNAKE_CASE :   Tuple					  =							burst_time[i]
	SCREAMING_SNAKE_CASE :   list[int]					  =							[]

	SCREAMING_SNAKE_CASE :   List[str]					  =							0
	SCREAMING_SNAKE_CASE :   Dict					  =							0

	# When processes are not completed,
	# A process whose arrival time has passed \
	# and has remaining execution time is put into the ready_process.
	# The shortest process in the ready_process, target_process is executed.

	while completed != no_of_processes:
		SCREAMING_SNAKE_CASE :   Optional[Any]					  =							[]
		SCREAMING_SNAKE_CASE :   List[str]					  =							-1

		for i in range(_a):
			if (arrival_time[i] <= total_time) and (remaining_time[i] > 0):
				ready_process.append(_a)

		if len(_a) > 0:
			SCREAMING_SNAKE_CASE :   Optional[int]					  =							ready_process[0]
			for i in ready_process:
				if remaining_time[i] < remaining_time[target_process]:
					SCREAMING_SNAKE_CASE :   List[str]					  =							i
			total_time += burst_time[target_process]
			completed += 1
			SCREAMING_SNAKE_CASE :   List[Any]					  =							0
			SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							(
			    total_time - arrival_time[target_process] - burst_time[target_process]
			)
		else:
			total_time += 1

	return waiting_time

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	SCREAMING_SNAKE_CASE :   Any					  =							[0] * no_of_processes
	for i in range(_a):
		SCREAMING_SNAKE_CASE :   Tuple					  =							burst_time[i] + waiting_time[i]
	return turn_around_time


if __name__ == "__main__":
			print('[TEST CASE 01]')

			a_      =     4
			a_      =     [2, 5, 3, 7]
			a_      =     [0, 0, 0, 0]
			a_      =     calculate_waitingtime(arrival_time, burst_time, no_of_processes)
			a_      =     calculate_turnaroundtime(
			    burst_time, no_of_processes, waiting_time
			)

			# Printing the Result
			print('PID\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time')
			for i, process_id in enumerate(list(range(1, 5))):
						print(
						    F'''{process_id}\t{burst_time[i]}\t\t\t{arrival_time[i]}\t\t\t\t'''
						    F'''{waiting_time[i]}\t\t\t\t{turn_around_time[i]}'''
						)
			print(F'''\nAverage waiting time = {mean(waiting_time):.5f}''')
			print(F'''Average turnaround time = {mean(turn_around_time):.5f}''')


from __future__ import annotations

def 			lowerCamelCase__			(       _a):
	if len(_a) == 0:
		return []
	SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE :   Tuple					  =							min(_a), max(_a)
	SCREAMING_SNAKE_CASE :   Dict					  =							int(max_value - min_value) + 1
	SCREAMING_SNAKE_CASE :   list[list]					  =							[[] for _ in range(_a)]

	for i in my_list:
		buckets[int(i - min_value)].append(_a)

	return [v for bucket in buckets for v in sorted(_a)]


if __name__ == "__main__":
			from doctest import testmod

			testmod()
			assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
			assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]