Given an array of `points` where `points[i] = [xi, yi]` represents a point on the **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., `√(x1 - x2)2 + (y1 - y2)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 = 1
**Output:** \[\[-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 = 2
**Output:** \[\[3,3\],\[-2,4\]\]
**Explanation:** The answer \[\[-2,4\],\[3,3\]\] would also be accepted.

**Constraints:**

*   `1 <= k <= points.length <= 104`
*   `-104 < xi, yi < 104`


def moves_to_stamp(stamp: str, target: str) -> list:
    result = []
    is_stamped = [False] * len(target)
    stamp_count = 0
    target = list(target)

    while stamp_count < 10 * len(target):
        found_stamp = False
        for i in range(len(target) - len(stamp) + 1):
            if is_stamped[i]:
                continue
            j = 0
            overlap = 0
            while j < len(stamp) and (target[i + j] == '?' or target[i + j] == stamp[j]):
                if target[i + j] == stamp[j]:
                    overlap += 1
                j += 1
            if j == len(stamp) and overlap > 0:
                for j in range(len(stamp)):
                    target[i + j] = '?'
                result.append(i)
                is_stamped[i] = True
                found_stamp = True
        if not found_stamp:
            break

        stamp_count += 1

    for c in target:
        if c != '?':
            return []

    return result[::-1]
