Given a list of list of integers, task is to write a function which will output another list of list of integers. It's hard to tell the nature of the desired output in words, I am writing some examples:

# list with one element will be returned
>>> func([[1, 2, 3, 4]])
[[1, 2, 3, 4]]>>> func([[1], [1, 2]])
[[1], [2]]>>> func([[1, 2], [1]])
[[1], [2]]>>> func([[1], [1, 2, 3]])
[[1], [2, 3]]>>> func([[1], [1, 2, 3], [1, 4]])
[[1], [2, 3], [4]]>>> func([[1, 2], [2, 3]])
[[1], [2], [3]]>>> func([[1], [2], [1, 2, 3]]) 
[[1], [2], [3]]>>> func([[1, 2], [1, 2, 3]])
[[1, 2], [3]]>>> func([[1], [1, 2], [1, 2, 3]])
[[1], [2], [3]]

(UPDATE) You can use the following preconditions:

1. Each inner list contains integers already sorted and there is no duplicate entry.

2. The outer list has no duplicate entry.

(UPDATE) As you asked, here's what I think I'm stuck with:

This is a problem on some optimization on a Directed Graph, with numbers as nodes and inner lists as starting points of edges (the outer list is the set of starting points of all edges). Now, you might ask, "How there be multiple start points to a single edge, which is shown in some test cases?"

This is what I am trying to do: for func ([1, 2]) the node 1 & node 2 can be merged to a single node. The output [1, 2] shows that these two can be merged.

Now look at func ([[1], [1, 2]]). The 2nd inner list tries to merge node 1 & 2 together, but the 1st inner list says node 1 cannot be merged to anything. So, the output is [[1], [2]], indicating that node 1 & node 2 are to be kept separated.

For func ([[1], [2, 3], [1, 2, 3]]), node 1 is to be separated, but node 2 & 3 can be merged; so the output would be [[1], [2, 3]]

In case of func ([[1, 2], [2, 3]]), neither node 1 & 2 nor 2 & 3 can be merged as node 1 & 3 can be merged, so the expected result is [[1], [2], [3]].

There is a list of integers also, which comprises of end points of vertices, each integer corresponds to each inner list. When elements of an inner list are merged to one, there remains only 1 edge. When they are separated, there are singleton lists, and elements from each of which is taken as starting points; the list of end points are updated accordingly.

I think it will help you to realize my needs.

This relies on the list of lists being sorted in ascending length (and the outputs needs sorting), but works with all provided input as of time of posting.

def removeFromList(elementsToRemove):def closure(list):for element in elementsToRemove:if list[0] != element:returnelse:list.pop(0)return closuredef func(listOfLists):result = []for i, thisList in enumerate(listOfLists):result.append(thisList)map(removeFromList(thisList), listOfLists[i+1:])return result

You can remove the closure using more for loops, but it looked too ugly, and too deeply nested.

Edit: based on updates, this is the naive solution to the actual problem:

from itertools import combinationsdef isSubsetOrDisjointTo(listA, listB):return all(item in listB for item in listA) or all(item not in listB for item in listA)def func(nodesToJoin):#flatten list, extracting duplicatesallNodes = sorted(set(itertools.chain(*nodesToJoin)))result = []seen = set()for length in xrange(max(map(len, nodesToJoin)), 0, -1): #start with longest possible, work to shortestfor sublist in combinations(allNodes, length):if any(item in seen for item in sublist):#skip possible sublists with options we've already seen in the resultcontinueif all(isSubsetOrDisjointTo(sublist, node) for node in nodesToJoin):result.append(sublist)seen.update(sublist)return result

There are probably a number of ways this can be optimised or improved.