Better way to deal with dynamic MIN & MAX numbers to find range of missing number in an array

const findMissing = num => {
  const max = Math.max(...num); // Will find highest number
  const min = Math.min(...num); // Will find lowest number
  const missing = []

  for(let i=min; i<= max; i++) {
    if(!num.includes(i)) { // Checking whether i(current value) present in num(argument)
      missing.push(i); // Adding numbers which are not in num(argument) array
    }
  }
  return missing;
}

findMissing([1,15]);

Use indexOf() to check element in array or not

var a = [5],
  count = 5,
  missing = [];

for (var i = 1; i <= count; i++) {
  if (a.indexOf(i) == -1) {
    missing.push(i);
  }
}

document.write('<pre>' + JSON.stringify(missing) + '</pre>');

A one-line ES6 riff:

let missingNumbers = (a, l=true) => Array.from(Array(Math.max(...a)).keys()).map((n, i) => a.indexOf(i) < 0  && (!l || i > Math.min(...a)) ? i : null).filter(f=>f);

By default returns numbers missing from a sequence of more than one number:

array = [2, 5, 9]
missingNumbers(array)
// returns [3, 4, 6, 7, 8]

But you can set the low-value flag to false and get a result starting with 1:

missingNumbers(array, false)
// returns [1, 3, 4, 6, 7, 8]

missingNumbers([5])
// returns [1, 2, 3, 4]

or simply define the function without the flag

let missingNumbers = (a) => Array.from(Array(Math.max(...a)).keys()).map((n, i) => a.indexOf(i) < 0? i : null).filter(f=>f);

Try running the code snippet

var a = [1,4,7], count = a[a.length - 1];
var missing = [];
for ( var i = 1; i <= count; i++ ) {
	if (a.indexOf(i) == -1) {
		missing.push(i);
	}
}
alert(missing.toString());

The missing number can be found by finding total (n*(n+1)/2) and subtract total from each value the renaming number will be the required number.

function findNumber(arr) {
  var n = arr.length;
  var total = ((n + 2) * (n + 1)) / 2;
  for (let i = 0; i < n; i++) {
    total -= arr[i];
  }
  return total;
}

var arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(findNumber(arr));

function missingItems(arr, n) {
  let missingItems = [];
  for (let i = 1; i <= n; i++) if (!arr.includes(i)) missingItems.push(i);
  return missingItems;
}
console.log(missingItems([9, 1, 4, 2, 10, 6], 10));

Although this solution would take a time complexity of 0(n), you could easily get all the missing items between 1 and n by running a loop from 1 to n and checking if the index exists in the array arr on each iteration.

Simple

consider _ is lodash or underscore

var arr = [2,3,4,5];

var min = _.min(arr);
var result = [];

for (var i = 0; i < min; i++) {
    result.push(i);
}

result // [0, 1];

You could switch your loops around and set a flag. This may not be the fastest method, but it worth looking at since this is the first thoughts you had.

The Fix

Example: jsFiddle

var missing = [];
var a = [5];
var count = 5;
var found = false;

for (var j = 1; j < count; j++) {
  found = false;
  for (var i = 0; i <= a.length; i++) {
    if (a[i] == j) {
      found = true;
      break;
    }
  }
  if (!found) {
    missing.push(j);
  }
}

alert(JSON.stringify(missing));

One way is to find missing numbers by using this:

Array.from({length: Math.max(...b)},(_,x) => !b.includes(x+1)?x+1:false).filter(Boolean)

Lodash solution:
It will work for any number that are missing between the min & max of array values.

let numbersArray = [0, 1, 3, 6, 7];
let missedNumbersArray = [];
_.forEach(_.range(_.min(numbersArray), _.max(numbersArray)), (number, index) => {
    if (_.findIndex(numbersArray, val => val == number) == -1) {
        missedNumbersArray.push(index);
    }
});

const myFunc = (arr) => {
  const sum = ((arr.length + 1) * (arr.length + 2)) / 2;
  const arrSum = (arr) => arr.reduce((a, b) => a + b, 0);
  return sum - arrSum(arr);
};
const myArray = [1, 2, 10, 5, 6, 4, 7, 9, 3, 11];
console.log(myFunc(myArray));

Explanation:

1. Storing sum of natural numbers in  "sum" variable up to one more of length of array. We are adding one more to the length of the array because one number is missing. To calculate the sum, we are using the sum of n natural number formula i.e  n*(n+1)/2.
2. Now calculating the sum of our given array using reduce().
3. It is clear that one number is missing from our Array so subtracting the sum of the given array from the sum of natural numbers will give us the missing number.

You can do this with the use of XOR operator:

let arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
let x1 = xorOfArray(arr1, arr1.length); // 8
console.log(x1);

let arr2 = [1, 2, 3, 4, 5, 7, 8]; // 6 is missing
let x2 = xorOfArray(arr2, arr2.length); // 14
console.log(x2);

let arr3 = [x1, x2];
let x3 = xorOfArray(arr3, arr3.length); // 6
console.log(x3);
// x3 is the missing number

function xorOfArray(arr, n) 
{ 
    // Resultant variable 
    let xor_arr = 0; 
  
    // Iterating through every element in 
    // the array 
    for (let i = 0; i < n; i++) { 
  
        // Find XOR with the result 
        xor_arr = xor_arr ^ arr[i]; 
    } 
  
    // Return the XOR 
    return xor_arr; 
} 

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    
    const filterArr= [...new Set(A.filter(x=> x>0).sort())];
   
    let k=1;
    
    function newArr(){
        for(let i=0;i<filterArr.length;i++){
            if(filterArr[i]=== k){
                    k++;
            }
            else{
                return k;
            }
        }
        return k;
      }
    
    return filterArr.length? newArr():1;  
}

console.log(solution([3,2,1,5]));   output:4

console.log(solution([-1,-2.-5]));  output: 1

console.log(solution([1,2.3,4]));   output: 5

That's only for sequenced array:

const findMissingNumber = (arr) => {
  for (let i = 1; i <= arr.length; i++) {
    if (arr[i - 1] !== i) {
      return i;
    }
  }
}
const arr = [1, 2, 3, 4, 5, 6, 8, 10];
console.log(findMissingNumber(arr));

Finding the missing numbers of given array using javascript;

//add a sorting function to get exact output

let len = parseInt(prompt("Enter the range : "));
let arr = [];let i = 0;
for (i = 0; i < len;i++){
    let num = parseInt(prompt("Enter the numbers : "));
    arr.push(num);
    /*arr.sort(function(a,b){
          return a - b;
    });*/
}

missingNum = (arr) => {
    let i = 0,j = 0;
    let start = arr[0];
    let end = arr[arr.length - 1];
    let miss = [];
    let found = false;
    let result = "";

for (i = start; i<=end; i++){
    found = false;
    for(j = 0;j<arr.length;j++){
        if(arr[j] == i){
            found = true ;
            break;
        }   
    }
    if(!found){
        miss.push(i)
    }
}
return  miss;
}
console.log(missingNum(arr))

function missingArray(params) {
    var arr =[1,3,5,8,9];
    var missing = []; 
    for (let i = 0; i < arr[arr.length-1]; i++) {
        if(!(arr.includes(i))){
           missing.push(i);
        }
       
    }
    return missing;
}

console.log(missingArray());

function findMissingNumbers(arr) {
  // sort the array in ascending order
  arr.sort(function(a, b) {
    return a - b;
  });

  // initialize the missing numbers array
  const missing = [];

  // iterate through the array
  for (let i = 0; i < arr.length - 1; i++) {
    // calculate the difference between the current and next number
    const diff = arr[i + 1] - arr[i];

    // if the difference is greater than 1, there is a missing number(s)
    if (diff > 1) {
      // push the missing number(s) into the array
      for (let j = 1; j < diff; j++) {
        missing.push(arr[i] + j);
      }
    }
  }

  // return the missing numbers array
  return missing;
}

Brute, buffer and best solutions just with pure JS:

const nums = [1,2,3,4,6];

// Brute sol
// Time complexity = O(n2)
// Space complexity = O(n)

const findMissingNumberBrute = (nums, n) => {
    for(let i = 1; i <= n - 1; i++) {
        let flag = 0;
        for(let j = 0; j <= n; j++) {
            if(nums[j] == i) {
                flag = 1;
            }
        }
        if(flag === 0) {
            return i;
        }
    }
    
}

// 5
console.log(findMissingNumberBrute(nums, 6))

// Buffer sol
// Time complexity = O(n) + O(n)
// Space complexity = O(n)

const findMissingNumberBuffer = (nums, n) => {
    const obj = {};
    for(let i = 0; i < n-1; i++) {
        obj[nums[i]] = 1
    }
    for(let j = 1; j <= n; j++) {
        if(obj[j] === undefined) {
            return j
        }
    }
}

// 5
console.log(findMissingNumberBuffer(nums, 6))


// Best sol
// Time complexity = O(n)
// Space complexity = O(1)

const findMissingNumberBest = (nums, n) => {
    // get the sum of first n natural numbers
    const totalSumOfFirstNNumners = (n*(n+1)/2);
    let sum = 0;

    for(let i = 0; i <= nums.length -1; i++) {
        sum = sum + nums[i]
    }
    return totalSumOfFirstNNumners - sum;
}

// 5
console.log(findMissingNumberBest(nums, 6))

// Best1 with xor sol
// Time complexity = O(1)
// Space complexity = O(1)

const findMissingNumberBest1 = (nums, n) => {
    // get the sum of first n natural numbers
    let xor1 = 0;
    for(let i = 0; i <= n; i++) {
        xor1 = xor1 ^ i;
    }
    let xor2 = 0;
    for(let j = 0; j <= n - 1; j++) {
        xor2 = xor2 ^ nums[j];
    }

    return xor1 ^ xor2;
}

// 5
console.log(findMissingNumberBest1(nums, 6))

class Solution{
    missingNumber(array,n){ 
     let res = 0;
        for (let i = 0; i <= n; i++)  res ^= i;  
        
        for (let i = 0; i < n-1; i++) res ^= array[i]
       return res
    }
}

N = 10
A = [6,1,2,8,3,4,7,10,5]

const find = new Solution()
console.log(find.missingNumber(A, N))

Missing element in array code for sequence or non sequence array

const arry = [2,6,5,11,9,13];

function missing(arr) {

let s = arr[0];

let missingArr = [];

  for (let i = 0; i < arr[arr.length-1]; i++) {   
    
    if(s !== arr[arr.length-1]) {
    
      if(!arr.includes(s)) {
            missingArr.push(s)
       };

       s = s+1;
    };
  
  }
  
  return missingArr;
};

console.log('====>>>', missing(arry));

This is how to find missing number in a array(sorted array),
It checks only one missing number.

function miss(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== i + 1) {
      return i + 1;
    }
  }
}
let a = miss([1, 2, 3, 4, 5, 7, 8, 9, 10])
console.log(a)

function missing(arr) {
  let n = arr.length;
  let sum = (n + 1) * (n + 2) / 2
  let total = arr.reduce((acc, item) => acc + item);
  let missin = sum - total
  return missin

}

let b = missing([1, 2, 3, 4, 6, 7, 8, 9]);
console.log(b)