Question

I apologize if this question has already been answered in:
Topological Sort with Grouping

However, I do not completely understand the answer as I am new to graph theory.

I have the following items:

c01,a11,b12,a21, b22,c23, c31,b32, a33.

Each of these is a three tuple.

Tup[0]: ‘letter to group by’

Tup[1]: ‘group number where dependencies are valid’

Tup[2]: ‘sort order of dependencies’

I would like to group by tup[0] as closely as possible while maintaining the sort order described by the groups in item[1] and item[2]. Items 1,2 allow us to create the dependencies, from here we just need to create the groups.

so we can create the following depencies:

a11<-b12

a21<-b22, b22<-c23

c31<-b32, b32<-a33

c01

From here I would like to group by letter while maintaining the dependencies. One such solution would be

a11, a21, b12, b22, c01, c23, c31, b32, a33

We can see that a11<-b12, a21<-b22<-c23, c31<-b32<-a33, c01

Any thoughts would be greatly appreciated,
Thanks,
Rob

one solution:

def groupPreserveSorted(listOfPairs):
    """

    we want to group by tup[0], but maintain the order passed in according to tup[1]

    >>> lop = [['A',0], ['B',1], ['C',0], ['D',2], ['E',2]]
    >>> print groupPreserveSorted(lop)
    [('A', 0), ('B', 1), ('C', 0), ('D', 2), ('E', 2)]

    >>> lop = [['c',0], ['a',1], ['b',1], ['a',2], ['b',2], ['a', 3], ['b', 3], ['c', 3], ['a', 4], ['b', 4]]
    >>> print groupPreserveSorted(lop)
    [('c', 0), ('a', 1), ('a', 2), ('a', 3), ('a', 4), ('b', 1), ('b', 2), ('b', 3), ('b', 4), ('c', 3)]

    >>> lop = [['c',0], ['a',1], ['b',1], ['a',2], ['b',2], ['a', 3], ['b', 3], ['c', 3], ['c', 4], ['a', 4], ['b', 4]]
    >>> print groupPreserveSorted(lop)
    [('c', 0), ('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 3), ('c', 4), ('a', 4), ('b', 4)]


    """
    groupCount = 0
    groupMap = {} #map contains the "level" to the highest group
    maxGroupDic = {} #this contains a map from tup[1] to the highest level attained by tup[1]
    groupTypeToMapItem = {} #this contains all the levels that items in tup[0] are placed on

    for groupType, dependencyGroup in listOfPairs:
        if groupCount == 0:
            groupMap[0] = [(groupType, dependencyGroup)]
            maxGroupDic[dependencyGroup] = 0
            groupTypeToMapItem[groupType] = [0]
            groupCount+=1
        else:
            if groupType not in groupTypeToMapItem:#need to make new group
                groupMap[groupCount] = [(groupType, dependencyGroup)]
                maxGroupDic[dependencyGroup] = groupCount
                groupTypeToMapItem[groupType] = [groupCount]
                groupCount+=1
            else:
                maxGroupTypeItem  = groupTypeToMapItem[groupType][-1]
                if dependencyGroup in maxGroupDic: #then we just need to check where to add to a new level or to an old level
                    maxItem = maxGroupDic[dependencyGroup]
                    if maxItem>maxGroupTypeItem: #then we need to make a enw group
                        groupMap[groupCount] = [(groupType, dependencyGroup)]
                        maxGroupDic[dependencyGroup] = groupCount
                        groupTypeToMapItem[groupType] = [groupCount]
                        groupCount+=1
                    else:
                        countToUse = [item for item in groupTypeToMapItem[groupType] if item>=maxItem][0]
                        groupMap[countToUse].append((groupType, dependencyGroup))
                        maxGroupDic[dependencyGroup]=countToUse
                else: #we haven't added this groupType yet just add to lowest level
                    countToUse = groupTypeToMapItem[groupType][0]
                    groupMap[countToUse].append((groupType, dependencyGroup))
                    maxGroupDic[dependencyGroup]=countToUse

    return flatten([groupMap[count] for count in xrange(groupCount)], depth = 1)

this is a nice solution as it is o(n), but it is definitely not the cleanest answer:)

Answer 1

This is my solution

>>> data
['c01', 'a11', 'b12', 'a21', 'b22', 'c23', 'c31', 'b32', 'a33']
>>> data="c01,a11,b12,a21, b22,c23, c31,b32, a33"
>>> data=[x.strip() for x in data.split(",")]
>>> data=sorted(data,key=operator.itemgetter(0))
>>> data=sorted(data,key=operator.itemgetter(1))
>>> data=sorted(data,key=operator.itemgetter(2))
>>> data
['c01', 'a11', 'a21', 'c31', 'b12', 'b22', 'b32', 'c23', 'a33']
>>> 

or as a single line solution

>>> data
['c01', 'a11', 'b12', 'a21', 'b22', 'c23', 'c31', 'b32', 'a33']
>>> [data.sort(key=operator.itemgetter(x)) for x in [0,1,2]]
>>> data
['c01', 'a11', 'a21', 'c31', 'b12', 'b22', 'b32', 'c23', 'a33']