Javascript 数组中的成对值

您好，我正在尝试创建一个数组，数组中的成对值按随机顺序从1-size开始，例如：[3,1,1,2,3,2]，对于size=3

到目前为止，我做过这样的事情：

当数字不在数组中时，我用随机数填充两个数组

重复第二个数组

然后返回它们的串联

我不知道如何改进我问题的解决方法

    let arr1 = [];
    let arr2 = [];
    let number;
    let i = 0;
    let k = 0;
    while (i < size) {
      number = Math.floor(Math.random() * size + 1);
      if (!arr1.includes(number)) {
        arr1.push(number);
        i++;
      }
    }
    while (k < size) {
      number = Math.floor(Math.random() * size + 1);
      if (!arr2.includes(number)) {
        arr2.push(number);
        k++;
      }
    }
    return arr1.concat(arr2);

让arr1=[]；
设arr2=[]；
让数；
设i=0；
设k=0；
而（i

您的方式需要太多不必要的操作。您取决于随机值将重复多少次，直到覆盖所有数字。最好只创建一个数组，找到随机索引，然后删除所选项，将其移动到结果数组。所以没有重复，非常有效

而且，方法

包括

对大型阵列无效。我的解决办法是

const createRandomArrays = size => {

  const res = Array.from([1, 2]).flatMap(() => {
    const numbers = Array.from({ length: size }, (v, ind) => ind + 1)
    const res = []

    while (numbers.length) {
      const ind = Math.floor(Math.random() * numbers.length)
      res.push(numbers[ind])
      numbers.splice(ind, 1) 
    }

    return res
  })
  
  console.log(res)
}

const createRandomArrays = size => {

  const numbers = Array.from({ length: size * 2 }, (v, ind) => (ind % size) + 1)
  const res = []

  while (numbers.length) {
    const ind = Math.floor(Math.random() * numbers.length)
    res.push(numbers[ind])
    numbers.splice(ind, 1) 
  }

  console.log(res)
}

PS但您无法从代码中获取[3,1,1,2,3,2]，因为每个数组都有自己的集合，您可以获取[3,2,1,1,3,2]或其他内容，结果数组的前半部分中的两个数字1不能在一起

如果你想把它们混合在一起，那么解决方案就是

const createRandomArrays = size => {

  const res = Array.from([1, 2]).flatMap(() => {
    const numbers = Array.from({ length: size }, (v, ind) => ind + 1)
    const res = []

    while (numbers.length) {
      const ind = Math.floor(Math.random() * numbers.length)
      res.push(numbers[ind])
      numbers.splice(ind, 1) 
    }

    return res
  })
  
  console.log(res)
}

const createRandomArrays = size => {

  const numbers = Array.from({ length: size * 2 }, (v, ind) => (ind % size) + 1)
  const res = []

  while (numbers.length) {
    const ind = Math.floor(Math.random() * numbers.length)
    res.push(numbers[ind])
    numbers.splice(ind, 1) 
  }

  console.log(res)
}

---

我认为你在正确的轨道上。但是，通过提高性能，可以大大简化解决方案

如果你仔细想想，你真的只需要两次手术。首先让我们假设你的阵列是一副牌。你真正做的只是把两副牌混在一起

让我们假设您得到一个数组

A

，其中包含

N

之前的所有元素，比如

[1,2,3]

。我们只需将

A

与

A

合并即可得到

A'=[1,2,3,1,2,3]

。现在，为了完成我们的洗牌示例，我们只需要洗牌所有内容。假设我们有一个函数

S

，它洗牌一个数组，将它应用到我们的数组

a'

，以获得我们的随机排列

[2,1,2,3,1,3]

或任何东西

const pairs = (n) => {
  return Array.from({ length: n * 2 }, (_, i) => {
    return (i + 1) % n + 1;
  });
};

const shuffle = (array) => {
  const n = array.length;
  const result = array.slice();
  
  for (let i = 0; i < array.length - 1; i++) {
    const j = Math.floor(Math.random() * (n - i) + i);
    const t = result[i];
    
    result[i] = result[j];
    result[j] = t;
  }
  
  return result;
};

console.log(shuffle(pairs(3)));

const pairs=（n）=>{
返回数组。from（{length:n*2}，（\ux，i）=>{
返回（i+1）%n+1；
});
};
常量洗牌=（数组）=>{
常数n=数组长度；
const result=array.slice（）；
for（设i=0；i

pairs（）

将生成一个长度为

2*n

的数组，其中包含两次

[1，n]

范围<代码>洗牌对返回结果的数组执行洗牌