如何在列表中查找项目数组并在python中查找下一个项目

Question

I have a list such as ["scissors", "rock", "rock", "paper", "rock" ... (more than 100,000 items)] and want to find an array of item such as ["rock", rock", "paper"] in the list, find all the same patterns, and identify the next items following the pattern in all cases.

For example,

original list = ["scissors", "rock", "rock", "paper", "rock", "scissors", "rock", "paper", "scissors"] 

the pattern I want to identify = ["rock", "paper"] (there are 2 in the list above)

the eventual next items of the patterns I'm looking for = "rock" and "scissors".

How could I code this?

Answer 1

This will collect the indices where the first part of the pattern occurred:

original = ["scissors", "rock", "rock", "paper",
            "rock", "scissors", "rock", "paper", "scissors"]

pattern = ["rock", "paper"]

indices = []
for index, item in enumerate(original):
    if item == pattern[0] and index + 1 < len(original):
        if original[index + 1] == pattern[1]:
            indices.append(index)

# where in the original is the pattern found? starting at index...
print(indices)

# how many times was the pattern found?
print(len(indices))

# Result:    
# [[2, 6]
# 2

If you want to look for several patterns and identify where each one occurred in the original list and how often:

original = ["scissors", "rock", "rock", "paper",
            "rock", "scissors", "rock", "paper", "scissors"]

patterns = [["rock", "paper"], ["scissors", "rock"]]


def look_for_patterns(ori, pat):
    indices = []
    length = len(ori)
    for p in pat:
        sublst = []
        for index, item in enumerate(ori):
            if item == p[0] and index + 1 < length:
                if ori[index + 1] == p[1]:
                    sublst.append(index)
        indices.append(sublst)
    return indices, [len(i) for i in indices]

# where in the original is the pattern found? starting at index...
print(look_for_patterns(original, patterns)[0])

# how many times was the pattern found?
print(look_for_patterns(original, patterns)[1])

# Result:    
# [[2, 6], [0, 5]]
# [2, 2]

Answer 2

How about this,

def indexofsublist(l, sublist):
    l1, l2 = len(l), len(sublist)
    for idx in range(l1):
        if l[idx:idx+l2] == sublist:
            return idx

original_list = ["scissors", "rock", "rock", "paper", "rock", "scissors", "rock", "paper", "scissors"] 
identify = ["rock", "paper"]

idx = indexofsublist(original_list, identify)   # 2
next_idx = idx + len(identify)                  # 4

Answer 3

target = ["rock", "paper"]
original = ["scissors", "rock", "rock", "paper", "rock", "scissors", "rock", "paper", "scissors"]

def combinations(iterable, length):
    return [iterable[i: i + length] for i in range(len(iterable) - length + 1)]

combinations = combinations(original, 2)
indices = [i for i, x in enumerate(combinations) if x == target]

for index in indices:
    print(combinations[index+1][-1])

output:

rock
scissors

What did the code do:

1. Uses method combinations to print all 2 consecutive elements combinations
2. Finds all occurrences indices.
3. Prints the last element of combinations[index+1] , in which is what you look for.

Answer 4

Or this:

pattern = ["rock", "paper"]
lenpat=len(pattern)
original = ["scissors", "rock", "rock", "paper","rock", "scissors", "rock", "paper", "scissors"]
index=[]
for i in range(len(original)-lenpat):
    if original[i:i+lenpat]==pattern:
        index.append(i)

print original
print pattern
print index

Answer 5

The problem with the answers till now is that their great but their O(n) for each query unfortunately. You need a suffix trie to answer the queries in O(k) where k is pattern length.

Here is a good lib for the same https://github.com/ptrus/suffix-trees pip install suffix-trees

However in your case a bit more processing is left to do.. Since the choices will only be from 'rock', 'papers' and 'scissors' (assuming lizard and spock don't join in later :-P ) normalize and replace them with 'r','p' and 's'

Use "".join(new_arr) and your ready to use the github link above. Drop a comment if you have a prob or want more explanation.

Answer 6

If you have a very long list to browse, recursion might be adapted (and funnier for what it's worth):

def find_pattern_and_followings(pattern, rest, followings=None,
                                pattern_indexes=None, curr_index=0):
    if len(rest) < len(target):
        return followings, pattern_indexes
    followings = [] if followings is None else followings
    pattern_indexes = [] if pattern_indexes is None else pattern_indexes
    # Check if the first elements match the pattern
    # and move to next elements
    if len(rest) >= len(target):
        if rest[0:len(target)] == target:
            pattern_indexes.append(curr_index)
            if len(rest) > len(target):
                followings.append(rest[len(target)])
            rest = rest[len(target):]
            curr_index += len(target)
        else:
            rest = rest[1:]
            curr_index += 1   
        return(find_pattern_and_followings(pattern, rest, 
                                           followings=followings, 
                                           pattern_indexes=pattern_indexes,
                                           curr_index=curr_index))

Returns:

(['rock', 'scissors'], [2, 6])

What the function does is browse the list item by item, if the first items of the list match the pattern it stores interesting information. Then it removes the already-scanned elements and starts again until the list is too short to contain a pattern.