Javascript - Remove Unique Elements from Array

Question

I am wondering how one would go about removing unique elements from an array. For example:

var arr = [1, 2, 2, 4, 4] would return [2, 2, 4, 4]. Where [1, 2, 3] would return [] because all elements are unique.

I believe I need to check each element with every other element in the array, but I'm not sure how to go about this.

Thanks!

Answer 1

With ES6, you could use a Array#map and count the values with Array#forEach.

Later use Array#filter and check the count.

If greater than 1 return true (include the item in the result set), otherwise return false (do not include item in the result set).

function getNotUnique(array) {
    var map = new Map();
    array.forEach(a => map.set(a, (map.get(a) || 0) + 1));
    return array.filter(a => map.get(a) > 1);
}

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

Answer 2

Below is basic and easy to understand for removing unique elements from array.

function removeUnique(arr) {
 var newArr = [];
 for (var i = 0; i < arr.length; i++) {
  var count = 0;
  for (var j = 0; j < arr.length; j++) {
   if (arr[j] == arr[i]) {
    count++;
   }
  }
  if (count >= 2) {
   newArr.push(arr[i]);
  }
 }
    return newArr;
}
console.log(removeUnique([1, 2, 2, 4, 4]));

Answer 3

This should do it;

var arr = [1, 2, 2, 4, 4],
    unq = arr.map((e,i,a) => a.filter(f => f === e ).length)
             .reduce((p,c,i) => c === 1 ? p : p.concat(arr[i]) ,[]);
console.log(unq);

However on a second thought the following might be even more readable and efficient. We are in fact using one of the rare cases in which we can utilize laziness in JS through a short circuit.

var r = [1,2,2,4,4].filter((e,i,a) => a.lastIndexOf(e) != i || a.indexOf(e) != i);
console.log(r);

So the a.indexOf(e) != i portion only runs for the unique elements and the last encountered non-unique element. Cool.

Answer 4

The code is below returns all duplicated values

const getDuplicatedVals = (data) => data.filter( (x) => data.indexOf(x) != data.lastIndexOf(x))

Answer 5

Here is an implementation (using https://stackoverflow.com/a/5668029/4202031)

function removeUnique(arr) {
  var counts = {}

  for(var i = 0; i< arr.length; i++) {
      var num = arr[i]
      counts[num] = counts[num] ? counts[num]+1 : 1
  }

  var result = []
  for(var key in counts) {
    if(Object.prototype.hasOwnProperty.call(counts, key) && counts[key] > 1 {
      result.push(key)
    }
  }

  return result
}


var arr = [1, 2, 3]
var arr2 = [1, 1, 2, 2, 4, 6, 4]

console.log(removeUnique(arr)) // []
console.log(removeUnique(arr2)) // [ '1', '2', '4' ]

Answer 6

You could do something like this (strictly using arrays):

var arr = [1,2,3,4,4];
var temp = [];
var to_keep = [];
for(var x = 0; x < arr.length; x++){
  if(temp.indexOf(arr[x]) > -1) {
    if(to_keep.indexOf(arr[x]) == -1)
      to_keep.push(arr[x]);
  } else if(temp.indexOf(arr[x]) == -1) temp.push(arr[x]);
}

for(var y = 0; y < arr.length; y++){
  if(to_keep.indexOf(arr[y]) == -1){
    arr.splice(y,1);
    y--;
  }
}

// arr = [4,4];

Answer 7

Iterate through the array, use the value as an index into an object and increment for each occurrence in the original. Then iterate through the object and pull out those with totals greater than one. Should work for string and numeric types.

function dupsOnly(a) {
    var T = {};
    for (var i = 0; i < a.length; i++) {
        if (a[i] in T)
            T[a[i]] += 1;
        else
            T[a[i]] = 1;
    }
    var D = [];
    for (var t in T) {
        if (T[t] > 1)
            D.push(t);
        while (T[t] > 1) {
            T[t] -= 1;
            D.push(t);
       }
    }
    return D;
}

Answer 8

var arr = [1, 2, 2, 4, 4]

var dict_with_count = {}
for (var i=0; i<arr.length; i++){
   dict_with_count[arr[i]] = 0
}

for (var i=0; i<arr.length; i++){
   dict_with_count[arr[i]] += 1
}

var new_list = [];

for (key in dict_with_count){
   if (dict_with_count[key] > 1){
       for (var j=0; j<dict_with_count[key]; j++){
          new_list.push(key)
       }
   }
}

console.log(new_list)

Answer 9

#include <stdio.h>

int main() {
    int n;

    printf("Enter the length of the array: ");
    scanf("%d", &n);

    int array[n];
    int frequency[1000] = {0}; // Assuming element range from 0 to 999

    printf("Enter the elements of the array:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &array[i]);
        frequency[array[i]]++;
    }

    int newSize = 0;

    // Remove unique elements directly in the original array
    for (int i = 0; i < n; i++) {
        if (frequency[array[i]] > 1) {
            array[newSize] = array[i];
            newSize++;
            frequency[array[i]] = 0; // Mark as copied
        }
    }

    printf("Array after deleting unique elements:\n");
    for (int i = 0; i < newSize; i++) {
        printf("%d ", array[i]);
    }

    return 0;
}