在不使用正则表达式的情况下在字符串中查找模式

Question

I'm trying to find a pattern in a string. Example:

trail = ' AABACCCACCACCACCACCACC " one can note the " ACC " repetition after a prefix of AAB; so the result should be AAB(ACC)

Without using regex 'import re' how can I do this. What I did so far:

    def get_pattern(trail):
        for j in range(0,len(trail)):
            k = j+1
            while k<len(trail) and trail[j]!=trail[k]:
                k+=1
            if k==len(trail)-1:
                continue

            window = ''
            stop = trail[j]
            m = j
            while  m<len(trail) and k<len(trail) and trail[m]==trail[k]:
                window+=trail[m]
                m+=1
                k+=1
                if trail[m]==stop and len(window)>1: 
                    break

            if len(window)>1:
                prefix=''
                if j>0:
                    prefix = trail[0:j]
                return prefix+'('+window+')'
            
        return False

This will do (almost) the trick because in a use case like this: " AAAAAAAAAAAAAAAAAABDBDBDBDBDBDBDBDBDBDBDBDBDBDBDBD " the result is AA but it should be: AAAAAAAAAAAAAAAAAA(BD)

Answer 1

The issue with your code is that once you find a repetition that is of length 2 or greater, you don't check forward to make sure it's maintained. In your second example, this causes it to grab onto the 'AA' without seeing the 'BD's that follow.

Since we know we're dealing with cases of prefix + window, it makes sense to instead look from the end rather than the beginning.

def get_pattern(string):
    
    str_len = len(string)
    
    splits = [[string[i-rep_length: i] for i in range(str_len, 0, -rep_length)] for rep_length in range(1, str_len//2)]

    reps = [[window == split[0] for window in split].index(False) for split in splits]
    
    prefix_lengths = [str_len - (i+1)*rep for i,rep in enumerate(reps)]
    
    shortest_prefix_length = min(prefix_lengths)
    
    indices = [i for i, pre_len in enumerate(prefix_lengths) if pre_len == shortest_prefix_length]
    
    reps = list(map(reps.__getitem__, indices))
    splits = list(map(splits.__getitem__, indices))
    
    max_reps = max(reps)

    window = splits[reps.index(max_reps)][0]

    prefix = string[0:shortest_prefix_length]
    
    return f'{prefix}({window})' if max_reps > 1 else None

splits uses list comprehension to create a list of lists where each sublist splits the string into rep_length sized pieces starting from the end.

For each sublist split , the first split[0] is our proposed pattern and we see how many times that it's repeated. This is easily done by finding the first instance of False when checking window == split[0] using the list.index() function. We also want to calculate the size of the prefix. We want the shortest prefix with the largest number of reps. This is because of nasty edge cases like jeifjeiAABBBBBBBBBBBBBBAABBBBBBBBBBBBBBAABBBBBBBBBBBBBBAABBBBBBBBBBBBBB where the window has B that repeats more than the window itself. Additionally, anything that repeats 4 times can also be seen as a double-sized window repeated twice.

If you want to deal with an additional suffix, we can do a hacky solution by just trimming from the end until get_pattern() returns a pattern and then just append what was trimmed:

def get_pattern_w_suffix(string):
    
    for i in range(len(string), 0, -1):
        pattern = get_pattern(string[0:i])
        
        suffix = string[i:]
        
        if pattern is not None:
            return pattern + suffix
        
    return None

However, this assumes that the suffix doesn't have a pattern itself.