Question

在每个数字必须是下一个/上一个数字的+3或-3的条件下，对数组进行洗牌的最佳方法是什么？因此，例如[0,1]不起作用，但[0,3]会起作用。

谢谢！

Answer 1

看一下截图，你似乎想要从列表中选择一个随机分类，没有2个选择在彼此的3个之内。此代码采用数组，并为您提供满足该条件的数组的子集。您也可以指定最大数量的选择，尽管您可能并不总是那么多。

var src = [0,1,2,3,4,5,6,7,8,9,10,11,12];

var getRnd = function(max){
    var output = [];
    var newSrc = src.slice();
    var test, index, i, safe;

    while (newSrc.length > 0 && output.length < max){
        index = Math.floor(Math.random()*newSrc.length);
        test = newSrc.splice(index,1);
        //Make sure it's not within 3
        safe = true;
        for (i=0; i<output.length;i++){
            if(Math.abs(test-output[i]) < 3){
                //abort!
                safe=false;
            }
        }
        if(safe){
            output.push(test);
        }
    }

    return output;

};

alert(getRnd(4));

Answer 2

一种方式（不是紧张的方式）将是：

排序数组
选择random元素以启动新的shuffled数组（使用或删除已排序数组中的标记元素）
使用二进制搜索找到下一个元素，即最后一个元素为+3或-3（在-3和+3之间随机选择）。确保元素之前没有标记为使用（否则找另一个元素）
重复3，直到找到元素。
你要么从排序数组中挑选出所有元素，要么就不可能进行这样的改组。

我认为你得到O（N * logN）（排序N * logN并为每个serch选择带有logN的N个元素）。

Answer 3

假设数组中的值不能重复。

function one(array, mod){
    var modArray = [];
    for(var index in array){
        var item = array[index];
        var itemMod = item%3;
        if(itemMod === mod){
            modArray.push(item);
        }
    }
    return modArray();
}

function two(modArray){
    var sortedArray = // sort highest to lowest
    for(var index in sortedArray ){
        var item = array[index];
        if(index > 0 && item[index-1] === item[index]-3){

        }else{return false;}          
    }
    return sortedArray.length;
}

function main(array){
    var a1 = one(array, 0);
    var a2 = one(array, 1);
    var a3 = one(array, 2);

    var a1c = two(a1);
    var a2c = two(a2);
    var a3c = two(a3);

    return // if a1c is greatest then a1, if a2c greatest then a2 ... etc
}

Answer 4

我认为你必须以某种非标准的方式使用短语“shuffle”。如果所有数字都已经在彼此的+ -3范围内，那么排序数组会将它们按正确的顺序排列，除非有重复数据，我猜。

更多示例可能会有所帮助。例如，这些例子是否有效，以及您正在寻找的那种东西？

[0, 3, 3] -> [3, 0, 3]
[9, 3, 6, 0, 6] -> [0, 3, 6, 9, 6]
[3, 3, 6, 0, 6] -> [0, 3, 6, 3, 6]

感觉这可能是图论中解决的问题 - 某种网络遍历具有最大/最小成本函数。

Javascript数组shuffle with padding

4 个答案: