5

我正在尝试创建一个可以操作数组的函数...

 var myArray = [2, 1, 1, 1, 1];

现在我希望它是这样的

[3, 1, 1, 1]

现在我的函数接受 3 个参数

  1. ArrayToProcess - 它将被处理的数组
  2. indexTarget - 这是由 index 定义的选定值
  3. morphToValue - 这是我希望所选值成为的值。

好吧，我的目标是接受 indexTarget 例如

myFunction(myArray,0,3); //myArray is [2, 1, 1, 1, 1]

如您所见，我希望我的函数循环遍历，myArray因此它会尝试在数组中添加数字，直到它到达morphToValue[3,1,1,1]，它会清除2第一个索引1和第二个指数获得3。如果它在 morphToValue 的超出部分上添加太多，它也会减去数组上的任何数字

另一个例子就是这样我想要数组

var myArray = [2, 1, 1, 1, 1];

变成这样

[2, 1, 3];

通过像这样调用 myFunction

myFunction(myArray,2,3);

我怎样才能做到这一点？如果我将在数组的最后一个索引中设置indexTarget ，我还想继续在数组的开头再次迭代，所以它会是这样的

var myArray = [2, 1, 1, 1, 1];

它会变成

[1, 1, 1, 3]; //when I invoke myFunction(myArray,4,3);

如果您有不明白的地方，请发表评论......

这是我迄今为止尝试过的http://jsfiddle.net/eESNj/

var myArray = ['2', '1', '1', '1', '1'];

indexPurge(myArray, 0, 3);

function indexPurge(haystack, indexTarget, morphToValue) {

    var toIntHaystack = [];

    for (var i = 0; i < haystack.length; i++) {
        toIntHaystack.push(parseInt(haystack[i]));
    }

    console.log(toIntHaystack); //before

    var i = 0;

    var purgedValue = 0;

    do {
        console.log(i + ' - ' + toIntHaystack[i]);
        purgedValue += toIntHaystack[i];
        toIntHaystack.splice(i, 1);
        if (purgedValue >= morphToValue) {
            break;
        }
        i++;
    } while (i < toIntHaystack.length);



    toIntHaystack.splice(indexTarget, 0, morphToValue); //after
    console.log(toIntHaystack);

}
4

3 回答 3

2

我解决了自己的问题..我希望这会帮助遇到同样问题的人

http://jsfiddle.net/YUdJL/

var myarrayx =  [1,1,3]; //5

function morphArray(myarray, index, target){

    //accumulate value on the array to gain target value
    var accu = 0;
    for(var i = 0; i < myarray.length; i++){
        var thisIndex = myarray[i];
        for(var j = 0; j < thisIndex; j++){
            if(accu != target){
                myarray[i]--;  
                accu++;
            }
            else{
                break;
            }
        }
    }

    //remove the zeroes on the array
    for(var k = 0; k < myarray.length; k++){
        if(myarray[k] == 0){
            myarray.splice(k, 1);
        }
    }

    //check if the target index is still available
    if((myarray.length - 1) > index){
        //index is not available anymore.. just push it
        myarray.push(target);
    }
    else{
        //insert the element in the desired index
        myarray.splice(index, 0, target);
    }


    return myarray;
}

console.log('----'+morphArray(myarrayx, 0, 2));
于 2013-11-14T05:40:38.327 回答
2

这是我的变体，它应该比拼接变体工作得更快：

function fixIdx(idx, len) {
    return idx % len; 
}
function fixStartOffset(idx, len) {
    return (idx < len) ? 0 : (idx % len);
}
function morhArray(inputArray, startIndex, targetValue) {
    var l = inputArray.length;
    var sum = 0;
    var endIdx = 0;
    while ( (sum < targetValue) && (endIdx < l) )
        sum += inputArray[fixIdx(startIndex+endIdx++, l)];
    if (endIdx == l) return [sum];
    var outputArray = [];
    for (var i=fixStartOffset(startIndex+endIdx, l); i<startIndex; i++)
        outputArray.push(inputArray[i]);
    outputArray.push(sum);
    for (var i=startIndex+endIdx; i<l; i++)
        outputArray.push(inputArray[i]);
    return outputArray;
}
于 2013-10-25T03:39:41.243 回答
1

尝试

var myArray = [2, 1, 1, 1, 1];

function myfunction(array, index, target) {
    var copy = array.slice(0);
    var c = 0,
        i = index;
    while (c < target && array.length) {
        c += copy.splice(i, 1)[0];
        if (i == array.length - 1) {
            i = 0;
        }
    }
    if (i == index) {
        copy[index] = c;
    } else {
        copy.push(c);
    }
    return copy;
}

console.log(myfunction(myArray, 0, 3));
console.log(myfunction(myArray, 2, 3))
console.log(myfunction(myArray, 4, 3))

演示：小提琴

于 2013-10-25T03:21:34.863 回答