从Python中的列表中删除重复的整数序列

Question

I have a list of integers that I need to remove duplicate sequences from, and the logic is doing my head in.

I've been trying to modify this to what I need, however that only returns one number pertaining to the length of the repeating sequence, and it only counts from the starting integer.

This is as far as I've gotten so far:

def findRep(rmRepList):
    #Array to hold [starting position, length] of repeating sequences
    repList = []
    #For each industry listed
    for industry in rmRepList:
        #Maximum starting position
        maxStartPos = len(industry)-2
        #For each possible starting point of repetition
        for start in range(1,maxStartPos):
            #Limit on how long the repetition can be
            maxLen = math.ceil((len(industry)-start)/2)

            #For each possible length (2 because already canceled out repeating resources in genAllLoop)
            for i in range(2,maxLen):
                #If the next 'i' integers repeat
                if industry[start:i+start] is industry[i+start:2*i+start]:
                    repList = [start,i]
                    industry = rmRep(repList, industry)

                #If reached end of list
                if 2*i+start+1 == len(industry):
                    #End loop
                    break

def rmRep(rmProp, loop):
    #Sequence of resources to drop
    rmSeq = [loop[rmProp[0]:rmProp[0]+rmProp[1]]]
    #Debugging statement
    print(rmSeq)
    loop.remove(rmSeq)
    return(loop)name = username_entry.get()

rmRepList is a list of lists, holding each list I need to analyse.

So for example, if given a list

rmRepList = [[0,1,2,1,2,1,0],[0,1,2,1,2,1,2,3,4,5,3,4,5,6,0]]

I would need it to return [[0,1,2,1,0], [0,1,2,3,4,5,6,0]]

Right now, the code isn't even reaching the rmRep subroutine. I have a horrible feeling I'm going about this all wrong. I don't like that I need so many loops in the code, especially as the actual lists I have to analyse are hundreds of digits long. Is there a simpler way to do this?

---

EDIT: If it helps, I can guarantee that the lists will not repeat one integer over and over (eg [0,0,0,1,0] won't happen).

Also, the first and last number in the lists will always be the same.

Answer 1

Part of the answer : detect your repeated sequences.

listA = [0,1,2,1,2,1,2,3,4,5,3,4,5,6,0]
listB = [0,1,2,1,2,1,0]

def get_repeated_seq(seq, start, length):
    ref = seq[start:start+length]
    #print("Ref", ref)
    for pos in range(start+length, len(seq)-length):
        compare = seq[pos:pos+length]
        #print("Pos", pos, compare)
        if compare == ref:
            print("Found", ref, "at", pos)
            return pos
    return False

def get_repeated_seqs(seq):
    for size in reversed(range(2, len(seq)/2)):
        for pos in range(0, len(seq)-size):
            print("Check rep starting at pos %s for size %s" % (pos, size))
            get_repeated_seq(seq, pos, size)

print(get_repeated_seqs(listA))

Then you can remove them according to your removal strategy (largests ? smallests ?)

EDIT : to be clear that it works (and adding some removal by the same time)

listA = [0,1,2,1,2,1,2,3,4,5,2,1,3,4,5,2,1,6,0]
listB = [0,1,2,1,2,1,0]

def get_repeated_seq(seq, start, length):
    ref = seq[start:start+length]
    #print("Ref", ref)
    for pos in range(start+length, len(seq)-length):
        compare = seq[pos:pos+length]
        #print("Pos", pos, compare)
        if compare == ref:
            #print("Found", ref, "at", pos)
            return pos, length
    return False

def get_repeated_seqs(seq):
    reps = []
    for size in reversed(range(2, len(seq)/2)):
        for pos in range(0, len(seq)-size):
            #print("Check rep starting at pos %s for size %s" % (pos, size))
            rep = get_repeated_seq(seq, pos, size)
            if rep:
                reps.append(rep)
    return reps

def remove_repeated_seqs(seq, reps):
    # need to backup seq ?
    for rep in reps:
        overlaps = False
        for pos in range(rep[0], rep[0]+rep[1]):
            if seq[pos] == "*":
                overlaps = True
        if not overlaps:
            for pos in range(rep[0], rep[0]+rep[1]):
                seq[pos] = "*"
    out = []
    for item in seq:
        if item != "*":
            out.append(item)
    return out


reps = get_repeated_seqs(listB)
rem = remove_repeated_seqs(listB, reps)
#print(rem)
print(rem==[0,1,2,1,0])

reps = get_repeated_seqs(listA)
rem = remove_repeated_seqs(listA, reps)
#print(rem)
print(rem==[0,1,2,3,4,5,6,0])

outputs True and True :)

EDIT2: no -1 to go up to the end of a list in a for range loop..