I am trying to calculate the sum of all duplicates in an array. For example:

duplicate([1,1,2,3,3]) --> should return 8.

I have written the following function to calculate the sum of duplicates in an array using JavaScript. Currently it is returning an array with duplicates one less than what they are present in the array.

function duplicate(arr) {
  var sum = 0;
  arr.sort();
  var stack = [];

  for(var i = 0; i < arr.length; i++){
    if (arr[i] === arr[i+1]) {
      stack.push(arr[i])
    } 
  }
  return stack;

}

console.log(duplicate([1,2,1,2,2,3,3]))

This is returning [ 1, 2, 2, 3 ]

How do I get the correct array and calculate the correct sum? I have to use Object for that?

I am trying to calculate the sum of all duplicates in an array. For example:

duplicate([1,1,2,3,3]) --> should return 8.

I have written the following function to calculate the sum of duplicates in an array using JavaScript. Currently it is returning an array with duplicates one less than what they are present in the array.

function duplicate(arr) {
  var sum = 0;
  arr.sort();
  var stack = [];

  for(var i = 0; i < arr.length; i++){
    if (arr[i] === arr[i+1]) {
      stack.push(arr[i])
    } 
  }
  return stack;

}

console.log(duplicate([1,2,1,2,2,3,3]))

This is returning [ 1, 2, 2, 3 ]

How do I get the correct array and calculate the correct sum? I have to use Object for that?

• javascript
• arrays

9 Answers 9

To make the logic easier, you might filter out the non-duplicates by checking whether their indexOf in the array is equal to their lastIndexOf in the array:

function duplicate(arr) {
  const duplicates = arr.filter(elm => arr.indexOf(elm) !== arr.lastIndexOf(elm));
  return duplicates.reduce((a, b) => a + b);
}

console.log(duplicate([1,1,2,3,3])); // --> should return 8.
console.log(duplicate([1,2,1,2,2,3,3]));

Initially create an object where the keys will be the integer and their value will be the number of occurrence. Then if the number of occurrence is more than 1 , multiply the number with number of occurrence.

function duplicate(arr) {
  let dupVal = 0;
  let k = arr.reduce((acc, curr, index) => {
    if (acc[curr] === undefined) {
      acc[curr] = 1
    } else {
      acc[curr] += 1;
    }
    return acc
  }, {});
  for (let keys in k) {

    if (k[keys] > 1) {
      dupVal += parseInt(keys, 10) * k[keys]
    }
  }
  return dupVal;
}

console.log(duplicate([1, 2, 1, 2, 2, 3, 3]))

Try This one

const arr = [1,1,2,3,3]

let dup = arr.filter((value, index)=>{

  // creating a copy of main array
  let copyarr = [].concat(arr)

  // removing present value
  copyarr.splice(index,1)

  // after removing present value, if you still
  // get the value in copied array that means 
  // it has duplicates
  if(copyarr.indexOf(value)>-1){
    return true
  }

  return false

})

// now add it using reduce
let sum = dup.reduce((acc, value)=> acc+value,0)
console.log(sum)

Copy above code and paste into chrome devTool. You will get the answer.

The problem is that you are matching value with immediate next value in array, in array that is sorted already it will work, but not on unsorted one. So try to sort the array first and then run your code.

Edit : Looks like sorting is added in code,

But another condition => if there is number that is repeated more than twice it should be handled and only appear once in stack, if that is required.

This will : console.log(duplicate([1,2,1,2,2,3,3]))

Result this : [1,2,3]

function duplicate(arr) {
  var sum = 0;
  arr.sort();
  var stack = [];

  for(var i = 0; i < arr.length; i++){
    if (arr[i] === arr[i+1]) {
        if(stack.length == 0 || (arr[i] != stack[stack.length-1])){
            stack.push(arr[i])
        }
    } 
  }
  return stack;

}

you can use JS Array.reduce method to acplish your requirement in a shorter way

function sumDplicates(arr) {

  return arr.reduce(function(tot, val, index, _arr) {
    if (_arr.lastIndexOf(val) > index || _arr.indexOf(val) != index)
      return tot + val;
    return tot
  }, 0)
}

console.log(sumDplicates([1, 1, 2, 3, 3]));
console.log(sumDplicates([1, 2, 1, 2, 2, 3, 3]));

You can pursue your original sorting approach with a slight modification:

if (arr[i] === arr[i + 1] || arr[i] === arr[i - 1])

That is, check if the previous or the next element in the sorted array is equal to the current element for it to qualify as a duplicate.

The following solution acplishes this with filter and reduce:

function duplicate(array) {
  return array
          .sort((a, b) => a - b)
          .filter((a, i, arr) => (arr[i] === arr[i + 1] || arr[i] === arr[i - 1]))
          .reduce((a, b) => a + b, 0);
}

console.log(duplicate([1, 1, 2, 3, 3]));
console.log(duplicate([1, 2, 1, 2, 3, 3]));

Array.reduce() and Array.lastIndexOf() will simply solve your problem.

function sum(arr)
{
    return arr.reduce(function(sum, item){
        return arr.lastIndexOf(item)!==arr.indexOf(item) ? sum+=item : sum;
    },0)
}

console.log(sum([1,1,2,3,3]));
console.log(sum([1,2,3,4]));
console.log(sum([1,2,2,3,4]));
console.log(sum([1,1,2,2,3,3,4,4]));

Though I don't know much about JavaScript, If I were you, I would have simply kept a temporary array, which copies all the duplicate variables and then use that array for sum. Also, if you want to add the particular number as many times as it appears, I will suggest creating a table like the one in sparse matrices and then referring to it during addition. This logic, though not space efficient, is very easy to implement.

Here is an approach with a single Array.reduce and nothing else. No Array.indexOf or Array.lastIndexOf. Although it might not be as concise it does not traverse the array looking for indexes multiple times nor does any Array.filter:

const sumDubs = arr => arr.reduce((r,c) => {
  if(r[c]) { 
    r[c] += 1
    r.sum += r[c] > 2 ? (r[c]*c) - ((r[c]-1)*c) : r[c]*c
  } else r[c] = 1
  return r
}, { sum: 0 }).sum

console.log(sumDubs([1, 1, 2, 3, 3]))                       // 8
console.log(sumDubs([1, 2, 1, 2, 2, 3, 3]))                 // 14
console.log(sumDubs([1, 2, 1, 2, 2, 3, 3, 3, 1, 2, 4, 4]))  // 28

The idea is to keep track of the on-going sum via a property in the accumulator of the Array.reduce and simply keep calculating the sum based on which number is duplicated and more importantly how many times.