Miller-Rabin Primality Test - Problem

The Miller-Rabin primality test is a probabilistic algorithm used to determine whether a given number is prime. Unlike deterministic tests, Miller-Rabin provides a probability of correctness that increases with the number of iterations.

Given a positive integer n and a number of iterations k, implement the Miller-Rabin test that returns true if n is likely prime, and false if n is definitely composite.

Algorithm Overview:

1. Handle special cases: numbers ≤ 1 are not prime, 2 and 3 are prime

2. Write n-1 = 2^r × d where d is odd

3. For k iterations, pick random witness a in range [2, n-2]

4. Compute x = a^d mod n. If x = 1 or x = n-1, continue to next iteration

5. Square x repeatedly r-1 times. If any result equals n-1, continue to next iteration

6. If no n-1 found in step 5, n is composite

7. If all iterations pass, n is probably prime

Input & Output

Example 1 — Small Prime Number

$ Input: n = 97, k = 3

› Output: true

💡 Note: 97 is prime. The Miller-Rabin test with 3 iterations will very likely return true, as random witnesses will not be able to prove 97 is composite.

Example 2 — Composite Number

$ Input: n = 15, k = 3

› Output: false

💡 Note: 15 = 3 × 5 is composite. Most random witnesses will detect this during the Miller-Rabin test and return false definitively.

Example 3 — Edge Case Small Numbers

$ Input: n = 2, k = 5

› Output: true

💡 Note: 2 is the smallest prime number. The algorithm handles this as a special case and returns true immediately.

Constraints

1 ≤ n ≤ 10¹⁸
1 ≤ k ≤ 20
For practical purposes, k ≥ 3 recommended

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8 F Meta 6

The Miller-Rabin primality test is a probabilistic algorithm that efficiently determines if a number is likely prime. The key insight is writing n-1 = 2^r × d and testing random witnesses. Best approach achieves O(k log³ n) time complexity with high accuracy.

Common Approaches

✓ Miller-Rabin Probabilistic Test

⏱️ Time: O(k log³ n) Space: O(1)

The proper Miller-Rabin algorithm that writes n-1 = 2^r × d and tests random witnesses. Each witness either proves n is composite or provides evidence n might be prime.

Trial Division Method

⏱️ Time: O(√n) Space: O(1)

Test if n has any divisors from 2 to √n. This is deterministic but very slow for large numbers. Not actually Miller-Rabin, but the naive approach to primality testing.

Miller-Rabin Probabilistic Test — Algorithm Steps

Handle special cases (n ≤ 3, even numbers)
Write n-1 = 2^r × d where d is odd
For k iterations, pick random witness a ∈ [2, n-2]
Compute x = a^d mod n, check if x = 1 or x = n-1
Square x repeatedly r-1 times, check for n-1
If witness fails all tests, n is composite

Visualization

Tap to expand

Step-by-Step Walkthrough

Decompose

Write n-1 = 2^r × d

Random Witness

Pick random a, compute a^d mod n

Square Test

Square repeatedly, check for n-1

Verdict

All witnesses pass → probably prime

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) {
            result = ((__int128)result * base) % mod;
        }
        base = ((__int128)base * base) % mod;
        exp >>= 1;
    }
    return result;
}

bool solution(long long n, int k) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0) return false;
    
    // Write n-1 = 2^r * d
    int r = 0;
    long long d = n - 1;
    while (d % 2 == 0) {
        d /= 2;
        r++;
    }
    
    srand(time(NULL));
    
    // Perform k rounds of testing
    for (int i = 0; i < k; i++) {
        long long a = 2 + rand() % (n - 4);
        long long x = modPow(a, d, n);
        
        if (x == 1 || x == n - 1) {
            continue;
        }
        
        bool composite = true;
        for (int j = 0; j < r - 1; j++) {
            x = modPow(x, 2, n);
            if (x == n - 1) {
                composite = false;
                break;
            }
        }
        
        if (composite) return false;
    }
    
    return true;
}

int main() {
    long long n;
    int k;
    scanf("%lld", &n);
    scanf("%d", &k);
    
    bool result = solution(n, k);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k log³ n)

k iterations, each doing modular exponentiation in O(log³ n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for calculations

✓ Linear Space

5.7K Views

Medium Frequency

~35 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Miller-Rabin Primality Test - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Miller-Rabin Probabilistic Test — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler