# Group recursively adjacent tuples from a list in Python

If I understood correctly.

```
a = [(1, 1), (3, 1), (4, 5), (8, 8), (4, 4), (8, 9), (2, 1)]
a = sorted(a)
def Manhattan(tuple1, tuple2):
return abs(tuple1[0] - tuple2[0]) + abs(tuple1[1] - tuple2[1])
result = [set()]
l = len(a)
for i, v in enumerate(a):
if not i+1 >= l:
if Manhattan(v, a[i+1]) ==1:
result[-1].add(v)
result[-1].add(a[i+1])
else:
result.append(set())
result[-1].add(a[i+1])
print(result)
```

**Output:**

```
[{(3, 1), (1, 1), (2, 1)}, {(4, 5), (4, 4)}, {(8, 9), (8, 8)}]
```

A completely different, maybe less efficient but certainly interesting approach, would be with a graph theoretic formulation. You can view this problem as finding all connected components of a graph where two vertices are connected whenever the Manhattan distance is one. Crudely written, you could do :

```
import networkx as nx
G = nx.Graph()
a = [(1, 1), (3, 1), (4, 5), (8, 8), (4, 4), (8, 9), (2, 1)]
n = len(a)
G.add_nodes_from(a)
# Generate edges
for i in range(n):
for j in range(i+1,n):
if Manhattan(a[i],a[j]) == 1:
G.add_edge(a[i], a[j])
# Find components
components = nx.connected_components(G)
for x in components:
print(x)
```

which spits out

```
{(3, 1), (1, 1), (2, 1)}
{(4, 5), (4, 4)}
{(8, 9), (8, 8)}
```

a somewhat UnionFind approach, iterating all 1-distanced pairs and "Unifying" their groups:

```
from itertools import groupby, product
def Manhattan(tuple1, tuple2):
return abs(tuple1[0] - tuple2[0]) + abs(tuple1[1] - tuple2[1])
a = [(1, 1), (3, 1), (4, 5), (8, 8), (4, 4), (8, 9), (2, 1)]
tuple_pairs_with_distance_1 = [sorted(pair) for pair in product(a, repeat=2) if Manhattan(*pair) == 1]
result_dict = {t: {t} for t in a}
for t1, t2 in tuple_pairs_with_distance_1:
# "Unify" these tuple's groups
result_dict[t1] |= result_dict[t2]
result_dict[t2] = result_dict[t1]
result = [[*next(g)] for k, g in groupby(sorted(result_dict.values(), key=id), id)]
print(result)
```