Given an array of `points`

where `points[i] = [x`

represents a point on the _{i}, y_{i}]**X-Y** plane and an integer `k`

, return the `k`

closest points to the origin `(0, 0)`

.

The distance between two points on the **X-Y** plane is the Euclidean distance (i.e., `√(x`

)._{1} - x_{2})^{2} + (y_{1} - y_{2})^{2}

You may return the answer in **any order**. The answer is **guaranteed** to be **unique** (except for the order that it is in).

**Example 1:**

Input:points = [[1,3],[-2,2]], k = 1Output:[[-2,2]]Explanation:The distance between (1, 3) and the origin is sqrt(10). The distance between (-2, 2) and the origin is sqrt(8). Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin. We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].

**Example 2:**

Input:points = [[3,3],[5,-1],[-2,4]], k = 2Output:[[3,3],[-2,4]]Explanation:The answer [[-2,4],[3,3]] would also be accepted.

**Constraints:**

`1 <= k <= points.length <= 10`

^{4}`-10`

^{4}< x_{i}, y_{i}< 10^{4}

Solution1:

```
class Solution(object):
def kClosest(self, points, K):
return heapq.nsmallest(K, points, lambda (x, y): x * x + y * y)
```

Solution2:

Python sorting by distance

**Hint**:

Recall the definition of Euclidean distance.

Launch customized sorting to sort points by distance to origin.

**Illustration** and **Visualization**:

**Implementation** by sorting with distance:

```
class Solution:
def kClosest(self, points, K):
# sort by the distance to origin, in ascending order
points.sort( key = lambda point: (point[0]**2 + point[1]**2) )
return points[:K]
```

**Implementation** by heap sort with distance:

```
class Solution:
def kClosest(self, points, K):
# sort by the distance to origin, in ascending order
k_closet = heapq.nsmallest( K, points, key = lambda point: point[0]**2 + point[1]**2 )
return k_closet
```