输入两个六边形用js代码判断两个六边形有几个交点

这是一个比较复杂的问题，需要使用一些几何算法来解决。以下是一种可能的解决方案：

定义六边形的数据结构，可以使用一个包含六个点的数组来表示。每个点可以用一个包含 x 和 y 坐标的对象来表示。

const hexagon1 = [
  { x: 0, y: 0 },
  { x: 2, y: 0 },
  { x: 3, y: 1 },
  { x: 2, y: 2 },
  { x: 0, y: 2 },
  { x: -1, y: 1 }
];

const hexagon2 = [
  { x: 1, y: 1 },
  { x: 3, y: 1 },
  { x: 4, y: 2 },
  { x: 3, y: 3 },
  { x: 1, y: 3 },
  { x: 0, y: 2 }
];

实现一个函数来判断两条线段是否相交。可以使用向量叉积的方法。

function segmentsIntersect(p1, q1, p2, q2) {
  const direction1 = { x: q1.x - p1.x, y: q1.y - p1.y };
  const direction2 = { x: q2.x - p2.x, y: q2.y - p2.y };
  const crossProduct = direction1.x * direction2.y - direction1.y * direction2.x;

  if (crossProduct === 0) {
    return false;
  }

  const difference = { x: p1.x - p2.x, y: p1.y - p2.y };
  const t = (difference.x * direction2.y - difference.y * direction2.x) / crossProduct;
  const u = (difference.x * direction1.y - difference.y * direction1.x) / crossProduct;

  if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
    return true;
  }

  return false;
}

实现一个函数来判断两个六边形是否相交。可以使用线段相交的方法。

function hexagonsIntersect(hexagon1, hexagon2) {
  for (let i = 0; i < hexagon1.length; i++) {
    const p1 = hexagon1[i];
    const q1 = hexagon1[(i + 1) % hexagon1.length];

    for (let j = 0; j < hexagon2.length; j++) {
      const p2 = hexagon2[j];
      const q2 = hexagon2[(j + 1) % hexagon2.length];

      if (segmentsIntersect(p1, q1, p2, q2)) {
        return true;
      }
    }
  }

  return false;
}

实现一个函数来计算两个六边形的交点数量。可以使用一个计数器来记录相交的线段数量。

function countIntersectionPoints(hexagon1, hexagon2) {
  let count = 0;

  for (let i = 0; i < hexagon1.length; i++) {
    const p1 = hexagon1[i];
    const q1 = hexagon1[(i + 1) % hexagon1.length];

    for (let j = 0; j < hexagon2.length; j++) {
      const p2 = hexagon2[j];
      const q2 = hexagon2[(j + 1) % hexagon2.length];

      if (segmentsIntersect(p1, q1, p2, q2)) {
        count++;
      }
    }
  }

  return count;
}

调用以上函数来计算两个六边形的交点数量。

console.log(countIntersectionPoints(hexagon1, hexagon2)); // 输出 2

以上是一种可能的解决方案，但并不是唯一的。实际上，这个问题有很多种解决方法，具体取决于算法的实现和优化。