检查列表是否是有效的块序列

Question

我想检查一个列表是否是一个有效的块序列，其中每个块都以某个值开始，并以相同值的下一次出现结束。例如，这是三个块的有效序列：

lst = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4, 5, 2]
       \___________/  \_____/  \_______________________/

这是一个无效的：

lst = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4]
       \___________/  \_____/  \_____ ... missing the 2 to end the chunk

我有一个解决方案，但它很糟糕。你看到更好的东西了吗？

def is_valid(lst):
    while lst:
        start = lst.pop(0)
        if start not in lst:
            return False
        while lst[0] != start:
            lst.pop(0)
        lst.remove(start)
    return True

# Tests, should print: True, False, True, False, True
print(is_valid([2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4, 5, 2]))
print(is_valid([2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4]))
print(is_valid(['I', 'N', 'O', 'A', 'I', 'L', 'L', 'T', 'R', 'X', 'I', 'I', 'N', 'X', 'F', 'T']))
print(is_valid(['T', 'I', 'N', 'I', 'X', 'R', 'O', 'F', 'T', 'I', 'N', 'I', 'X', 'L', 'L', 'A']))
print(is_valid([]))

Answer 1

为此创建解决方案的简短尝试：

def isValid(input):
   if len(input) == 0:
       return True
   firstChar = input.pop(0)
   if firstChar not in input:
       return False
   input = input[input.index(firstChar)+1:]
   isValid(input)

虽然我不认为这是最快的方法，但我认为这是一个足够有趣的方法，可以在这里包含。此外，这可以通过删除这些行来进一步优化：

if firstChar not in input:
    return False

然后将代码放在 try/except 块中，如下所示：

def isValid(input):
    if len(input) == 0:
        return True
    firstChar = input.pop(0)
    try:
        input = input[input.index(firstChar)+1:]
        isValid(input)
    except:
        return False

因为如果索引不存在，此代码将给出 ValueError

目前我还没有测试过确切的速度差异，但我确定这不是最快的方法，但它应该是相对不错的速度。

Answer 2

怎么样，从列表中创建一个iter 并在该迭代上向前搜索，直到找到next 匹配元素。请注意，这可能会失败，因为 None 可以是列表的元素；那么您应该定义并与哨兵obj = object()进行比较。

def is_valid(lst):
    it = iter(lst)
    for x in it:
        if next((y for y in it if y == x), None) is None:
            return False
    return True

---

由于我们实际上并不需要next返回的值，所以我们也可以直接使用any，同时解决default元素的问题。与next 一样，any 将使用迭代器，直到匹配元素（如果有）：

def is_valid(lst):
    it = iter(lst)
    for x in it:
        if not any(y == x for y in it):
            return False
    return True

这可以使用all 而不是外部for 循环进一步缩短：

def is_valid(lst):
    it = iter(lst)
    return all(any(y == x for y in it) for x in it)

而这个终于可以归结为同样神秘而耐人寻味的：

def is_valid(lst):
    it = iter(lst)
    return all(x in it for x in it)

每一种方式，每个元素只被访问一次，原始列表没有改变，几乎没有额外的空间，恕我直言，它甚至有点容易阅读和理解。

---

这与速度无关，但无论如何：以下是不同解决方案（以及更多变体）的一些基准测试，运行问题中的测试用例以及 1,000 个整数的两个随机列表，一个有效，一个无效， 10,000 次，在 Python 3.8.10 上：

# with long lists             # only short test lists
1.52 is_valid_index           0.22 is_valid_index
3.28 is_valid_next            0.30 is_valid_next
2.78 is_valid_for_for_else    0.13 is_valid_for_for_else
5.26 is_valid_for_any         0.32 is_valid_for_any
5.29 is_valid_all_any         0.38 is_valid_all_any
3.42 is_valid_all_any_if      0.36 is_valid_all_any_if
2.02 is_valid_all_in          0.18 is_valid_all_in
1.97 is_valid_all_in_if       0.17 is_valid_all_in_if
1.87 is_valid_for_in          0.11 is_valid_for_in

当然，都是 O(n)。对于长 1000 个元素列表，使用 index 的解决方案最快，但使用 x in it 的解决方案也不错。 any 解决方案有些落后，但在使用 generator with condition 时与 next 一样快（或慢），但仍比使用普通 for 循环时慢。 只有简短的测试列表，情况有点不同：这里，使用一个迭代器和for-for-else 和for-in 的解决方案是最快的。

Answer 3

这个问题没有完全解释我们是否需要贪婪的解决方案。

考虑一个例子 - [1, 2, 1, 1]

如果我们考虑贪心方法，则解决方案将找到第一个序列为 [1, 2, 1]，并留下 [1]。因此，将返回 False。

但如果没有贪心方法，解决方案会将 [1, 2, 1, 1] 视为完整序列并返回 True。

我运行了你提供的解决方案，它返回 False，所以我假设我们需要一个贪婪的方法。

所以，这是一种可能的解决方案：

def is_valid(lst):
    to_find = None
    
    for value in lst:
        if to_find is None:
            to_find = value
            continue
        
        if to_find is value:
            to_find = None

    return to_find is None
    
# Tests, should print: True, False, True, False, True
print(is_valid([2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4, 5, 2]))
print(is_valid([2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4]))
print(is_valid(['I', 'N', 'O', 'A', 'I', 'L', 'L', 'T', 'R', 'X', 'I', 'I', 'N', 'X', 'F', 'T']))
print(is_valid(['T', 'I', 'N', 'I', 'X', 'R', 'O', 'F', 'T', 'I', 'N', 'I', 'X', 'L', 'L', 'A']))
print(is_valid([]))

Answer 4

您似乎想确保最后一个“块”在列表末尾关闭。这应该这样做：

def is_valid(lst):
  search = None
  paired = True
  for item in lst:
    if paired:
      search = item
      paired = False
    elif search == item:
      paired = True
  return paired

这是O(n)，每个元素只检查一次，因此您无需为长输入列表的start not in lst 检查支付费用。

Answer 5

这是我对这个问题的看法。我已经针对可读性进行了优化，而不是速度（当然要保持在 O(n) 中）：

def is_valid(sequence):
    iterator = iter(sequence)
    for element in iterator:
        for other in iterator:
            if element == other:
                break
        else:
            return False
    return True

外循环的每次迭代都对应一个块。当我们这里的元素用完时，我们在块边界处结束序列，我们可以return True。否则，我们循环遍历迭代器，直到找到匹配的元素。如果我们用完了元素（一个“自然”终止的 for 循环，没有break，进入它的else）我们return False。

---

还有另一个使用itertools。我不喜欢上面的解决方案，主要是因为 next 与哨兵的神秘使用：

from itertools import dropwhile

def is_valid(iterable):
    iterator = iter(iterable)
    sentinel = object()
    for element in iterator:
        if next(dropwhile(lambda x: x != element, iterator), sentinel) is sentinel:
            return False
    return True

Answer 6

以下是该问题的替代递归解决方案。基本上只是检查下一个目标是否在列表中，然后跳到该索引再次检查。我不是这里的专家，但想尝试并贡献一种不同的方式来解决这个问题。

def is_valid(
    input_list: list, 
    target_index: int = 0):

    # If we have only one element remaining, or if an empty list is passed initially, there cannot be a pair.
    if len(input_list) <= 1:
        return False
    
    target = input_list[target_index]
    search_range = input_list[target_index + 1 :]

    # print(f"target index: {target_index}")
    # print(f"target: {target}")
    # print(f"search range: {search_range}")
    # print("-------------------------------")

    if target in search_range:

        found_target_sublist_index = search_range.index(target)

        # Plus 2: two indexes start at 0 -> off by two
        next_target_index = target_index + found_target_sublist_index + 2

        if next_target_index == len(input_list):
            return True

        return is_valid(input_list, next_target_index)
    else:
        return False


test_one = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4, 5, 2]
test_two = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9, 0, 4]
test_three = ['I', 'N', 'O', 'A', 'I', 'L', 'L', 'T', 'R', 'X', 'I', 'I', 'N', 'X', 'F', 'T']
test_four = ['T', 'I', 'N', 'I', 'X', 'R', 'O', 'F', 'T', 'I', 'N', 'I', 'X', 'L', 'L', 'A']

print(is_valid(test_one)) 
print(is_valid(test_two))
print(is_valid(test_three))
print(is_valid(test_four))

Answer 7

使用pop(0) 更改列表的成本很高且不需要。

你可以使用index...当块很大时，这可能会特别快：

def is_valid(lst):
    i = 0
    n = len(list)
    while i < n:
        try:
            i = lst.index(lst[i], i + 1) + 1
        except:
            return False
    return True