 # How to Find the Odd Number in an Array with JavaScript In this post, we’ll look at how to use JavaScript to locate a missing positive odd number in an array. When one number is missing from a series of positively odd numbers that are consecutive, this can be helpful. To make the process easier for you to grasp, we’ll give you a step-by-step manual.

## For Loop Method – Odd Number in an Array

### Step 1: Create a function

To begin, let’s create a JavaScript function called findMissingOddNumber. This function will take an array of numbers as input and return the missing positive odd number.

``````function findMissingOddNumber(numbers) {
// Code goes here
}
``````

### Step 2: Initialize variables

We’ll initialise two variables within the function: minNumber and maxNumber. The minNumber function returns the smallest number in the specified array, whereas the maxNumber function returns the largest number.

``````function findMissingOddNumber(numbers) {
let minNumber = Math.min(...numbers);
let maxNumber = Math.max(...numbers);
// Code goes here
}
``````

### Step 3: Find the missing number

The missing odd number will then be found by iterating through the range of numbers from minNumber to maxNumber. To do this, a for loop will be used.

``````function findMissingOddNumber(numbers) {
let minNumber = Math.min(...numbers);
let maxNumber = Math.max(...numbers);

for (let i = minNumber; i <= maxNumber; i++) {
// Check if the current number is odd and not present in the array
if (i % 2 !== 0 && !numbers.includes(i)) {
return i;
}
}

return -1; // If no missing odd number is found
}
``````

### Step 4: Testing the function

Now, let’s test our function with a sample array to see if it correctly identifies the missing odd number.

``````let numbers = [1, 3, 5, 7, 9, 13, 15, 17];
console.log(findMissingOddNumber(numbers)); // Output: 11
``````

## Other Methods – Odd Number in an Array

### Array filter() Method

We can use the Array filter() method to locate the odd integers in an array by feeding it a callback that returns true when the number is odd and false otherwise.

``````function findMissingOddNumber(numbers) {
let minNumber = Math.min(...numbers);
let maxNumber = Math.max(...numbers);

// Filter out the existing odd numbers in the array
let existingNumbers = numbers.filter(num => num % 2 !== 0);

// Find the missing odd number between minNumber and maxNumber
let missingNumber = Array.from({ length: maxNumber - minNumber + 1 }, (_, index) => minNumber + index)
.filter(num => num % 2 !== 0)
.filter(num => !existingNumbers.includes(num));

return missingNumber;
}

console.log(findMissingOddNumber(numbers)); // Output: 11``````

In this method, we first use numbers to filter the original array’s existing odd numbers away.(num => num% 2!== 0) is a filter. By doing this, an array called existingNumbers is created and it contains all of the odd numbers that were in the initial array.

Then, using the Array.from() and filter() methods, a new array is created. The odd numbers are filtered out of an array of numbers between minNumber and maxNumber (inclusive). Then, this array is further filtered to get rid of the numbers that are already in the existingNumbers array.

The missing odd number, which is kept in the missingNumber array, is then returned.

### Array ForEach Method

``````function findMissingOddNumber(numbers) {
let minNumber = Math.min(...numbers);
let maxNumber = Math.max(...numbers);
let missingNumber = -1;

// Iterate over the range of numbers
Array.from({ length: maxNumber - minNumber + 1 }, (_, index) => minNumber + index)
.forEach(num => {
if (num % 2 !== 0 && !numbers.includes(num)) {
missingNumber = num;
}
});

return missingNumber;
}

console.log(findMissingOddNumber(numbers)); // Output: 11
``````

In this code, we first determine the minimum (minNumber) and maximum (maxNumber) values from the given array using the Math.min() and Math.max() functions, respectively.

Next, we use the Array.from() method along with the forEach() method to iterate over the range of numbers between minNumber and maxNumber. We create an array of these numbers using Array.from() and iterate over each number using forEach(). Within the iteration, we check if the number is odd and if it is not included in the original array (!numbers.includes(num)). If both conditions are true, we update the missingNumber variable with the current number.

Finally, we return the value of the missingNumber variable, which will contain the missing positive odd number if found. If no missing number is found, the function will return -1.