如何将两个元素相同的数组随机配对且避免元素自匹配？

你的需求本质是生成错位排列——让arrayA的每个元素都匹配到arrayB中不同的元素，相当于把arrayB打乱后，每个位置的元素都和原数组对应位置（即arrayA的同位置元素）不重复。

简单实现（适合小数组） #

这种方法逻辑直观，通过洗牌+检查的方式实现，对于元素数量不多的场景足够高效：

var arrayA = ["john","max","james","nicolas"];
var arrayB = ["john","max","james","nicolas"];

// 生成错位排列：打乱数组且无元素在原位置
function getDerangement(arr) {
  let shuffled;
  do {
    // 复制数组并随机打乱
    shuffled = [...arr].sort(() => Math.random() - 0.5);
    // 检查是否存在元素和原位置重复
  } while (shuffled.some((item, index) => item === arr[index]));
  return shuffled;
}

// 生成配对结果
const matchedB = getDerangement(arrayB);
const pairs = arrayA.map((name, idx) => `${name} ${matchedB[idx]}`);

// 输出示例
pairs.forEach(pair => console.log(pair));

更公平的洗牌优化 #

上面的sort洗牌随机性不够均匀，换成Fisher-Yates洗牌算法可以得到更公平的随机结果：

// 标准Fisher-Yates洗牌函数
function fisherYatesShuffle(arr) {
  const newArr = [...arr];
  for (let i = newArr.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [newArr[i], newArr[j]] = [newArr[j], newArr[i]];
  }
  return newArr;
}

// 用Fisher-Yates替换原洗牌逻辑
function getDerangement(arr) {
  let shuffled;
  do {
    shuffled = fisherYatesShuffle(arr);
  } while (shuffled.some((item, index) => item === arr[index]));
  return shuffled;
}

无重试的高效实现 #

如果不想通过循环重试来筛选结果，可以用错位排列专用的生成算法，在洗牌过程中直接避免元素回到原位置：

function generateDerangement(arr) {
  const derangement = [...arr];
  const len = derangement.length;

  // 从后往前交换，避免元素回到原位置
  for (let i = len - 1; i > 0; i--) {
    let j = Math.floor(Math.random() * i);
    // 如果选中的位置元素和原i位置元素相同，就交换到i位置
    if (derangement[j] === arr[i]) {
      j = i;
    }
    [derangement[i], derangement[j]] = [derangement[j], derangement[i]];
  }

  // 最后检查第一个元素，确保它不等于原数组第一个元素
  if (derangement[0] === arr[0]) {
    const swapIdx = Math.floor(Math.random() * (len - 1)) + 1;
    [derangement[0], derangement[swapIdx]] = [derangement[swapIdx], derangement[0]];
  }

  return derangement;
}

// 使用示例
const matchedB = generateDerangement(arrayB);
const pairs = arrayA.map((name, idx) => `${name} ${matchedB[idx]}`);
console.log(pairs);

说明 #

• 错位排列的概率约为1/e（≈36.8%），所以循环重试的方法平均3次以内就能得到结果，小数组完全不用担心性能问题。
• 所有实现都会确保最终的配对中，arrayA的每个元素都不会匹配到arrayB中相同的元素。

内容的提问来源于stack exchange，提问作者yacine