




from multiprocessing import Lock, Pipe, Process

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


def 						lowerCamelCase__    (		_A     ,	_A     ,	_A     ,	_A     ,	_A     ,	_A     ,	_A							):







	'''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__    (		_A							):







	'''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()





'''simple docstring'''





def        a_     (							_lowerCAmelCase       )      ->      list:
  if n_term == "":
    return []
  __lowerCamelCase       :       list           = []
  for temp in range(int(_lowerCAmelCase       )       ):
    series.append(F'1/{temp + 1}' if series else '1'       )
  return series


if __name__ == "__main__":
   _UpperCamelCase											=						input('Enter the last number (nth term) of the Harmonic Series')
   print('Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n')
   print(harmonic_series(nth_term))






