Push duplicate items into a separate array in Javascript with for loop?

Question

For some reason, the manipulated doubleArray below is not shown in the console. Any variables that I declare after the for loop won't show to the console on both cases. Consider that in the first algorithm, there is only one for loop with x being incremented everytime. Whereas, in the second algorithm, it's a nested for loop. Can someone help me fix my error in both algorithms? First Algorithm:

var isDuplicate = function() {
  var helloWorld = [1,2,3,4,3];
  var doubleValue = [];
  var x = 0;
  for (i = 0; i < helloWorld.length; i++) {
    x = x + 1;
    if (helloWorld[i] === helloWorld[x] && i !== x) {
      doubleValue.push(helloWorld[i])
      console.log(helloWorld[i]);
    } else {
      continue;
    }
  }
  console.log(doubleValue);
};

The second Algorithm:

var isDuplicate = function() {
  var helloWorld = [1,2,3,4,3];
  var doubleValue = [];
  for (i = 0; i < helloWorld.length; i++) {
    for (x = 1; x < helloWorld.length; i++) {
      if (helloWorld[i] === helloWorld[x] && i !== x) {
        doubleValue.push(helloWorld[x]);
      }
    }
  }
  console.log(doubleValue);
};

Answer 1

The main problem by finding duplicates is to have nested loop to compare each element of the array with any other element exept the element at the same position.

By using the second algorithm, you can iterate from the known position to reduce the iteration count.

var isDuplicate = function(array) {
    var doubleValue = [];
    outer: for (var i = 0; i < array.length - 1; i++) { // add label,
                                                        // declare variable i
                                                        // no need to check last element
        for (var j = i + 1; j < array.length; j++) {    // start from i + 1,
                                                        // increment j
            if (array[i] === array[j]) {                // compare values, not indices
                doubleValue.push(array[i]);
                continue outer;                         // prevent looping
            }
        }
    }
    return doubleValue;
};

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

You could take an object for storing seen values and use a single loop for getting duplicate values.

const
    getDuplicates = array => {
        const
            seen = {}
            duplicates = [];
        
        for (let value of array) {
            if (seen[value]) duplicates.push(value);
            else seen[value] = true;
        }
        
        return duplicates;
    };

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

Answer 2

Not entirely sure what you are trying to do. If you are only looking for a method to remove duplicates you can do the following:

const hello_world = [1, 2, 2, 3, 4, 5, 5];
const duplicates_removed = Array.from(new Set(hello_world));

A set is a data object that only allows you to store unique values so, when converting an array to a set it will automatically remove all duplicate values. In the example above we are creating a set from hello_world and converting it back to an array.

If you are looking for a function that can identify all the duplicates in an array you can try the following:

const hello_world = [1, 2, 2, 3, 4, 5, 5];
const duplicates_found = hello_world.filter((item, index) => hello_world.indexOf(item) != index);

Answer 3

var isDuplicate = function() {
    var helloWorld = [1,2,3,4,3,4];
    var doubleValue = [];
    for (i = 0; i < helloWorld.length; i++) {
      for (x = i + 1; x < helloWorld.length; x++) {
        if (helloWorld[i] === helloWorld[x]) {
          doubleValue.push(helloWorld[x]);
        }
      }
    }
    console.log(doubleValue);
  };

  isDuplicate()

Answer 4

In first algorithm, you are only checking if the number at current index is equal to the number at the next index, meaning you are only comparing numbers at consecutive indexes. First algorithm will work only if you have duplicate numbers on consecutive indexes.

In second algorithm, you are incrementing i in both loops, increment x in nested loop, change x = 1 to x = i + 1 and your error will be fixed.

Here's the fixed second code snippet

var isDuplicate = function() {
  var helloWorld = [1,2,3,4,3, 1, 2];
  var doubleValue = [];
  for (let i = 0; i < helloWorld.length; i++) {
    for (let x = i + 1; x < helloWorld.length; x++) {
      if (helloWorld[i] === helloWorld[x] && i !== x) {
        doubleValue.push(helloWorld[x]);
      }
    }
  }
  console.log(doubleValue);
};

isDuplicate();

Heres's another way to find the duplicates in an array, using an object. Loop over the array, if current number is present as key in the object, push the current number in the doubleValue array otherwise add the current number as key-value pair in the object.

const isDuplicate = function() {
  const helloWorld = [1,2,3,4,3, 1, 2];
  const doubleValue = [];
  const obj = {};
  
  helloWorld.forEach(n => obj[n] ? doubleValue.push(n): obj[n] = n);
  
  console.log(doubleValue);
};

isDuplicate();

Answer 5

Your first algorithm doesn't work because it only looks for duplicates next to each other. You can fix it by first sorting the array, then finding the duplicates. You can also remove the x and replace it by ++i in the loop.

var isDuplicate = function() {
  var helloWorld = [1,2,3,4,3,6];
  var doubleValue = [];
  helloWorld = helloWorld.sort((a, b) => { return a - b });
  for (i = 0; i < helloWorld.length; i++) {
    if (helloWorld[i] === helloWorld[++i]) {
      doubleValue.push(helloWorld[i])
      console.log(helloWorld[i]);
    } else {
      continue;
    }
  }
  console.log(doubleValue);
};

isDuplicate();

For the second algorithm loop, you probably meant x++ instead of i++ in the second loop. This would fix the problem.

Answer 6

The first algorithm can't be fixed, it can only detect consecutive duplicates, in the second algorithm you increment i in both loops.

To avoid the duplicates beeing listed too often, you should start the second loop with i + 1