





'''simple docstring'''






from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
A__				:   Optional[Any]      =Lock()
def    UpperCamelCase__      (		lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase  ):





      """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()
                  _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    UpperCamelCase__      (		lowerCAmelCase  ):





      """simple docstring"""


      _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    UpperCamelCase__      (		):





      """simple docstring"""


      _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'''





def        a_     (							_lowerCAmelCase       )      ->      str:
  if not all(char in '01' for char in bin_string       ):
    raise ValueError('Non-binary value was passed to the function'       )
  if not bin_string:
    raise ValueError('Empty string was passed to the function'       )
  __lowerCamelCase       :       int           = ''
  while len(_lowerCAmelCase       ) % 3 != 0:
    __lowerCamelCase       :       str           = '0' + bin_string
  __lowerCamelCase       :       Union[str, Any]           = [
      bin_string[index : index + 3]
      for index in range(len(_lowerCAmelCase       )       )
      if index % 3 == 0
  ]
  for bin_group in bin_string_in_3_list:
    __lowerCamelCase       :       Tuple           = 0
    for index, val in enumerate(_lowerCAmelCase       ):
      oct_val += int(2 ** (2 - index) * int(_lowerCAmelCase       )       )
    oct_string += str(_lowerCAmelCase       )
  return oct_string


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

   testmod()






