How can I optimize this code that checks for duplicates and missing values?

user_13689485 0
Viewed 67

this code is for return duplicates after sorted them, and also to return the missed value between the limits of the given array, it's executed correctly, but i need to re code it so it excecute in less time than it execute can any one help?

function findDupsMiss(arr) {
    // your code here
    var newarr = [];
    var missed;
    var duplicates = [];
    var newdup = []

    arr.forEach((el, i) => {
        if (newarr.includes(el) == false) {
            newarr.push(el)
        }
    })
    var sortedArr = newarr.sort((a, b) => a - b);
    for (var i = 0; i < sortedArr.length - 1; i++) {
        if ((sortedArr[i] + 1) !== sortedArr[i + 1]) {
            missed = sortedArr[i] + 1
        }
    }
    arr.forEach(el => {
        if (arr.indexOf(el) != arr.lastIndexOf(el)) {
            duplicates.push(el)
        }
    })
    duplicates.forEach(el => {
        if (newdup.includes(el) == false) {
            newdup.push(el)
        }
    })


    var lastdup = newdup.sort((a, b) => a - b);
    return [missed, lastdup]
}
findDupsMiss([10, 9, 8, 9, 6, 1, 2, 4, 3, 2, 5, 5, 3])

javascript
3 Answers

You could count the values with a an object and get all keys of it and filter by the value.

For the missing key, find the value which has no previous key.

function findDupsMiss(arr) {
    let count = {},
        duplicates = [],
        missing;

    for (let value of arr)
        if (value in count) count[value]++;
        else count[value] = -1;

    for (let key in count) {
        if (!count[key]) duplicates.push(+key);
        if (!(key - 1 in count)) missing = key - 1;
    }

    return [missing, duplicates];
}

console.log(findDupsMiss([10, 9, 8, 9, 6, 1, 2, 4, 3, 2, 5, 5, 3]));

user_14476750

Or you can use reduce 

function findDupsMiss(arr) {
    // your code here
    var missed;
    var duplicates = [];
    var temp = {}
    
    var sortedArr = arr.sort((a, b) => a - b);
    sortedArr.reduce((prev, cur) => {
        if (!temp[cur]) {
          temp[cur] = true;
        } else {
          duplicates.push(cur)
        }
      
        if ((cur-prev) > 1) {
            missed = prev + 1
        }
        return cur;
    }, sortedArr[0])
    
 
    var lastdup = duplicates.sort((a, b) => a - b);
    return [missed, lastdup]
}

user_105953130

One of decision is reducing loops

function findDupsMiss(arr) {
    // your code here
    var newarr = [];
    var missed;
    var duplicates = [];
    var temp = {}

    arr.forEach((el, i) => {
        if (!temp[el]) {
          temp[el] = true;
        } else {
          duplicates.push(el)
        }
        
        if (newarr.includes(el) === false) {
            newarr.push(el)
        }
    })
    
    var sortedArr = newarr.sort((a, b) => a - b);
    
    for (var i = 0; i < sortedArr.length - 1; i++) {
        if ((sortedArr[i] + 1) !== sortedArr[i + 1]) {
            missed = sortedArr[i] + 1
        }
    }
   
    var lastdup = duplicates.sort((a, b) => a - b);
    return [missed, lastdup]
}

user_105953130
Related