Merge sub arrays containing that have intersection in Groovy / Java - arrays

Question

Suppose we have one array:
def a = [[0], [1], [2], [2, 1], [1, 2], [3, 2], [2, 3], [3],
[4, 3], [3, 4], [4], [5], [6], [8], [10, 7], [7, 10],
[7, 8], [8, 7], [9], [10], [7, 10, 8], [8, 9], [9, 8],
[11, 0], [0, 11]]
then
def b = reduce(a)
should produce
[ [0, 11], [1, 2, 3, 4], [5], [6], [7,8,9,10] ]
My logic was to have a new array reducedObjects that would contain the result. First subarray from objects is copied to reducedObjects and then next subarray is checked if has intersection with subarrays from reducedObjects. If there is an intersection, then make a union from the subarray in reducedObjects and the original subarray.
def reduce(objects) {
def reducedObjects = new ArrayList()
objects.each { object ->
if (reducedObjects.size() == 0) {
reducedObjects << object
} else {
def isReduced = false
for (int i = 0; i < reducedObjects.size(); i++) {
def equals = false
object.each { it ->
if(reducedObjects[i].contains(it)) {
equals = true
isReduced = true
}
}
if (equals) {
reducedObjects[i] = (object + reducedObjects[i]).unique().sort()
reducedObjects.unique()
}
}
if(!isReduced) {
reducedObjects << object
}
}
}
return reducedObjects.unique()
}
The following function do not work fine, as the result is:
[[0, 11], [1, 2, 3, 4], [5], [6], [7, 8, 9, 10], [8, 9]]
The problem is that reducedObjects has an subarray [7, 8] and then the next subarray is [9]. The function will create a new subarray as there is no intersection, but in next iteration, there is a subarray [8, 9] and it is merged in both [7,8] and [9].
Is there any better solution to do this? Or somehow to improve this solution?

Answer 1

To expand on my comment above - I think the problem lies here:
for (int i = 0; i < reducedObjects.size(); i++) {
def equals = false
object.each { it ->
if(reducedObjects[i].contains(it)) {
equals = true
isReduced = true
}
}
if (equals) {
reducedObjects[i] = (object + reducedObjects[i]).unique().sort()
reducedObjects.unique()
}
}
Here, you are iterating over your input list (current item from that list being object) and comparing that object with all the previously reduced lists and merging them, but for every reduced list it is being merged.
Imagine your reducedObjects looks like [[7,8],[9,10]] and object is [8,9] - then this code will merge object [8,9] with both those existing items.
A more idiomatic groovy approach might be something like:
def a = [[0], [1], [2], [2, 1], [1, 2], [3, 2], [2, 3], [3],
[4, 3], [3, 4], [4], [5], [6], [8], [10, 7], [7, 10],
[7, 8], [8, 7], [9], [10], [7, 10, 8], [8, 9], [9, 8],
[11, 0], [0, 11]]
def reduced = []
a.each{ incoming ->
List allReducedLists = (reduced.findAll{ r -> incoming.intersect(r) } + incoming).flatten().unique()
reduced = reduced.findAll{ r -> !allReducedLists.intersect(r) }
reduced << allReducedLists
}
println reduced
(not tested beyond the above input, so maybe missed some cases)

Answer 2

Here is another option you have got that uses a recursive closure:
def a = [[0], [1], [2], [2, 1], [1, 2], [3, 2], [2, 3], [3],
[4, 3], [3, 4], [4], [5], [6], [8], [10, 7], [7, 10],
[7, 8], [8, 7], [9], [10], [7, 10, 8], [8, 9], [9, 8],
[11, 0], [0, 11]
]
def reducedList
reducedList = {l->
def r = []
def found = false
l.each{a1->
found = false
l.each{a2->
if(a1!=a2){
if(a1.intersect(a2).size()>0){
r.push(a1.plus(a2).sort().unique())
found = true
}
}
}
if(found==false)r.push(a1.sort().unique())
}
return (r.unique()==l)?r.unique():reducedList(r)
}
println reducedList(a) //[[0, 11], [1, 2, 3, 4], [5], [6], [7, 8, 9, 10]]