Python 带噪声有序表对的高效搜索

假设两个数据集是有序的，并且它们包含成对匹配，发现成对的有效方法是什么？两个列表中都可能有噪音

从集合A，B中，集合C将由成对（A[X1]，B[Y1]），（A[X2]，B[Y2]），…，（A[Xn]，B[Yn]）组成，使得X1 这个问题可以用简化的Python块来演示，在这个块中，如何验证一对成功的Python是不相关的。 由于验证条件是不相关的，因此不需要保留条件return_pairs（A，B，validate）=return_pairs（B，A，validate），因为A，B中的数据不需要相同，只需要存在（A[x]，B[y]的验证函数）

解决办法。O（n2）

def返回_对（A、B、验证）：
ret=[]
used_x，used_y=-1，-1
对于x，枚举（A）中的x：
对于y，枚举（B）中的y：
如果x不是在两个嵌套循环中迭代每个列表，您可以首先根据自己的条件删除噪声，然后使用过滤的元素创建第三个列表，并根据验证运行列表的每个项目（新形成的元组）。这是假设我正确理解了问题，但我认为我并没有：

A=[0,0,0,1,2,0,3,4,0,5,6,0,7,0,0,8,0,0,0,9]
B=[1,2,0,0,0,0,0,3,0,0,0,4,0,5,6,0,0,0,7,0,0,0,8,0,9]
def清洁（旧列表）：
新列表=[]
对于旧列表中的项目：
如果0新建列表[-1]）：
newList.append（项目）
返回新列表
def验证（C）：
对于C项：
如果项目[0]！=项目[1]：
返回错误
返回真值
C=拉链（干净（A），干净（B））
#清洁（A）：[1,2,3,4,5,6,7,8,9]
#清洁（B）：[1,2,3,4,5,6,7,8,9]
#名单（C）：[（1,1）、（2,2）、（3,3）、（4,4）、（5,5）、（6,6）、（7,7）、（8,8）、（9,9）]
#验证（C）：真
您的问题是什么？在问题中添加了粗体格式。如何区分噪波值和所需值？
返回\u对（a，B，validate）=返回\u对（B，a，validate）
是一个必要条件吗？很多事情都不清楚。什么是“配对”？这是否意味着一对指数i和j使得a[i]=B[j]？从集合A，B开始的句子描述了集合C，它是。。。想要的答案是什么？但似乎不可能是这样，因为C可以是几乎任何对的序列，例如对（A[1]，B[1]），（A[2]，B[2]），等等。如果这是一个（近似）答案，那么你的问题相当于在两个字符串之间找到最长的公共子序列（LCS），但每个匹配都有权重。这可以用动态规划在O（n^2）中最优地解决。这假设噪声可以独立于集合A和集合B之间的关联进行评估，但事实并非如此。噪波就是任何无法通过相关数据中的正确配对进行验证的东西。该示例使用非零等式来简化问题。被问的问题与A、B和validate中的细节无关。当你没有向像我这样的人解释清楚时，你会得到这些无用的答案
A = [0,0,0,1,2,0,3,4,0,5,6,0,7,0,0,8,0,0,9]
B = [1,2,0,0,0,0,0,3,0,0,4,0,5,6,0,0,7,0,0,8,0,9]
B1 = [1,2,0,0,0,0,0,3,0,0,4,0,5,6,0,0,7,7,7,0,0,8,0,9]

def validate(a,b):
  return a and b and a==b

def return_pairs(A,B, validation):
  ret = []    
  x,y = 0,0    
  # Do loops and index changes...
    if validation(A[x], B[y]):
        ret.append((A[x], B[y]))
  return ret

assert zip(range(1,10), range(1,10)) == return_pairs(A,B,validate)
assert zip(range(1,10), range(1,10)) == return_pairs(A,B1,validate)

def return_pairs(A,B, validation):
  ret = []

  used_x, used_y = -1,-1
  for x, _x in enumerate(A):
    for y, _y in enumerate(B):
        if x <= used_x or y <= used_y:
            continue
        if validation(A[x], B[y]):
            used_x,used_y = x,y
            ret.append((A[x], B[y]))
  return ret

A = [0,0,0,1,2,0,3,4,0,5,6,0,7,0,0,8,0,0,9]
B = [1,2,0,0,0,0,0,3,0,0,4,0,5,6,0,0,7,0,0,8,0,9]

def clean(oldList):
    newList = []
    for item in oldList:
        if 0<item and (not newList or item>newList[-1]):
            newList.append(item)
    return newList
    
def validate(C):
    for item in C:
        if item[0] != item[1]:
            return False
    return True

C = zip(clean(A),clean(B))

#clean(A):[1, 2, 3, 4, 5, 6, 7, 8, 9]
#clean(B):[1, 2, 3, 4, 5, 6, 7, 8, 9]
#list(C):[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]
#validate(C): True