Print Out All Duplicates in an Array - Javascript - Also need time/space complexity of the function

Question

Trying to print out any values that are duplicates. Having an issue visualizing what I need to do. This isn't working.

This is different than any other similar question because I want all the duplicate values to be printed, not just ones that have duplicates.

Could you also give the time/space complexity of the result as well?

This should print out 2, 2, 4, 4, 7, 7

const printDuplicates = (arr) => {
  let newArray = [];

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

console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));

And BTW I APPRECIATE ALL THE HELP

You want `arr[i+1]`, not `arr[i] + 1`. I vote to close this as typo. — trincot, Mar 12 '19 at 19:32
`arr[i] === arr[i] + 1` can never be true. A value cannot be equal to itself + 1. (exception: `Infinity`). — Felix Kling, Mar 12 '19 at 19:32
@trincot: Fair enough. Values >= 2^53 due to lack of precision. — Felix Kling, Mar 12 '19 at 19:35
@mph85 If any of the answers solve your problem, please accept it. Or tell us what is wrong so we can help — Amir, Mar 12 '19 at 20:05
most of these answers work, am i only allowed to accept one answer? — mph85, Mar 12 '19 at 20:22
i upvoted all the answers but it just doesn't show cause im a noobie still, i think i need a few more rep points in order for it to show up — mph85, Mar 12 '19 at 20:22

score 1 · Answer 1 · answered Mar 12 '19 at 19:36

Here's one way - though I must admit it isn't the most elegant but most easy to understand:

const printDuplicates = (arr) => {
  let newArray = [];
  let valToCompare;
  for (let i = 0; i < arr.length; i++) {
    valToCompare = arr[i];
    for (let j = 0; j < arr.length; j++) {
      if (i != j && arr[j] == valToCompare) {
        newArray.push(arr[j]);
      }
    }
  }
  return newArray;
}

console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));

score 1 · Answer 2 · answered Mar 12 '19 at 19:36

1

There are many ways to do this, here's one example using Array.filter

const printDuplicates = (arr) => {
  let newArray = [];

  for (let i = 0; i < arr.length; i++) {
    let targetValue = arr[i];
    let numFound = arr.filter(val => val === targetValue).length;
    let results = {
      targetValue,
      numFound
    }
    newArray.push( results );
    i += ( numFound - 1 );
  }
  return newArray
}

console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));

answered Mar 12 '19 at 19:36

Steven Stark

1,249
11
19

1

appreciate the help, but all i was looking for were the values that were duplicates, this goes beyond that – mph85 Mar 13 '19 at 19:32
yes, it does, but it's a habit of mine to use a collection to be able to filter on later. – Steven Stark Mar 14 '19 at 00:07

score 1 · Answer 3 · answered Mar 12 '19 at 19:39

1

If the duplicates are adjacents, and you want to display them including repeats.

const printDuplicates = (arr) => arr.filter((_,indx) => arr[indx] === arr[indx+1] || arr[indx] === arr[indx-1]);

console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));

answered Mar 12 '19 at 19:39

Zeyad Etman

2,250
5
25
42

what is that underscore `(_, indx)` all about? – mph85 Mar 12 '19 at 20:21
`filter` iterates through the array and in every iteration gives you (element, index, arr) in that order, and I don't need the element, so I put an underscore to ignore it and just used the index. – Zeyad Etman Mar 12 '19 at 20:24
ah so anytime you want to ignore that, you need to put an underscore? – mph85 Mar 12 '19 at 20:27
No, you can put anything, and simply don't use it. – Zeyad Etman Mar 12 '19 at 20:28

Amir · Accepted Answer · 2019-03-12T20:27:21.563

0

Try this:

let arr = [1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9];
result = arr.filter(x => arr.filter(y => y == x).length > 1)
console.log(result);

The filter function takes a function as argument. This function takes each element of the array as argument and should return a boolean value, indicating whether the element should be included in the resulting array or not.

So we use a function that counts the occurrences of the element in the array, and returns true if it appeared more than once, or else returns false.

This occurrence counter also is written using filter function.

UPDATE:

This part, is just a function that counts the occurrences of the x element in arr:

arr.filter(y => y == x).length

So we use it in the filter function, to decide if we want to keep an element or not (if it appeared more than once then keep it). In order to keep an element, we should return true for it in filter function.

edited Mar 12 '19 at 20:27

answered Mar 12 '19 at 19:32

Amir

1,885
3
19
36

2

You need to add more information about the code – JEY Mar 12 '19 at 19:34
@JEY Thanks, checkout my edit. – Amir Mar 12 '19 at 19:40
so you're filtering the filtered results? – mph85 Mar 12 '19 at 20:20
no, the internal `filter` s just used for counting the occurrences. As in it filters the array and counts how many times the element is appeared. then the first filter use this value to decide if it wants to include the element or not – Amir Mar 12 '19 at 20:24
@mph85 Check my update – Amir Mar 12 '19 at 20:27
ah icic thank you for that, makes sense. I'm also looking for the time/space complexity as well. I kinda know how to calculate time, but not space complexity – mph85 Mar 12 '19 at 20:31
@mph85 well if you need a theoretical method, I don't think I have anything to offer. But if you just want a practical answer, I think you can use a very very large array as test case, and monitor the usage of RAM while running each algorithm – Amir Mar 12 '19 at 20:34
hm nothing crazy, just a simple explanation. Maybe something like since I'm filtering the first time, that should be O(n), and since we're running that filter again, maybe O(n2)? – mph85 Mar 12 '19 at 20:43
@mph85 well this is time complexity and since you said you know about that, I was talking about space complexity. But anyway, I think you're right and it is o(n2) – Amir Mar 12 '19 at 20:45
i could be mistaken, but i was told that maybe in this case, the time and space complexity would be the same. – mph85 Mar 12 '19 at 20:56
@mph85 Sorry, I don't know about that – Amir Mar 12 '19 at 20:57
1

no worries, i appreciate the help, ive accepted your answer – mph85 Mar 12 '19 at 21:02
quick question, what is this part `arr.filter(y => y == x).length > 1`, the `.length greater than 1` all about? – mph85 Mar 14 '19 at 03:48
@mph85 number of occurrences greater than 1 – Amir Mar 14 '19 at 06:53
@Amir so basically, this part `arr.filter(y => y === x).length > 1` is saying I want to filter all the values that are duplicate or that are equal to each other that occur more than once? and the outer filter wants to return those filtered results? – mph85 Mar 14 '19 at 06:57

Kamil Kiełczewski · Answer 5 · 2019-03-12T20:29:04.627

-2

O(2n) time complexity (details here)

function printDuplicates(a) {
  let r={}; 
  a.map(a=>!(1-(r[a]=++r[a]|0)) );
  return a.filter(x=>r[x]);
}

console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]))

edited Mar 12 '19 at 20:29

answered Mar 12 '19 at 19:31

Kamil Kiełczewski

85,173
29
368
345

2

You need to add more information about the code – JEY Mar 12 '19 at 19:34
@JEY what is not clear? – Kamil Kiełczewski Mar 12 '19 at 19:48
Given the question I think it's not enough for op to understand – JEY Mar 12 '19 at 19:58
i sorta understand but there's a lot going on – mph85 Mar 12 '19 at 20:20

Print Out All Duplicates in an Array - Javascript - Also need time/space complexity of the function

5 Answers5