检查字符串的字母是否在另一个字符串中按顺序排列

Question

如果它只是检查test_string中的字母是否也在control_string中，

我不会遇到这个问题。

我将简单地使用下面的代码。

if set(test_string.lower()) <= set(control_string.lower()):
    return True

但我也面临着一个相当复杂的任务，即辨别是否重叠的字母

control_string与test_string中的顺序相同。

例如，

test_string = 'Dih'
control_string = 'Danish'
True

test_string = 'Tbl'
control_string = 'Bottle'
False

我想过使用for迭代器来比较字母表的索引，但是很难想到合适的算法。

for i in test_string.lower():
    for j in control_string.lower():
        if i==j:
            index_factor = control_string.index(j)

我的计划是将主要指标因子与下一个因子进行比较，如果主要指数因子大于另一个，则该函数返回False。

我被困在如何比较for循环中的那些index_factors。

我该如何处理这个问题？

Answer 1

你可以只join在你的人物test字符串的正则表达式 ，允许任何其它字符.*之间，然后re.search在该模式control字符串。

>>> test, control = "Dih", "Danish"
>>> re.search('.*'.join(test), control) is not None
True
>>> test, control = "Tbl", "Bottle"
>>> re.search('.*'.join(test), control) is not None
False

---

如果不使用正则表达式，你可以创建一个iter从control字符串和使用两个嵌套循环^，1） break从内环路荷兰国际集团和else返回False ，直到所有字符test中发现的control 。 尽管control已经是可迭代的，但创建iter很重要，这样内部循环将在上次停止的地方继续。

def check(test, control):
    it = iter(control)
    for a in test:
        for b in it:
            if a == b:
                break
        else:
            return False
    return True

您甚至可以使用all和any在一行（两行）中执行此操作：

def check(test, control):
    it = iter(control)
    return all(any(a == b for b in it) for a in test)

两种方法的复杂度应为O（n），其中n为最大字符数。

^1）这在概念上与@jpp的相似，但恕我直言更清楚。

Answer 2

这是一个解决方案。 我们的想法是通过迭代control串的第一和如果下一个匹配产生一个值test字符。 如果匹配总数等于test长度，则满足您的条件。

def yield_in_order(x, y):
    iterstr = iter(x)
    current = next(iterstr)
    for i in y:
        if i == current:
            yield i
            current = next(iterstr)

def checker(test, control):
    x = test.lower()
    return sum(1 for _ in zip(x, yield_in_order(x, control.lower()))) == len(x)

test1, control1 = 'Tbl', 'Bottle'
test2, control2 = 'Dih', 'Danish'

print(checker(test1, control1))  # False
print(checker(test2, control2))  # True

@ tobias_k的答案有更清晰的版本。 如果你想要一些额外的信息，例如在发现中断之前对齐了多少个字母，你可以简单地调整checker函数以返回sum(1 for _ in zip(x, yield_in_order(...))) 。

Answer 3

递归是解决此类问题的最佳方法。 这是检查顺序排序的一个。

def sequentialOrder(test_string, control_string, len1, len2): 

    if len1 == 0:     # base case 1
        return True

    if len2 == 0:     # base case 2
        return False

    if test_string[len1 - 1] == control_string[len2 - 1]: 
        return sequentialOrder(test_string, control_string, len1 - 1, len2 - 1)  # Recursion 

    return sequentialOrder(test_string, control_string, len1, len2-1)

test_string = 'Dih'
control_string = 'Danish'

print(isSubSequence(test_string, control_string, len(test_string), len(control_string)))

输出：

True

和False的

test_string = 'Tbl'
control_string = 'Bottle'

这是一个迭代的方法，做同样的事情，

def sequentialOrder(test_string,control_string,len1,len2): 

    i = 0
    j = 0

    while j < len1 and i < len2: 
        if test_string[j] == control_string[i]:     
            j = j + 1    
        i = i + 1

    return j==len1 

test_string = 'Dih'
control_string = 'Danish'

print(sequentialOrder(test_string,control_string,len(test_string) ,len(control_string)))

Answer 4

一种简单的方法是使用sorted中的key参数，它作为排序比较的关键：

def seq_order(l1, l2):
    intersection = ''.join(sorted(set(l1) & set(l2), key = l2.index))
    return True if intersection == l1 else False

因此，这是计算两个集合的交集并根据较长的字符串对其进行排序。 完成后，您只需要将结果与较短的字符串进行比较，看它们是否相同。

该函数相应地返回True或False。 使用您的示例：

seq_order('Dih', 'Danish')
#True

seq_order('Tbl', 'Bottle')
#False

seq_order('alp','apple')
#False

Answer 5

使用发电机的优雅解决方案：

def foo(test_string, control_string):
    if all(c in control_string for c in test_string):
        gen = (char for char in control_string if char in test_string)
        if all(x == test_string[i] for i, x in enumerate(gen)):
            return True
    return False

print(foo('Dzn','Dahis')) # False
print(foo('Dsi','Dahis')) # False
print(foo('Dis','Dahis')) # True

首先检查test_string中的所有字母test_string都包含在control_string 。 然后检查订单是否与test_string订单类似。

Answer 6

您可以使用find(letter, last_index)查找已处理字母后所需字母的出现。

def same_order_in(test, control):
    index = 0
    control = control.lower()
    for i in test.lower():
        index = control.find(i, index)
        if index == -1:
            return False
        # index += 1 # uncomment to check multiple occurrences of same letter in test string  
    return True

如果测试字符串有重复的字母，如：

test_string = 'Diih'
control_string = 'Danish'

使用注释行same_order_in(test_string, control_string) == True

并使用未注释的行same_order_in(test_string, control_string) == False