部分随机检索，部分最小化重复

Question

我有一个包含 10 个数字的数组：

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

我编写了一个函数（如下）来从数组中返回一个随机元素，而不重复返回相同的元素，直到返回 8 个其他元素。它可以工作，但似乎效率很低，因为随机数生成器通常需要多次调用才能继续代码。有没有更有效的方法来实现相同的结果？

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var recentlyReturned = [];

function minimalRepeat() {

var i = Math.floor(Math.random() * 10);
while( recentlyReturned.indexOf(i) != -1 ) {
    i = Math.floor(Math.random() * 10);
}

recentlyReturned.push(i);
while(recentlyReturned.length>8) {
    recentlyReturned.shift();
}
return array[i];
}


for(var i=1; i<20; i++) {
    console.log(minimalRepeat());
}

* 编辑 *

我根据 Tudor Ilisoi 的反馈重写了代码。它肯定更有效率。但是，有可能在 shuffle 边界上重复。

版本 2：

function shuffle(arr) {
    var copyArr = arr.slice();
    for (let i = copyArr.length; i; i--) {
        let j = Math.floor(Math.random() * i);
        [copyArr[i - 1], copyArr[j]] = [copyArr[j], copyArr[i - 1]];
    }
    return copyArr;
}

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var b = shuffle(a);

for(var i=1; i<20; i++) {
    if(b.length == 0) {
        b = shuffle(a);
    }
    console.log(b.pop());
}

Answer 1

费舍尔-耶茨：

function shuffle(array) {
  var m = array.length, t, i;

  while (m) {

    i = Math.floor(Math.random() * m--);

    t = array[m];
    array[m] = array[i];
    array[i] = t;
  }

  return array;
}

var origArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var numbers = origArray;
var randomNumbers = shuffle(numbers);

var result = randomNumbers.slice(0, 8);

for (var i = 0; i < 11; i++) {
  result.push(randomNumbers[Math.floor(Math.random() * (origArray.length-1))]);
}

前 8 个数字应该是唯一的（来自预定义的集合）。
接下来的 11 个号码可以在所选号码内和预定义集中重复。

（如果我理解正确的话。）

基于 cmets 编辑

由于 no-repeat-window 是 8，因此数组中剩下两个数字；最后两个数字。

下一个随机数是数组中的第一个数字。

您可以做的是将pop 和shift 这些数字放入一个临时数组中，将临时数组和push 临时数组打乱回随机数组。

var origArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var randomNumbers = shuffle(origArray);

for (var i = 0; i < 19; i++)
{
    var tmp = [];
    tmp.push(randomNumbers.pop());   // First number not in no-repeat-window
    tmp.push(randomNumbers.pop());   // Second number not in no-repeat-window
    tmp.push(randomNumbers.shift()); // Current random number.

    randomNumbers.push.apply(randomNumbers, shuffle(tmp));
}

jsFiddle

Answer 2

你可以这样做：

• 复制数组并将其随机化。我们就叫它copy
• 您的 minimumRepeat 将从带有copy.pop() 的随机副本中提取，直到副本为空（或提取了 8 个元素）。满足此条件后，再制作一份副本

通过从随机副本中提取，您可以确保在再次生成副本之前不会返回相同的元素。

根据评论反馈进行编辑

function shuffle(arr) {
  var copyArr = arr.slice();
  for (let i = copyArr.length; i; i--) {
    let j = Math.floor(Math.random() * i);
    [copyArr[i - 1], copyArr[j]] = [copyArr[j], copyArr[i - 1]];
  }
  return copyArr;
}

var latest = []
var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var b = shuffle(a);

for (var i = 1; i < 20; i++) {
  if (b.length == 0) {
    b = shuffle(a);
  }
  var popped = b.pop()

  //if found in recents
  if (latest.indexOf(popped) !== -1) {
    continue;
  }

  //push the popped element
  latest.push(popped)
  if (latest.length > 8) {
    latest.shift() //remove the oldest "recent" to keep the "latest" length at 8
  }

  console.log(popped);
}

Answer 3

您可以在数组中组织循环队列：

Randomize array A[] with Fisher-Yates algo
Set Idx to 0
At every step generate random r = 0 or 1 
If r=1 swap A[Idx % 10] and A[(Idx + 1) % 10]
Output A[Idx % 10] 
Increment Idx