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






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							)      ->       Optional[int]:
    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(UpperCamelCase__							)
            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(UpperCamelCase__							,    UpperCamelCase__							)
        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(UpperCamelCase__							)
            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(UpperCamelCase__							,    UpperCamelCase__							)
    # after all swaps are performed, send the values back to main
    result_pipe[1].send(UpperCamelCase__							)






def __lowerCAmelCase					(				UpperCamelCase__							)      ->       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=UpperCamelCase__							,    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(UpperCamelCase__							) - 1							):
        __lowerCamelCase            =    Pipe()
        __lowerCamelCase            =    Pipe()
        process_array_.append(
            Process(
                target=UpperCamelCase__							,    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=UpperCamelCase__							,    args=(
                len(UpperCamelCase__							) - 1,
                arr[len(UpperCamelCase__							) - 1],
                temp_ls,
                None,
                temp_lr,
                None,
                result_pipe[len(UpperCamelCase__							) - 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(UpperCamelCase__							)							):
        __lowerCamelCase            =    result_pipe[p][0].recv()
        process_array_[p].join()
    return arr






def __lowerCAmelCase					(				)      ->       Tuple:
    __lowerCamelCase            =    list(range(10							,    0							,    -1							)							)
    print('''Initial List'''							)
    print(*UpperCamelCase__							)
    __lowerCamelCase            =    odd_even_transposition(UpperCamelCase__							)
    print('''Sorted List\n'''							)
    print(*UpperCamelCase__							)


if __name__ == "__main__":
  main()

'''simple docstring'''




def __lowerCAmelCase					(				UpperCamelCase__							)      ->       bool:
    if not isinstance(UpperCamelCase__							,    UpperCamelCase__							):
        raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''							)
    if len(UpperCamelCase__							) == 0:
        raise ValueError('''Input list must be a non empty list'''							)
    if len(UpperCamelCase__							) == 1:
        return True
    __lowerCamelCase            =    series[1] - series[0]
    for index in range(len(UpperCamelCase__							) - 1							):
        if series[index + 1] - series[index] != common_diff:
            return False
    return True






def __lowerCAmelCase					(				UpperCamelCase__							)      ->       float:
    if not isinstance(UpperCamelCase__							,    UpperCamelCase__							):
        raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''							)
    if len(UpperCamelCase__							) == 0:
        raise ValueError('''Input list must be a non empty list'''							)
    __lowerCamelCase            =    0
    for val in series:
        answer += val
    return answer / len(UpperCamelCase__							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
