human
I found an interesting problem on https://www.codewars.com/kata/5a99d851fd5777f746000066:
Cluster analysis - Unweighted pair-group average

Clustering is a task of grouping a set of objects in such a way that the objects in the same class are similar to each other and the objects in different classes are distinct. Cluster analysis is employed in many fields such as machine learning, pattern recognition, image analysis, etc.

In this kata, your task is to implement a simple clustering technique called 'Unweighted pair-group average'. This method takes a set of 2D points and the desired number of final clusters. Initially, each point forms its own cluster. The most similar (least distant) clusters are iteratively merged until the target number of clusters is reached.

The distance metric between two clusters is defined as the average distance between all pairs of points from the two clusters. For example: 
```
Cluster 1: (0, 0), (0, 1)
Cluster 2: (4, 3)
Distance = (sqrt((0-4)^2 + (0-3)^2) + sqrt((0-4)^2 + (1-2)^2)) / 2
```

Input:
- ```points``` - a list of 2D points ```[(1, 1), (3, 5), (4, 4), (8, 2), (0, 1)]```
- ```n``` - the desired number of clusters

Output:
- list of clusters, each cluster is a list of points
- points in each cluster should be sorted in ascending order
- the list of clusters should also be sorted in ascending order

Example:
- ```cluster(3, [(1, 1), (3, 5), (4, 4), (8, 2), (0, 1)])```
- should return 
```[ [(0, 1), (1, 1)],
     [(3, 5), (4, 4)],
     [(8, 2)]
   ]
```
   
Notes:
- the coordinates ```(x, y)``` are chosen from interval ```<0, 1000>```
- ```0 < len(points) <= 100```
- ```0 < n <= len(points)```
- there is always only one unique solution
- there are no duplicate points in the input

I tried it in Python, but could not do it. Can you solve it?

What is a the Python program you requested?
assistant
#Here is the Python program you requested.

from math import hypot
from statistics import mean

def cluster(points, n):
    cs = [[p] for p in points]
    def key(ij):
        return mean(dist(p1, p2) for p1 in cs[ij[0]] for p2 in cs[ij[1]])
    while len(cs) > n:
        i, j = min(((i, j) for i in range(len(cs)) for j in range(i)), key=key)
        cs[i] += cs[j]
        del cs[j]
    return sorted(map(sorted, cs))

def dist(a, b):
    return hypot(a[0] - b[0], a[1] - b[1])