

import heapq

def 			lowerCamelCase__			(       _a):
	SCREAMING_SNAKE_CASE :   list[list]					  =							[]

	# for each node and his adjacency list add them and the rank of the node to queue
	# using heapq module the queue will be filled like a Priority Queue
	# heapq works with a min priority queue, so I used -1*len(v) to build it
	for key, value in graph.items():
		# O(log(n))
		heapq.heappush(_a				,      [-1 * len(_a), (key, value)])

	# chosen_vertices = set of chosen vertices
	SCREAMING_SNAKE_CASE :   str					  =							set()

	# while queue isn't empty and there are still edges
	#   (queue[0][0] is the rank of the node with max rank)
	while queue and queue[0][0] != 0:
		# extract vertex with max rank from queue and add it to chosen_vertices
		SCREAMING_SNAKE_CASE :   str					  =							heapq.heappop(_a)[1][0]
		chosen_vertices.add(_a)

		# Remove all arcs adjacent to argmax
		for elem in queue:
			# if v haven't adjacent node, skip
			if elem[0] == 0:
				continue
			# if argmax is reachable from elem
			# remove argmax from elem's adjacent list and update his rank
			if argmax in elem[1][1]:
				SCREAMING_SNAKE_CASE :   List[str]					  =							elem[1][1].index(_a)
				del elem[1][1][index]
				elem[0] += 1
        # re-order the queue
		heapq.heapify(_a)
	return chosen_vertices


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			a_      =     {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
			print(F'''Minimum vertex cover:\n{greedy_min_vertex_cover(graph)}''')


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]