

'''simple docstring'''

def     __magic_name__       ( A							)			->		List[Any]:
	snake_case							 =				len(A							)
	for _ in range(
	    0					,   int(((no_of_elements - 1) / 2) + 1							)							):  # we don't need to traverse to end of list as
		for j in range(0					,   no_of_elements - 1							):
			if (
			    lst[j + 1] < lst[j]
			):  # applying bubble sort algorithm from left to right (or forwards)
				snake_case							 =				lst[j + 1]
				snake_case							 =				lst[j]
				snake_case							 =				temp
			if (
			    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
			):  # applying bubble sort algorithm from right to left (or backwards)
				snake_case							 =				lst[no_of_elements - 1 - j]
				snake_case							 =				lst[no_of_elements - 2 - j]
				snake_case							 =				temp
	return lst


if __name__ == "__main__":
						print("enter the list to be sorted")
						lowerCAmelCase_						   =			[int(x) for x in input().split()]  # inputing elements of the list in one line
						lowerCAmelCase_						   =			double_sort(lst)
						print("the sorted list is")
						print(sorted_lst)








'''simple docstring'''

lowerCAmelCase_						   =			{0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}

lowerCAmelCase_						   =			{0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}

def     __magic_name__       ( A					,   A					,   A							)			->		list:
	snake_case							 =				True
	snake_case							 =				[]

	for neighbour in graph[vert]:
		if not visited[neighbour]:
			connected_verts += dfs(A					,   A					,   A							)

	return [vert, *connected_verts]

def     __magic_name__       ( A							)			->		list:
	snake_case							 =				len(A							)
	snake_case							 =				graph_size * [False]
	snake_case							 =				[]

	for i in range(A							):
		if not visited[i]:
			snake_case							 =				dfs(A					,   A					,   A							)
			components_list.append(A							)

	return components_list


if __name__ == "__main__":
						import doctest

						doctest.testmod()





