Javascript數組隨機填充

Question

在每個數字必須為下一個/上一個數字的+3或-3的條件下，對數字數組進行混洗的最佳方法是什么？ 因此，例如[0,1]無效，但[0,3]無效。

謝謝！

Answer 1

查看屏幕快照，您似乎希望從列表中選擇一個隨機的分類，彼此之間不得有2個選擇。 此代碼采用一個數組，並為您提供滿足該條件的數組子集。 您也可以指定最大選擇數，盡管可能不會總是得到那么多選擇。

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

一種方法（不是空腹）是：

1. 排序數組
2. 選擇隨機元素以開始新的改組數組（將已排序數組中的mark元素標記為使用或刪除）
3. 使用二進制搜索時，找到下一個為+3或-3的最后一個元素（在-3和+3之間隨機選擇）。 確保之前未將元素標記為已使用（否則找到另一個）
4. 重復3直到找到元素。
5. 您要么從排序數組中選擇了所有元素，要么無法進行這種改組。

我認為您可以通過此操作獲得O（N * logN）（對N * logN進行排序，並為每個服務使用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

我認為您必須以某種非標准的方式使用“隨機播放”一詞。 如果所有數字都已經在+ -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]

感覺這可能是圖論中已解決的問題-一種具有最大/最小成本函數的網絡遍歷。