邏輯操作，以刪除索引

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