在列表或数组中搜索与子列表的最佳匹配（通过数值差异）？

Question

我有一个这样的值列表：

[ 669,  592,  664, 1005,  699,  401,  646,  472,  598,  681, 1126, ...]

我的问题是，给定一小部分数字，例如：

[ 400, 650, 475 ]

如何获取最接近子列表的子列表，例如：

[401,  646,  472, ]  # difference = 1 + 4 + 3 = 8

我开始考虑在堆树中组织所有长度的子列表，但后来我意识到我很可笑，肯定有人以前遇到过这个问题，但我找不到任何东西。你认为我需要这样做吗？

有没有办法在列表中搜索匹配（或最接近）搜索条件的最佳子列表（连续）？

Answer 1

快速 NumPy 解决方案：

import numpy as np

# Taken from https://rigtorp.se/2011/01/01/rolling-statistics-numpy.html
def rolling_window(a, window):
    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
    strides = a.strides + (a.strides[-1],)
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

lst = np.array([669, 592, 664, 1005, 699, 401, 646, 472, 598, 681, 1126])
small = np.array([400, 650, 475])

sublists = rolling_window(lst, len(small))

# Only find the best match
match = sublists[np.abs(sublists - small).sum(axis=1).argmin()]
print(match)

# Array of matches, best to worst
match = sublists[np.abs(sublists - small).sum(axis=1).argsort()]
print(match)

时间安排：

In [1]: import numpy as np
   ...:
   ...: # Taken from https://rigtorp.se/2011/01/01/rolling-statistics-numpy.html
   ...: def rolling_window(a, window):
   ...:     shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
   ...:     strides = a.strides + (a.strides[-1],)
   ...:     return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
   ...:
   ...: lst = np.array([669, 592, 664, 1005, 699, 401, 646, 472, 598, 681, 1126])
   ...: small = np.array([400, 650, 475])
   ...:
   ...: sublists = rolling_window(lst, len(small))

In [2]: %timeit sublists[np.abs(sublists - small).sum(axis=1).argmin()]
6.43 µs ± 51.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [3]: %timeit sublists[np.abs(sublists - small).sum(axis=1).argsort()]
10 µs ± 1.03 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [4]: lst = [ 669,  592,  664, 1005,  699,  401,  646,  472,  598,  681, 1126 ]
   ...: small = [ 400, 650, 475 ]

In [5]: %timeit min((lst[i:i + len(small)] for i in range(len(lst) - len(small) + 1)), key=lambda sub: sum(abs(a - b) for a, b in zip(small, sub)))
17.4 µs ± 1.39 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [6]: %timeit sorted((lst[i:i + len(small)] for i in range(len(lst) - len(small) + 1)), key=lambda sub: sum(abs(a - b) for a, b in zip(small, sub)))
15.9 µs ± 208 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

如果列表很长，我预计速度会更快。

Answer 2

您可以遍历较长列表的子列表并将关键函数传递给min：

lst = [ 669,  592,  664, 1005,  699,  401,  646,  472,  598,  681, 1126 ]
small = [ 400, 650, 475 ]
match = min((lst[i:i + len(small)] for i in range(len(lst) - len(small) + 1)), key=lambda sub: sum(abs(a - b) for a, b in zip(small, sub)))
print(match) # 401,  646,  472

如果您想要一个最佳匹配到最差匹配的排序列表，只需将min 替换为sorted。

print(sorted((lst[i:i + len(small)] for i in range(len(lst) - len(small) + 1)), key=lambda sub: sum(abs(a - b) for a, b in zip(small, sub))))
[[401, 646, 472], [472, 598, 681], [669, 592, 664], [646, 472, 598], [699, 401, 646], [1005, 699, 401], [592, 664, 1005], [664, 1005, 699], [598, 681, 1126]]

如果你觉得单行字很可怕（我必须承认我确实有，哈哈），这里有一个更易读的版本：

lst = [ 669,  592,  664, 1005,  699,  401,  646,  472,  598,  681, 1126 ]
small = [ 400, 650, 475 ]

def key(sublist):
    result = 0
    for a, b in zip(sublist, small):
        result += abs(a - b)
    return result

sublist_iter = (lst[i:i + len(small)] for i in range(len(lst) - len(small) + 1))
match = min(sublist_iter, key=key) # or `sorted`
print(match)

Answer 3

你可以这样做：

import operator
numbers = [ 669,  592,  664, 1005,  699,  401,  646,  472,  598,  681, 1126, 669,  592,  664]

search =  [ 400, 650, 475 ]

diffs = {}

for index in range(len(numbers)-len(search)+1):
    subset = numbers[index:index+len(search)]
    diff = sum([abs(x-y) for x,y in zip(subset,search)])
    diffs[diff] = diffs.get(diff,[]) + [subset]

for key, value in sorted(diffs.items(), key=operator.itemgetter(0)):
    print("{} : {}".format(key, value))

输出：

8 : [[401, 646, 472]]
330 : [[472, 598, 681]]
516 : [[669, 592, 664], [669, 592, 664]]
547 : [[646, 472, 598]]
719 : [[699, 401, 646]]
728 : [[1005, 699, 401]]
736 : [[592, 664, 1005]]
843 : [[664, 1005, 699]]
862 : [[1126, 669, 592]]
880 : [[598, 681, 1126]]
951 : [[681, 1126, 669]]

它是按顺序打印的，如果你有两次相同的值，它会打印两个列表来表示这个差异。

Answer 4

很惊讶没有人提供numpy 解决方案：

import numpy as np

numbers = np.array([669, 592, 664, 1005, 699, 401, 646, 472, 598, 681, 1126])
searchs = [400, 650, 475]

for search in searchs:
    result = numbers[np.abs(numbers - search).argmin()]
    print(result)

输出：

401
646
472