How sort specific items in specific order in a list

Question

Hello everybody I am trying to do an algorithm that sort specific items in a specifig order. Let's assume that we have a list of items : [1, 2, 1, 3, 3, 3, 2, 2, 2, 2, 2, 1, 3, 2, 2, 1] there is three different type of items here : 1, 2 and 3. I want to sort this list in order to have a sequence of items that follows the same types. In the sorting process we can't move the position's items, we just can remove some items and the result should be the longest. The result of this algorithm should be :
[1, 1, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2] I don't know why my algorithm doesn't work :

# start list
givenList = [1, 2, 1, 3, 3, 3, 2, 2, 2, 2, 2, 1, 3, 2, 2,1]
# whish list (just for an example)
whish = [1, 1, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2]
# list grouped by items ( [ [1], [2], [1], [3, 3, 3], [2, 2, 2, 2, 2] ....])
sortedList = []

# we group the elements
lastElement=0
for currentElement in givenList :
  if currentElement != lastElement :
    sortedList.append([currentElement])
    lastElement=currentElement
  else : sortedList[-1].append(currentElement)

# we print the grouped items
for index, element in enumerate(sortedList) :
  print("Bloc : ", index , " contient : " , element)

# we sort the same elements by group
result=[]
for index, element in enumerate(sortedList) :
  # we pass if it's the first group because he has no backward element
  if(index == 0) : continue
  # we pass if it's the last group because he has no afterward element
  if(index == len(sortedList) - 1) : continue
  # backward group
  backwardList = sortedList[index - 1]
  # current group
  currentList = sortedList[index]
  # afterward group
  forwardList = sortedList[index + 1]
  # if the backward groupelement type is the same as the forward
  if backwardList[0] == forwardList[0] :
    # and if the backwardlist contains more element that the current group
    if(len(backwardList) >= len(currentList)) :
      # we add the concatenation of the backwards and the forwards group
      result.append(backwardList + forwardList)
  elif backwardList[0] != forwardList[0] :
    # else we just add the current group
    result.append(currentList)
    
# we degroup the grouped and sorted list
resultSorted=[]
for e in result:
  for i in e:
    resultSorted.append(i)

# 
print("#"*20)
print("Given : ", givenList)
print("Whish : ", whish)
print("Result : ", resultSorted)
print("#"*20)

Answer 1

You can try this implementation with itertools.groupby :

from itertools import groupby

l = [1, 2, 1, 3, 3, 3, 2, 2, 2, 2, 2, 1, 3, 2, 2, 1]

def get_max(elems, current_elems=None):
    if current_elems is None:
        current_elems = []

    for idx, (color, count) in enumerate(elems):
        if color in [c for c, _ in current_elems[:-1]]:
            continue
        yield current_elems + [(color, count)]
        yield from get_max( elems[idx+1:], current_elems + [(color, count)] )

elems = [(v, sum(1 for _ in g)) for v, g in groupby(l)]
l, _ = max(((v, sum(c for _, c in v)) for v in get_max(elems)), key=lambda k: k[1], default=[[], None])

out = []
for v, g in groupby(l, key=lambda k: k[0]):
    for _, c in g:
        out.extend([v] * c)

print(out)

Prints:

[1, 1, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2]

---

Other test cases:

l = [1, 2, 3]       # [1, 2, 3]
l = [1, 2, 3, 1, 1] # [2, 3, 1, 1]

Answer 2

The best solution is :

def solve(l):
    def aux(i, current, exclude):
        if i==len(l):
            return []
        val = l[i]
        if val in exclude:
            return aux(i+1, current, exclude)
        elif val == current:
            return [val] + aux(i+1, current, exclude)
        else:
            exclude.add(current)
            s1 = [val] + aux(i+1, val, exclude)
            exclude.remove(current)
            s2 = aux(i+1, current, exclude)
            if len(s1)>len(s2):
                return s1
            return s2

    return aux(0, -1, set())