






'''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    :      int  			=		Lock()
def 						A__			(				__lowerCAmelCase		:			Optional[Any]   ,    __lowerCAmelCase		:			List[str]   ,    __lowerCAmelCase		:			Union[str, Any]   ,    __lowerCAmelCase		:			List[str]   ,    __lowerCAmelCase		:			Any   ,    __lowerCAmelCase		:			Union[str, Any]   ,    __lowerCAmelCase		:			List[Any]						):
						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()
																		lowerCamelCase__         =  rr_cv[0].recv()
																		process_lock.release()

																		# take the lower value since you are on the left
																		lowerCamelCase__         =  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()
																		lowerCamelCase__         =  lr_cv[0].recv()
																		process_lock.release()

																		# take the higher value since you are on the right
																		lowerCamelCase__         =  max(__lowerCAmelCase   ,    __lowerCAmelCase						)
    # after all swaps are performed, send the values back to main
						result_pipe[1].send(__lowerCAmelCase						)
def 						A__			(				__lowerCAmelCase		:			List[str]						):
						lowerCamelCase__         =  []
						lowerCamelCase__         =  []
						# 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
						lowerCamelCase__         =  Pipe()
						lowerCamelCase__         =  Pipe()
						process_array_.append(
						    Process(
						        target=__lowerCAmelCase   ,    args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])   ,    )						)
						lowerCamelCase__         =  temp_rs
						lowerCamelCase__         =  temp_rr

						for i in range(1   ,    len(__lowerCAmelCase						) - 1						):
												lowerCamelCase__         =  Pipe()
												lowerCamelCase__         =  Pipe()
												process_array_.append(
												    Process(
												        target=__lowerCAmelCase   ,    args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])   ,    )						)
												lowerCamelCase__         =  temp_rs
												lowerCamelCase__         =  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						)						):
												lowerCamelCase__         =  result_pipe[p][0].recv()
												process_array_[p].join()
						return arr
def 						A__			(				):
						lowerCamelCase__         =  list(range(10   ,    0   ,    -1						)						)
						print("""Initial List"""						)
						print(*__lowerCAmelCase						)
						lowerCamelCase__         =  odd_even_transposition(__lowerCAmelCase						)
						print("""Sorted List\n"""						)
						print(*__lowerCAmelCase						)


if __name__ == "__main__":
							main()









'''simple docstring'''







from manim import *




class 		UpperCamelCase__    (a			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  Rectangle(height=0.5   ,width=0.5       )
								lowerCamelCase__         =  Rectangle(height=0.46   ,width=0.46       ).set_stroke(width=0       )

								lowerCamelCase__         =  [mem.copy() for i in range(6       )]
								lowerCamelCase__         =  [mem.copy() for i in range(6       )]
								lowerCamelCase__         =  VGroup(*_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )
								lowerCamelCase__         =  VGroup(*_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )
								lowerCamelCase__         =  VGroup(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )
								lowerCamelCase__         =  Text("""CPU"""   ,font_size=24       )
								lowerCamelCase__         =  Group(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0.5   ,aligned_edge=_lowerCAmelCase       )
								cpu.move_to([-2.5, -0.5, 0]       )
								self.add(_lowerCAmelCase       )

								lowerCamelCase__         =  [mem.copy() for i in range(1       )]
								lowerCamelCase__         =  VGroup(*_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )
								lowerCamelCase__         =  Text("""GPU"""   ,font_size=24       )
								lowerCamelCase__         =  Group(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0.5   ,aligned_edge=_lowerCAmelCase       )
								gpu.align_to(_lowerCAmelCase   ,_lowerCAmelCase       )
								gpu.set_x(gpu.get_x() - 1       )

								self.add(_lowerCAmelCase       )

								lowerCamelCase__         =  [mem.copy() for i in range(6       )]
								lowerCamelCase__         =  VGroup(*_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )

								lowerCamelCase__         =  Text("""Model"""   ,font_size=24       )
								lowerCamelCase__         =  Group(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0.5   ,aligned_edge=_lowerCAmelCase       )
								model.move_to([3, -1.0, 0]       )

								self.play(
								    Create(_lowerCAmelCase   ,run_time=1       )   ,Create(_lowerCAmelCase   ,run_time=1       )   ,Create(_lowerCAmelCase   ,run_time=1       )   ,)

								lowerCamelCase__         =  MarkupText(
								    F'''First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'''   ,font_size=24   ,)

								lowerCamelCase__         =  Square(side_length=2.2       )
								key.move_to([-5, 2, 0]       )

								lowerCamelCase__         =  MarkupText(
								    F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''   ,font_size=18   ,)

								key_text.move_to([-5, 2.4, 0]       )

								step_a.move_to([2, 2, 0]       )
								self.play(Write(_lowerCAmelCase   ,run_time=2.5       )   ,Write(_lowerCAmelCase       )   ,Write(_lowerCAmelCase       )       )

								self.add(_lowerCAmelCase       )

								lowerCamelCase__         =  []
								lowerCamelCase__         =  []
								lowerCamelCase__         =  []
								for i, rect in enumerate(_lowerCAmelCase       ):
														lowerCamelCase__         =  Rectangle(height=0.46   ,width=0.46       ).set_stroke(width=0.0       ).set_fill(_lowerCAmelCase   ,opacity=0.7       )
														cpu_target.move_to(_lowerCAmelCase       )
														cpu_target.generate_target()
														lowerCamelCase__         =  0.46 / 4
														lowerCamelCase__         =  0.46 / 3

														if i == 0:
																				cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT       )   ,buff=0.02   ,direction=_lowerCAmelCase       )
																				cpu_target.target.set_x(cpu_target.target.get_x() + 0.1       )
														elif i == 3:
																				cpu_target.target.next_to(cpu_targs[0].target   ,direction=_lowerCAmelCase   ,buff=0.0       )
														else:
																				cpu_target.target.next_to(cpu_targs[i - 1].target   ,direction=_lowerCAmelCase   ,buff=0.0       )
														cpu_targs.append(_lowerCAmelCase       )

														first_animations.append(rect.animate(run_time=0.5       ).set_stroke(_lowerCAmelCase       )       )
														second_animations.append(MoveToTarget(_lowerCAmelCase   ,run_time=1.5       )       )

								self.play(*_lowerCAmelCase       )
								self.play(*_lowerCAmelCase       )

								self.wait()

