逻辑操作，以删除索引

Question

我想创建一个可以操作数组的函数...

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

现在我希望它是这样

[3,1 ，1，1]

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

1. ArrayToProcess - 以及其将被处理
2. 阵列indexTarget - 这是受索引
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(myArray,2,3); 

调用myFunction的我怎样才能使这个可能吗？如果我将在数组的最后一个索引中设置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); 

} 

Answer 1

我解决我自己的问题。我希望这会帮助别人，更是预示了同样的问题

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)); 

Answer 2

尝试

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)) 

演示：Fiddle

Answer 3

这里是我的变种，它应该工作得更快，然后剪接变体。

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; 
}