Logic Manipulation von Arrays, um einen Index zu entfernen

Question

Ich versuche, eine Funktion zu erstellen, die die Bearbeitung von Arrays können ...

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

jetzt habe ich es so

[3, sein möchten 1 , 1, 1]

jetzt meine Funktion akzeptiert drei Parameter

1. ArrayToProcess - gut sein das Array, das
2. indexTarget verarbeitet werden - das ist der ausgewählte Wert, der
von Index definiert ist
3. morphToValue - das ist der Wert, den ich der ausgewählte Wert werden wollen.

gut mein Ziel ist es, die indexTarget zu akzeptieren, die zum Beispiel

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

wie man sehen kann ich meine Funktion Schleife über die myArray will so wird es versuchen, Zahlen im Array hinzuzufügen, bis es wird erreichen Sie die morphToValue so wurde es [3, 1, 1, 1], es reinigt die auf dem ersten Index und 1 auf dem zweiten Index zu 3 zu gewinnen. Es wird nur auch minus eine beliebige Zahl auf dem Array, wenn es fügt sich zu sehr auf die Überschreitung auf dem morphToValue

ein weiteres Beispiel so sein werde ich das Array wollen

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

wie diese

[2, 1, 3]; 

indem Anruf myFunction wie diese

myFunction(myArray,2,3); 

sein, wie kann ich machen dies möglich? Ich mag auch Iterieren am Anfang wieder der Anordnung fortzusetzen, wenn ich indexTarget im letzten Index des Arrays festgelegt werden, so dass es wie dieses

var wäre myArray = [2, 1, 1, 1, 1 ];

wird es

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

werden Sie einen Kommentar setzen, wenn Sie etwas nicht verstehen ....

das ist, was ich bisher 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

ich mein eigenes Problem gelöst .. Ich hoffe, dass dies jemand helfen wird, die das gleiche Problem

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

Versuchen Sie versucht haben,

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

Demo: Fiddle

Answer 3

hier ist meine Variante, sollte es schneller als Splice-Variante arbeiten:

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