Queries on Number of Points Inside a Circle

class Solution {
public:
    vector<int> countPoints(vector<vector<int>>& points, vector<vector<int>>& queries) {
        vector<int> ans;
        ans.reserve(queries.size());
        for (auto& q : queries) {
            int qx = q[0], qy = q[1], r2 = q[2] * q[2], cnt = 0;
            for (auto& p : points) {
                int dx = p[0] - qx, dy = p[1] - qy;
                if (dx*dx + dy*dy <= r2) ++cnt;
            }
            ans.push_back(cnt);
        }
        return ans;
    }
};

func countPoints(points [][]int, queries [][]int) []int {
    ans := make([]int, 0, len(queries))
    for _, q := range queries {
        qx, qy, r2 := q[0], q[1], q[2]*q[2]
        cnt := 0
        for _, p := range points {
            dx, dy := p[0]-qx, p[1]-qy
            if dx*dx+dy*dy <= r2 {
                cnt++
            }
        }
        ans = append(ans, cnt)
    }
    return ans
}

from typing import List

class Solution:
    def countPoints(self, points: List[List[int]], queries: List[List[int]]) -> List[int]:
        ans: List[int] = []
        for qx, qy, r in queries:
            r2 = r * r
            cnt = 0
            for px, py in points:
                dx, dy = px - qx, py - qy
                if dx * dx + dy * dy <= r2:
                    cnt += 1
            ans.append(cnt)
        return ans

function countPoints(points, queries) {
    const ans = [];
    for (const [qx, qy, r] of queries) {
        const r2 = r * r;
        let cnt = 0;
        for (const [px, py] of points) {
            const dx = px - qx, dy = py - qy;
            if (dx * dx + dy * dy <= r2) cnt++;
        }
        ans.push(cnt);
    }
    return ans;
}

class Solution {
    public int[] countPoints(int[][] points, int[][] queries) {
        int[] ans = new int[queries.length];
        for (int i = 0; i < queries.length; i++) {
            int qx = queries[i][0], qy = queries[i][1];
            int r2 = queries[i][2] * queries[i][2];
            int cnt = 0;
            for (int[] p : points) {
                int dx = p[0] - qx, dy = p[1] - qy;
                if (dx * dx + dy * dy <= r2) cnt++;
            }
            ans[i] = cnt;
        }
        return ans;
    }
}

function countPoints(points: number[][], queries: number[][]): number[] {
    const ans: number[] = [];
    for (const [qx, qy, r] of queries) {
        const r2 = r * r;
        let cnt = 0;
        for (const [px, py] of points) {
            const dx = px - qx, dy = py - qy;
            if (dx * dx + dy * dy <= r2) cnt++;
        }
        ans.push(cnt);
    }
    return ans;
}