way to find a sequence in a list with the same number of repetitions of two integers?

I have this function that takes as arguments a list of integers and two integers. I have to find the longest sequence where the two integers repeat the same number of times.
For example if the list is

[9, 5, 7, 33, 9, 5, 5, 5, 8, 5, 33, 33, 6, 15, 8, 5, 6]

and i1 = 33 and i2 = 5, the function must return 9, because the longest sequence is 8, 5, 33, 33, 6, 15, 8, 5, 6 (in fact 33 and 5 both repeat twice).

I thought about creating a count from 0 and using a for loop on the elements of the list. Then, if the current element equals i1 or i2, the count goes up by 1.
I now need to control the number of repetitions, but I'm stuck.

Here's a recursive solution (not efficient but short and simple) that checks subranges from larger to smaller recursing until it finds one that has the same count of each number in it:

def getMaxSeq(L,a,b):
    if L.count(a) == L.count(b): return L
    return max(getMaxSeq(L[1:],a,b),getMaxSeq(L[:-1],a,b),key=len)

output:

L = [9, 5, 7, 33, 9, 5, 5, 5, 8, 5, 33, 33, 6, 15, 8, 5, 6]
        
print(getMaxSeq(L,5,33))      # [8, 5, 33, 33, 6, 15, 8, 5, 6]
print(len(getMaxSeq(L,5,33))) # 9 

Using a queue to implement a breadth first traversal of subranges in decreasing order of length would be a bit more efficient:

from collections import deque
def getMaxSeq(L,a,b):
    ranges = deque([L])
    while L.count(a) != L.count(b):
        ranges.extend((L[1:],L[:-1]))
        L = ranges.popleft()
    return L

I would approach this by converting the list to a balance list and see when the numbers balance each other out. I would then loop through all the starting indices and check each sequence that comes after that, and update my record when the balance is 0 and the sequence length is longer than the previous record.

l = [9, 5, 7, 33, 9, 5, 5, 5, 8, 5, 33, 33, 6, 15, 8, 5, 6]
num1 = 5
num2 = 33

# create list where num1 = 1, num2 = -1, else 0
balance_list = [(1 if x == num1 else -1) if x in [num1, num2] else 0 for x in l]
record = (0, 0)

print(balance_list)

for seq_start in range(len(balance_list)):
    # if length of seq_start to end is less than record length, no need to search further
    if (len(balance_list)-1 - seq_start) <= (record[1] - record[0]):
        break
    
    balance = 0
    for seq_end, val in enumerate(balance_list[seq_start:], seq_start):
        balance += val
        
        # num1 occurs as frequently as num2, and the sequence length is longer
        if balance == 0 and (seq_end - seq_start) > (record[1] - record[0]):
            record = (seq_start, seq_end)
        # if more numbers are required to get balance to 0, we've hit a dead end
        elif abs(balance) > len(balance_list[seq_start:])-1:
            break
    
print(record)

Output:

(8, 16)

This is by no means a perfect solution and a dynamic programming approach would be much more efficient, but I've tried to add optimizations to speed up the search (e.g. quitting the search when no new record can be found).

Neither the most elegant nor the most performant code but it works fine for this example.

def longest_sequence(lst,x,y):
    def helper(lst,x):
        n = len(lst)
        seqs = []
        for i in range(0,n):
            if lst[i]==x:
                j=0
                sq=[]
                while i+j<n:
                    if lst[i+j]==x:
                        sq.append(i+j)
                        j=j+1
                        seqs.append(sq)
                    else:
                        break
        return seqs
    x_seqs = helper(lst,x)
    y_seqs = helper(lst,y)
    x_max_seq = max(x_seqs, key = len)
    y_max_seq = max(y_seqs, key = len)

    max_len = min(len(x_max_seq),len(y_max_seq))

    return x_max_seq[:max_len],y_max_seq[:max_len]

my_list=[9, 5, 7, 33, 9, 5, 5, 5, 8, 5, 33, 33, 6, 15, 8, 5, 6]
x = 33
y = 5
xsq,ysq=longest_sequence(my_list,x,y)
print(xsq,ysq)

and it returns the indices for the longest sequence for both x an y.