点の数を辞書に数え、向かいの角から軸にそろった正方形を数える

class DetectSquares:
    def __init__(self):
        self.cnt = {}

    def add(self, point):
        key = (point[0], point[1])
        c = self.cnt.get(key, 0)
        self.cnt[key] = c + 1

    def count(self, point):
        x, y = point
        cnt = self.cnt
        total = 0
        for (px, py), c in cnt.items():
            if px == x:
                continue
            if abs(px - x) != abs(py - y):
                continue
            a = cnt.get((x, py), 0)
            b = cnt.get((px, y), 0)
            total += c * a * b
        return total

class DetectSquares {
  constructor() {
    this.cnt = new Map();
    this.pts = [];
  }

  add(point) {
    const key = point.join(",");
    const c = this.cnt.get(key);
    if (c === undefined) {
      this.pts.push(point);
    }
    this.cnt.set(key, (c ?? 0) + 1);
  }

  at(x, y) {
    return this.cnt.get(`${x},${y}`) ?? 0;
  }

  count(point) {
    const [x, y] = point;
    let total = 0;
    for (const [px, py] of this.pts) {
      const dx = Math.abs(px - x);
      const dy = Math.abs(py - y);
      if (dx === 0 || dx !== dy) {
        continue;
      }
      total +=
        this.at(px, py) *
        this.at(x, py) *
        this.at(px, y);
    }
    return total;
  }
}

type DetectSquares struct {
	cnt map[[2]int]int
}

func newDetectSquares(
) *DetectSquares {
	m := map[[2]int]int{}
	return &DetectSquares{cnt: m}
}

func (d *DetectSquares) Add(
	point []int,
) {
	key := [2]int{point[0], point[1]}
	d.cnt[key]++
}

func abs(v int) int {
	if v < 0 {
		return -v
	}
	return v
}

func (d *DetectSquares) Count(
	point []int,
) int {
	x, y := point[0], point[1]
	total := 0
	for k, c := range d.cnt {
		px, py := k[0], k[1]
		if px == x {
			continue
		}
		if abs(px-x) != abs(py-y) {
			continue
		}
		a := d.cnt[[2]int{x, py}]
		b := d.cnt[[2]int{px, y}]
		total += c * a * b
	}
	return total
}