Mersenne prime in JavaScript

In Mathematics, a Mersenne prime is a number that can be written in the form M(n) = 2^n ? 1 for some integer n and is actually a prime number.

For example ? The first four Mersenne primes are 3, 7, 31, and 127, which correspond to n = 2, 3, 5, and 7 respectively:

• 2² ? 1 = 3
• 2³ ? 1 = 7
• 2? ? 1 = 31
• 2? ? 1 = 127

We need to write a JavaScript function that takes in a number and checks whether it is a Mersenne prime or not.

Understanding the Algorithm

To check if a number is a Mersenne prime, we need to:

1. First verify the number is prime
2. Then check if it can be written as 2^n ? 1

For the second step, we can add 1 to the number and check if the result is a power of 2.

Implementation

const isPrime = num => {
    if (num < 2) return false;
    let i = 2;
    while (i <= num / 2) {
        if (num % i++ === 0) {
            return false;
        }
    }
    return true;
}

const mersennePrime = num => {
    // First check if the number is prime
    if (!isPrime(num)) {
        return false;
    }
    
    // Check if num + 1 is a power of 2
    let n = num + 1;
    while (n !== 1) {
        if (n % 2 !== 0) {
            return false;
        }
        n /= 2;
    }
    return true;
};

// Test with known Mersenne primes
console.log(mersennePrime(31));   // 2^5 - 1
console.log(mersennePrime(127));  // 2^7 - 1
console.log(mersennePrime(3));    // 2^2 - 1
console.log(mersennePrime(7));    // 2^3 - 1

// Test with non-Mersenne numbers
console.log(mersennePrime(37));   // Prime but not Mersenne
console.log(mersennePrime(87));   // Not even prime

true
true
true
true
false
false

How It Works

The isPrime function checks if a number is prime by testing divisibility from 2 up to half the number. The mersennePrime function first verifies the number is prime, then adds 1 and checks if the result is a power of 2 by repeatedly dividing by 2.

Alternative Approach Using Bit Operations

We can optimize the power-of-2 check using bitwise operations:

const isPowerOfTwo = n => {
    return n > 0 && (n & (n - 1)) === 0;
};

const mersennePrimeOptimized = num => {
    if (!isPrime(num)) {
        return false;
    }
    return isPowerOfTwo(num + 1);
};

console.log(mersennePrimeOptimized(31));   // true
console.log(mersennePrimeOptimized(127));  // true
console.log(mersennePrimeOptimized(37));   // false

true
true
false

Conclusion

A Mersenne prime is both a prime number and can be expressed as 2^n ? 1. Our algorithm efficiently checks both conditions by verifying primality first, then testing if adding 1 gives a power of 2.