J'essaie de faire cet exercice:

Le défi est de mettre en œuvre une fonction qui additionne tous ensemble les numéros consécutifs dans un tableau et les pousse dans un nouveau tableau. exemple: sumConsecutives ([1,1,2,1,1,1,1,2,1,1,1]); // -> [2,2,4,2,3]

Mon idée est de diviser le tableau en un tableau de tableaux. Donc, pour l'exemple ci-dessus: [[1,1],[2],[1,1,1,1],[2],[1,1,1]] puis passez par et reduce les.

J'ai essayé avec une boucle while et push dans une variable temporaire qui est ensuite poussée si le nombre suivant n'est pas le même, en vain.

Des idées sur la façon d'y parvenir?

3
Apswak 9 août 2016 à 11:41

7 réponses

Meilleure réponse

L'approche la plus simple à laquelle je pouvais penser ... (sans carte / réduire, cependant)

var sumConsecutives = function(arr) {
var newArr = [];
var prev = arr[0];
var sum = arr[0];

for (var i=1; i<arr.length; i++){
	if (arr[i] !== prev) {
		newArr[newArr.length] = sum;
		sum = 0;
	}
	sum += arr[i];
	prev = arr[i];
}

// Add last sum
newArr[newArr.length] = sum;

return newArr;
};

console.log ( sumConsecutives([1,1,2,1,1,1,1,2,1,1,1]) );
	
3
lpg 9 août 2016 à 09:04

Vous pouvez utiliser array.reduce

Logique

  • Créez un tableau temporaire.
  • faire une boucle sur le tableau et vérifier si la valeur précédente et actuelle.
  • S'il en est de même, prenez le dernier élément du tableau temporaire et ajoutez-y la valeur actuelle.
  • Sinon, poussez l'élément courant vers le tableau temporaire

Échantillon

function sumConsecutives(arr) {
  var r = [];
  arr.reduce(function(p, c, i, a) {
    if (p === c) {
      r[r.length - 1] += c
    } else {
      r.push(c)
    }
    return c;
  }, 0);
  return r;
}
var a = [1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1];
console.log(sumConsecutives(a));
0
Rajesh 9 août 2016 à 09:03

Vous pouvez également essayer cette approche:

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

source.reduce(function(p, c, index, arr) {                 
   if (p.length === 0 || arr[index - 1] !== c) {
       return p.concat(c);
   }
   else if (arr[index - 1] === c) {           
        p[p.length - 1] += c             
   }

   return p;
}, []);
0
Dhananjaya Kuppu 9 août 2016 à 09:24

C'est le plus simple auquel je pouvais penser:

var testarr = [1,1,2,1,1,1,1,2,1,1,1];
var resultarr = [testarr[0]];
for(var i=1; i<testarr.length; i++){
	if(testarr[i-1]==testarr[i]){
		resultarr[resultarr.length - 1] += testarr[i];
	}else{
		resultarr.push(testarr[i]);
	}
}
console.log(resultarr);
0
Julian Kuchlbauer 9 août 2016 à 09:06
function sumConsecutives(input) {
    var output = [],
        factor = 1,
        lastnr = null;

    for (var i = 0; i < input.length; i++) {
        if (i === 0) {
            lastnr = input[i];
            continue;
        }

        if (input[i] !== lastnr) {
            output.push(lastnr * factor);
            lastnr = input[i];
            factor = 1;
        } else {
            factor++;
        }

        if (i === (input.length - 1)) {
            output.push(input[i] * factor);
        }
    }
    return output;
}

var result = sumConsecutives([1,1,2,1,1,1,1,2,1,1,1]);
0
simialbi 9 août 2016 à 08:54

J'ai aimé le défi, alors je l'ai fait dans une fonction en deux étapes que vous avez jugée utile.

  • La première réduction crée le tableau de tableaux

  • La seconde réduction les résume.

Ce n'est pas le code le plus court, mais j'espère le plus compréhensible.

const arr = [1,1,2,1,1,1,1,2,1,1,1];
let currentNumber = undefined;
let currentTempArr = [];

let newArr = arr.reduce((tempArr, value) => {
  // check if current number is set
  if(currentNumber == undefined) currentNumber = value;
  
  // if current number then push to temp array
  if(currentNumber == value)
    currentTempArr.push(value);
  // else just create a new array and push the old one into the parent array
  else {
    tempArr.push(currentTempArr);
    currentTempArr = [];
    currentNumber = value;
    currentTempArr.push(value);
  }
  
  // return the array back to the next reduce iteration
  return tempArr;
}, []);

// push the last temp array, because the function stops before the push
newArr.push(currentTempArr);

// this build your array of arrays
console.info('The array of arrays');
console.log(newArr); // [ [1,1,1], [2], ... ]

// now sum up the sub arrays
let sumArr = newArr.reduce((tempArr, value) => {
  let sum = 0;
  
  // for every value in the array we add that to the sum
  value.forEach(val => sum += val);
  
  // add the total to the temp array
  tempArr.push(sum);
  
  // return the filled array back to the reduce function
  return tempArr;
}, []);

// the array with summed up values
console.info('see the magic happen');
console.log(sumArr);
1
Randy 10 août 2016 à 08:07

Vous pouvez utiliser une approche reduce en une seule étape:

const sumConsecutives = ar =>
ar.reduce((ac, x, i) => {
  if ( i !== 0 && ar[i-1] === x)
    ac[ac.length -1] += x;
  else 
    ac.push(x);
    
  return ac;
 }, [])


var r = sumConsecutives([1,1,2,1,1,1,1,2,1,1,1]); // -> [2,2,4,2,3]

console.log(r)
2
maioman 9 août 2016 à 09:11