NumPy数组高效操作：条件替换与连续值处理

import numpy as np

def closest_zero(arr, arr_idx, n):
    """
    计算在指定索引arr_idx处，arr中向后（索引减小）最近的0的原始索引。

    参数:
    arr (np.array): 输入数组。
    arr_idx (np.array): 需要查找最近0的起始索引数组。
    n (np.array): 包含数组索引的序列，np.arange(arr.size)。

    返回:
    np.array: 对应arr_idx中每个元素，其向后最近0的原始索引。
    """
    # (1 - arr) 将0变为1，1变为0。
    # (1 - arr) * n 将0的索引保留，1的索引变为0。
    # 这样，对于一个1，它前面最近的0的索引就是这个序列中最大的非0值。
    temp_arr = (1 - arr) * n

    # np.r_[0, arr_idx] 创建了新的段边界。
    # np.maximum.reduceat 在这些段内执行最大值归约。
    # 结果[:-1] 去掉了最后一个不相关的最大值。
    return np.maximum.reduceat(temp_arr, np.r_[0, arr_idx])[:-1]

def compare_and_replace(arr1_orig, arr2_orig):
    """
    比较两个数组，并在共同为1的位置，根据向后最近的0进行条件替换。

    参数:
    arr1_orig (list or np.array): 第一个输入数组。
    arr2_orig (list or np.array): 第二个输入数组。

    返回:
    tuple: 包含修改后的arr1和arr2的元组。
    """
    A, B = np.array(arr1_orig), np.array(arr2_orig)
    n = np.arange(A.size) # 原始索引序列

    # 找出arr1和arr2在相同位置都为1的索引
    idx_common_ones = np.where((A == 1) & (B == 1))[0]

    if idx_common_ones.size == 0:
        return A, B # 没有共同的1，直接返回原数组

    # 计算arr1和arr2在这些共同1位置，向后最近的0的索引
    closest_zero_A = closest_zero(A, idx_common_ones, n)
    closest_zero_B = closest_zero(B, idx_common_ones, n)

    # 比较哪个数组的1距离最近的0更远（即最近的0的索引更小，表示0更靠前）
    # 如果closest_zero_A > closest_zero_B，表示arr1的0更靠后，即arr2的0更靠前/更近。
    # 那么我们应该替换arr1中的1。
    # 注意：这里逻辑是“更近0”的那个替换，如果closest_zero_A > closest_zero_B，说明A的0更远，B的0更近。
    # 所以，将B中对应的1替换为0。
    # 原始问题是“figure out which array has the closest "0" looking backwards and replace "1" in that array with "0".”
    # 如果A的0更近，A的1替换为0。如果B的0更近，B的1替换为0。
    # closest_zero值越大，表示0越靠后，即距离当前1越远。
    # 所以，如果 closest_zero_A > closest_zero_B，说明A的0更远，B的0更近，应替换B。
    # 如果 closest_zero_A < closest_zero_B，说明A的0更近，B的0更远，应替换A。

    # idx_to_replace_A 为 True 表示 A 的 0 更近 (closest_zero_A > closest_zero_B 是 B 的 0 更近)
    # 那么 (closest_zero_A < closest_zero_B) 才是 A 的 0 更近

    # 修正逻辑：如果closest_zero_A的值小于closest_zero_B，表示A的0更靠前（更近）。
    # 那么，A中对应的1应该被替换为0。
    replace_A_mask = closest_zero_A < closest_zero_B

    # 如果closest_zero_B的值小于等于closest_zero_A，表示B的0更靠前（更近）或距离相同。
    # 那么，B中对应的1应该被替换为0。
    # 注意：当距离相同时，按照惯例选择一个替换。这里选择替换B。
    replace_B_mask = closest_zero_B <= closest_zero_A

    # 应用替换
    A[idx_common_ones[replace_A_mask]] = 0
    B[idx_common_ones[replace_B_mask]] = 0

    return A, B

# 示例
arr1_ex = np.array([0,1,1,1,0,0,1])
arr2_ex = np.array([1,0,1,1,1,1,1])
result_A, result_B = compare_and_replace(arr1_ex, arr2_ex)
print(f"原始arr1: {arr1_ex}")
print(f"原始arr2: {arr2_ex}")
print(f"处理后arr1: {result_A}")
print(f"处理后arr2: {result_B}")

# 另一个复杂示例
arr1_long = np.array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0])
arr2_long = np.array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0])
result_A_long, result_B_long = compare_and_replace(arr1_long, arr2_long)
print("\n--- 复杂示例 ---")
print(f"处理后arr1 (长): {result_A_long}")
print(f"处理后arr2 (长): {result_B_long}")

def replace_consecutive_ones(x_orig):
    """
    将数组中所有后面跟着1的1替换为0。

    参数:
    x_orig (list or np.array): 输入数组。

    返回:
    np.array: 修改后的数组。
    """
    x = np.array(x_orig, copy=True) # 创建副本以避免修改原始数组

    # x[:-1] 表示数组中除了最后一个元素之外的所有元素
    # x[1:] 表示数组中除了第一个元素之外的所有元素
    # (x[1:] * x[:-1]) == 1 找出x[i]和x[i+1]都为1的位置
    # 然后将x[:-1]中对应这些位置的元素设置为0
    x[:-1][(x[1:] * x[:-1]) == 1] = 0
    return x

# 示例
arr_c1 = np.array([1, 1, 0, 1, 0, 1, 1, 1])
result_c1 = replace_consecutive_ones(arr_c1)
print(f"\n原始数组: {arr_c1}")
print(f"处理后数组: {result_c1}")

arr_c2 = np.array([0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1])
result_c2 = replace_consecutive_ones(arr_c2)
print(f"原始数组: {arr_c2}")
print(f"处理后数组: {result_c2}")