用不连续的随机数填充数组

Question

我想创建一个数组 (indexes)，该数组应填充从 0 到 length - 1 的随机数。

所以如果length = 3; 那么indexes 应该从0 延伸到2，例如它可能类似于：[0, 2, 1]。

我们应该遵循一个条件：（上帝，我怎么能用英语来描述呢：）

条件：我们不接受连续的数字。

所以我们不应该返回：

[0, 1, 2]       => Because 0 and 1 and 2 are consecutive.

[2, 0, 1]       => Because 0 and 1 are consecutive.

[2, 3, 1, 0]    => Because 2 and 3 are consecutive.

好的，我知道可能有一个例外，最后一个元素可能是连续的，因为那时我们别无选择！

我写了一段代码，但不幸的是，由于 CPU 使用率高，它导致浏览器崩溃！

请帮忙，我和我的笔记本电脑都很困惑！

// generate number from 0 to max (max could include in the result)
function getRandom(max) {
    return Math.floor(Math.random() * (max + 1));
};

// our array to be filled with unordered numbers
let indexes = [];

// we will fill the above array with 0, 1 ,2 ,3 I mean 0 to (length - 1) 
let length = 4;

// loop through indexes so that it is filled with 4 elements
while( indexes.length <= length){

      // get a number randomally from 0 to 3
      let result = getRandom(length - 1);
       // we don't want any repeated number so..
       if(!indexes.includes(result)){     
          // finally here is our condition, we should   
          if( result !== indexes[indexes.length - 1] + 1 ){
              indexes.push(result);
          } else if(indexes.length == length){
            // push the last element to the array despite the condition
            indexes.push(result);
          }
       }

};

console.log(indexes);

Answer 1

您可以通过以下方式调整modern Fisher-Yates 算法：

如果交换索引 i 和 j 处的值会在索引 i 处带来一个值，而该值是不允许的，因为已放置在索引 i+1 处，则不要进行该交换，而是在这三个相关索引之间进行三重轮换。

这是实现，以及 400 次运行的测试：

function shuffled(n) {
    let a = [...Array(n).keys()];
    for (let i = n - 1; i > 0; i--) {
        let j = Math.floor(Math.random() * (i + 1));
        if (a[j]+1 === a[i+1]) { // a swap is going to violate the rule at i/i+1
            // Triple rotation at j, i, i+1 (or, when j == i, swap at i, i+1)
            a[j] = a[i];
            a[i] = a[i+1]--;
        } else { // standard swap
            let temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
    // Finally check first two values:
    if (a[0]+1 === a[1]) {
        let temp = a[0];
        a[0] = a[1];
        a[1] = temp;
    }
    return a;
}

// Test this solution:
function verify(a) {
    let set = new Set(a);
    return !a.some((v, i) => v === a[i-1]+1 || !set.has(i));
}

for (let size = 2; size < 6; size++) {
    for (let i = 0; i < 100; i++) {
        let a = shuffled(size);
        if (!verify(a)) throw "not correct";
    }
}
console.log("tests successful");

这具有可预测的线性时间复杂度。没有多次尝试失败的风险。

Answer 2

更新：

我在比较错误的数字来检查不连续的规则

您可以创建一个索引列表，随机取第一项。如果满足条件或者它是最后一个元素，则一次从索引中删除一个项目

const range = (n) => {
    const array = [];
    for (let  i = 0; i < n; i++) array.push(i);
    return array;
};

const randomIndex = (array) => (
    parseInt(array.length * Math.random())
);

const randomNonConsecutive = (n) => {
    const array = range(n);
    const result = array.splice(randomIndex(array), 1);

    while (array.length) {
        const last = result[result.length - 1];
        const next = last + 1;
        const index = randomIndex(array);
        const item = array[index];

        if (item !== next || array.length === 1) {
            result.push(item)
            array.splice(index, 1);
        }
    }

    return result;
}

console.log(randomNonConsecutive(3))
console.log(randomNonConsecutive(4))
console.log(randomNonConsecutive(5))

Answer 3

这维护了一组可能的数字，供下一个数字选择。

从这组中选出的下一个数字是随机选择的。

如果选择了一个连续的数字，则交换顺序。

不允许上当。

function randomNonConsecutive(upto) {
  const result = []
  let set = Object.keys([...Array(upto)])
  for(let x = 0; x < upto; x++) {
    let index = Math.floor(Math.random()*set.length)
    let insert = set[index]
    if(x > 0 && Number(result[x-1]) === insert-1) {
        [result[x-1], insert] = [insert, result[x-1]]
    }
    result[x] = insert
    set.splice(index,1)
  }
  return result
}

let result = randomNonConsecutive(10)
console.log(result)

Answer 4

如果唯一剩余的值是最后一个值之前的值的增量值，那么您的算法采用随机值并且最后一个值有问题。

例如取值为1、0、2，剩余值为3

          v
[1, 0, 2, 3]

在这种情况下，除了不需要的值之外，没有其他可用值。这会产生一个无限循环。

---

您可以获取所有索引的数组并使用 Fisher-Yates shuffle algorithm 并随机播放，直到数组中没有连续的递增值。

function shuffle(array) { // https://stackoverflow.com/a/2450976/1447675
   var currentIndex = array.length,
       temporaryValue,
       randomIndex;

    // While there remain elements to shuffle...
    while (0 !== currentIndex) {
        // Pick a remaining element...
        randomIndex = Math.floor(Math.random() * currentIndex);
        currentIndex -= 1;

        // And swap it with the current element.
        temporaryValue = array[currentIndex];
        array[currentIndex] = array[randomIndex];
        array[randomIndex] = temporaryValue;
    }

    return array;
}

let length = 4,
    indices = Array.from({ length }, (_, i) => i);

do indices = shuffle(indices);
while (indices.some((v, i, a) => v + 1 === a[i + 1]))

console.log(...indices);

Answer 5

长度为 4 时，您的结果数组只有几个可能的结果（见下文）。

您的函数的问题是，如果您从没有可能答案的数字开始，它将永远运行，并且只有 4 个可能的数字，发生这种情况的可能性非常高。 如果返回 0 或 3 作为第一个数字，它将永远找不到解决方案。如果返回 1 并且第二个数字不是 3，或者如果 2 是第一个并且第二个数字不是 0，则相同。 更新，因为 cmets 澄清了允许降序的连续数字（这看起来很奇怪）。

你也将永远运行，因为你的 while 循环应该使用 indexes.length < length 而不是 <=

[0, 1, 2, 3] // no
[0, 1, 3, 2] // no
[0, 2, 1, 3] // yes
[0, 2, 3, 1] // no
[0, 3, 1, 2] // no
[0, 3, 2, 1] // yes
[1, 0, 2, 3] // no
[1, 0, 3, 2] // yes
[1, 2, 3, 0] // no
[1, 2, 0, 3] // no
[1, 3, 0, 2] // yes
[1, 3, 2, 0] // yes
[2, 0, 1, 3] // no
[2, 0, 3, 1] // yes
[2, 1, 0, 3] // yes
[2, 1, 3, 0] // yes
[2, 3, 0, 1] // no
[2, 3, 1, 0] // no
[3, 0, 1, 2] // no
[3, 0, 2, 1] // yes
[3, 1, 0, 2] // yes
[3, 1, 2, 0] // no
[3, 2, 0, 1] // no
[3, 2, 1, 0] // yes

这告诉我们，这个算法很可能会失败，因为当没有剩余的数字可以满足条件时，它没有“失败”条件处理。您可以检查一下，如果是这种情况，请重新启动，但它仍然可能很慢。换一种方法会更好。