

"""simple docstring"""




from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
_UpperCAmelCase		:       str						    =	Lock()





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							global process_lock

							# we perform n swaps since after n swaps we know we are sorted
							# we *could* stop early if we are sorted already, but it takes as long to
							# find out we are sorted as it does to sort the list with this algorithm
							for i in range(0       ,							10				):
														if (i + position) % 2 == 0 and r_send is not None:
																					# send your value to your right neighbor
																					process_lock.acquire()
																					r_send[1].send(lowerCAmelCase__				)
																					process_lock.release()

																					# receive your right neighbor's value
																					process_lock.acquire()
																					snake_case_          =   rr_cv[0].recv()
																					process_lock.release()

																					# take the lower value since you are on the left
																					snake_case_          =   min(lowerCAmelCase__       ,							lowerCAmelCase__				)
														elif (i + position) % 2 != 0 and l_send is not None:
																					# send your value to your left neighbor
																					process_lock.acquire()
																					l_send[1].send(lowerCAmelCase__				)
																					process_lock.release()

																					# receive your left neighbor's value
																					process_lock.acquire()
																					snake_case_          =   lr_cv[0].recv()
																					process_lock.release()

																					# take the higher value since you are on the right
																					snake_case_          =   max(lowerCAmelCase__       ,							lowerCAmelCase__				)
    # after all swaps are performed, send the values back to main
							result_pipe[1].send(lowerCAmelCase__				)





def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   []
							snake_case_          =   []
							# initialize the list of pipes where the values will be retrieved
							for _ in arr:
														result_pipe.append(Pipe()				)
							# creates the processes
							# the first and last process only have one neighbor so they are made outside
							# of the loop
							snake_case_          =   Pipe()
							snake_case_          =   Pipe()
							process_array_.append(
							    Process(
							        target=lowerCAmelCase__       ,							args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])       ,							)				)
							snake_case_          =   temp_rs
							snake_case_          =   temp_rr

							for i in range(1       ,							len(lowerCAmelCase__				) - 1				):
														snake_case_          =   Pipe()
														snake_case_          =   Pipe()
														process_array_.append(
														    Process(
														        target=lowerCAmelCase__       ,							args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])       ,							)				)
														snake_case_          =   temp_rs
														snake_case_          =   temp_rr

							process_array_.append(
							    Process(
							        target=lowerCAmelCase__       ,							args=(
							            len(lowerCAmelCase__				) - 1,
							            arr[len(lowerCAmelCase__				) - 1],
							            temp_ls,
							            None,
							            temp_lr,
							            None,
							            result_pipe[len(lowerCAmelCase__				) - 1],
							        )       ,							)				)

							# start the processes
							for p in process_array_:
														p.start()

							# wait for the processes to end and write their values to the list
							for p in range(0       ,							len(lowerCAmelCase__				)				):
														snake_case_          =   result_pipe[p][0].recv()
														process_array_[p].join()
							return arr





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   list(range(10       ,							0       ,							-1				)				)
							print('Initial List'				)
							print(*lowerCAmelCase__				)
							snake_case_          =   odd_even_transposition(lowerCAmelCase__				)
							print('Sorted List\n'				)
							print(*lowerCAmelCase__				)


if __name__ == "__main__":
					main()







from __future__ import annotations





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__ = None       ,							UpperCamelCase__ = None				):







							'''simple docstring'''






							if start is None:
														snake_case_          =   0

							if end is None:
														snake_case_          =   len(UpperCamelCase__				) - 1

							if start >= end:
														return

							snake_case_          =   (start + end) // 2

							slowsort(UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				)
							slowsort(UpperCamelCase__       ,							mid + 1       ,							UpperCamelCase__				)

							if sequence[end] < sequence[mid]:
														snake_case_    ,   snake_case_          =   sequence[mid], sequence[end]

							slowsort(UpperCamelCase__       ,							UpperCamelCase__       ,							end - 1				)


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

					testmod()




