# Queries for maximum difference between prime numbers in given ranges

Given n queries of the form range [L, R]. The task is to find the maximum difference between two prime numbers in the range for each query. If there are no prime in the range then print 0. All ranges are below 100005.

Examples:

```Input : Q = 3
query1 = [2, 5]
query2 = [2, 2]
query3 = [24, 28]
Output : 3
0
0
In first query, 2 and 5 are prime number
in the range with maximum difference which
is 3. In second and third queries, there
is only 1 prime number in range, so output
is 0.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to compute Prime numbers using Sieve of Eratosthenes along with some precomputing.
Below are the step to solve the question:
Step 1: Find the prime numbers using Sieve of Eratosthenes algorithm.
Step 2: Make an array, let say prefix[], where prefix[i] represents largest prime number smaller or equal to i.
Step 3: Make an array, let say suffix[], where suffix[i] represents smallest prime number greater or equal to i.
Step 4: Now for each query having [L, R], do the following:

```  if (prefix[R]  R)
return 0;
else
return prefix[R] - suffix[L];```

Below is the implementation of this approach:

## C++

 `// CPP program to find maximum differences between ` `// two prime numbers in given ranges ` `#include ` `using` `namespace` `std; ` `#define MAX 100005 ` ` `  `// Precompute Sieve, Prefix array, Suffix array ` `void` `precompute(``int` `prefix[], ``int` `suffix[]) ` `{ ` `    ``bool` `prime[MAX]; ` `    ``memset``(prime, ``true``, ``sizeof``(prime)); ` ` `  `    ``// Sieve of Eratosthenes ` `    ``for` `(``int` `i = 2; i * i < MAX; i++) { ` `        ``if` `(prime[i]) { ` `            ``for` `(``int` `j = i + i; j < MAX; j += i) ` `                ``prime[j] = ``false``; ` `        ``} ` `    ``} ` ` `  `    ``prefix[1] = 1; ` `    ``suffix[MAX - 1] = 1e9 + 7; ` ` `  `    ``// Precomputing Prefix array. ` `    ``for` `(``int` `i = 2; i < MAX; i++) { ` `        ``if` `(prime[i]) ` `            ``prefix[i] = i; ` `        ``else` `            ``prefix[i] = prefix[i - 1]; ` `    ``} ` ` `  `    ``// Precompute Suffix array. ` `    ``for` `(``int` `i = MAX - 1; i > 1; i--) { ` `        ``if` `(prime[i]) ` `            ``suffix[i] = i; ` `        ``else` `            ``suffix[i] = suffix[i + 1]; ` `    ``} ` `} ` ` `  `// Function to solve each query ` `int` `query(``int` `prefix[], ``int` `suffix[], ``int` `L,  ` `                                      ``int` `R) ` `{ ` `    ``if` `(prefix[R] < L || suffix[L] > R) ` `        ``return` `0; ` `    ``else` `        ``return` `prefix[R] - suffix[L]; ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `q = 3; ` `    ``int` `L[] = { 2, 2, 24 }; ` `    ``int` `R[] = { 5, 2, 28 }; ` ` `  `    ``int` `prefix[MAX], suffix[MAX]; ` `    ``precompute(prefix, suffix); ` ` `  `    ``for` `(``int` `i = 0; i < q; i++) ` `        ``cout << query(prefix, suffix, L[i], R[i]) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find maximum differences between  ` `// two prime numbers in given ranges  ` ` `  `public` `class` `GFG { ` ` `  `    ``final` `static` `int` `MAX = ``100005``; ` ` `  `// Precompute Sieve, Prefix array, Suffix array  ` `    ``static` `void` `precompute(``int` `prefix[], ``int` `suffix[]) { ` `        ``boolean` `prime[] = ``new` `boolean``[MAX]; ` `        ``for` `(``int` `i = ``0``; i < MAX; i++) { ` `            ``prime[i] = ``true``; ` `        ``} ` ` `  `        ``// Sieve of Eratosthenes  ` `        ``for` `(``int` `i = ``2``; i * i < MAX; i++) { ` `            ``if` `(prime[i]) { ` `                ``for` `(``int` `j = i + i; j < MAX; j += i) { ` `                    ``prime[j] = ``false``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``prefix[``1``] = ``1``; ` `        ``suffix[MAX - ``1``] = (``int``) 1e9 + ``7``; ` ` `  `        ``// Precomputing Prefix array.  ` `        ``for` `(``int` `i = ``2``; i < MAX; i++) { ` `            ``if` `(prime[i]) { ` `                ``prefix[i] = i; ` `            ``} ``else` `{ ` `                ``prefix[i] = prefix[i - ``1``]; ` `            ``} ` `        ``} ` ` `  `        ``// Precompute Suffix array.  ` `        ``for` `(``int` `i = MAX - ``2``; i > ``1``; i--) { ` `            ``if` `(prime[i]) { ` `                ``suffix[i] = i; ` `            ``} ``else` `{ ` `                ``suffix[i] = suffix[i + ``1``]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `// Function to solve each query  ` `    ``static` `int` `query(``int` `prefix[], ``int` `suffix[], ``int` `L, ` `            ``int` `R) { ` `        ``if` `(prefix[R] < L || suffix[L] > R) { ` `            ``return` `0``; ` `        ``} ``else` `{ ` `            ``return` `prefix[R] - suffix[L]; ` `        ``} ` `    ``} ` ` `  `// Driven Program  ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `q = ``3``; ` `        ``int` `L[] = {``2``, ``2``, ``24``}; ` `        ``int` `R[] = {``5``, ``2``, ``28``}; ` ` `  `        ``int` `prefix[] = ``new` `int``[MAX], suffix[] = ``new` `int``[MAX]; ` `        ``precompute(prefix, suffix); ` ` `  `        ``for` `(``int` `i = ``0``; i < q; i++) { ` `            ``System.out.println(query(prefix, suffix, L[i], R[i])); ` `        ``} ` ` `  `    ``} ` `} ` `/*This code is contributed by Rajput-Ji*/`

## Python3

 `# Python 3 program to find maximum  ` `# differences between two prime numbers  ` `# in given ranges ` `from` `math ``import` `sqrt ` ` `  `MAX` `=` `100005` ` `  `# Precompute Sieve, Prefix array, Suffix array ` `def` `precompute(prefix, suffix): ` `    ``prime ``=` `[``True` `for` `i ``in` `range``(``MAX``)] ` ` `  `    ``# Sieve of Eratosthenes ` `    ``k ``=` `int``(sqrt(``MAX``)) ` `    ``for` `i ``in` `range``(``2``, k, ``1``): ` `        ``if` `(prime[i]): ` `            ``for` `j ``in` `range``(i ``+` `i, ``MAX``, i): ` `                ``prime[j] ``=` `False` ` `  `    ``prefix[``1``] ``=` `1` `    ``suffix[``MAX` `-` `1``] ``=` `int``(``1e9` `+` `7``) ` ` `  `    ``# Precomputing Prefix array. ` `    ``for` `i ``in` `range``(``2``, ``MAX``, ``1``): ` `        ``if` `(prime[i]): ` `            ``prefix[i] ``=` `i ` `        ``else``: ` `            ``prefix[i] ``=` `prefix[i ``-` `1``] ` `     `  `    ``# Precompute Suffix array. ` `    ``i ``=` `MAX` `-` `2` `    ``while``(i > ``1``): ` `        ``if` `(prime[i]): ` `            ``suffix[i] ``=` `i ` `        ``else``: ` `            ``suffix[i] ``=` `suffix[i ``+` `1``] ` `        ``i ``-``=` `1` ` `  `# Function to solve each query ` `def` `query(prefix, suffix, L, R): ` `    ``if` `(prefix[R] < L ``or` `suffix[L] > R): ` `        ``return` `0` `    ``else``: ` `        ``return` `prefix[R] ``-` `suffix[L] ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``q ``=` `3` `    ``L ``=` `[``2``, ``2``, ``24``]  ` `    ``R ``=` `[``5``, ``2``, ``28``] ` ` `  `    ``prefix ``=` `[ ``0` `for` `i ``in` `range``(``MAX``)] ` `    ``suffix ``=` `[ ``0` `for` `i ``in` `range``(``MAX``)] ` `    ``precompute(prefix, suffix) ` ` `  `    ``for` `i ``in` `range``(``0``, q, ``1``): ` `        ``print``(query(prefix, suffix,  ` `                        ``L[i], R[i])) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# program to find maximum differences between  ` `// two prime numbers in given ranges ` `using` `System;  ` ` `  `public` `class` `GFG {  ` ` `  `    ``static` `readonly` `int` `MAX = 100005; ` `  `  `// Precompute Sieve, Prefix array, Suffix array  ` `    ``static` `void` `precompute(``int` `[]prefix, ``int` `[]suffix) { ` `        ``bool` `[]prime = ``new` `bool``[MAX]; ` `        ``for` `(``int` `i = 0; i < MAX; i++) { ` `            ``prime[i] = ``true``; ` `        ``} ` `  `  `        ``// Sieve of Eratosthenes  ` `        ``for` `(``int` `i = 2; i * i < MAX; i++) { ` `            ``if` `(prime[i]) { ` `                ``for` `(``int` `j = i + i; j < MAX; j += i) { ` `                    ``prime[j] = ``false``; ` `                ``} ` `            ``} ` `        ``} ` `  `  `        ``prefix[1] = 1; ` `        ``suffix[MAX - 1] = (``int``) 1e9 + 7; ` `  `  `        ``// Precomputing Prefix array.  ` `        ``for` `(``int` `i = 2; i < MAX; i++) { ` `            ``if` `(prime[i]) { ` `                ``prefix[i] = i; ` `            ``} ``else` `{ ` `                ``prefix[i] = prefix[i - 1]; ` `            ``} ` `        ``} ` `  `  `        ``// Precompute Suffix array.  ` `        ``for` `(``int` `i = MAX - 2; i > 1; i--) { ` `            ``if` `(prime[i]) { ` `                ``suffix[i] = i; ` `            ``} ``else` `{ ` `                ``suffix[i] = suffix[i + 1]; ` `            ``} ` `        ``} ` `    ``} ` `  `  `// Function to solve each query  ` `    ``static` `int` `query(``int` `[]prefix, ``int` `[]suffix, ``int` `L, ` `            ``int` `R) { ` `        ``if` `(prefix[R] < L || suffix[L] > R) { ` `            ``return` `0; ` `        ``} ``else` `{ ` `            ``return` `prefix[R] - suffix[L]; ` `        ``} ` `    ``} ` `  `  `// Driven Program  ` `    ``public` `static` `void` `Main() { ` `        ``int` `q = 3; ` `        ``int` `[]L = {2, 2, 24}; ` `        ``int` `[]R = {5, 2, 28}; ` `  `  `        ``int` `[]prefix = ``new` `int``[MAX]; ` `        ``int` `[]suffix = ``new` `int``[MAX]; ` `        ``precompute(prefix, suffix); ` `  `  `        ``for` `(``int` `i = 0; i < q; i++) { ` `            ``Console.WriteLine(query(prefix, suffix, L[i], R[i])); ` `        ``} ` `  `  `    ``} ` `} ` ` `  `/*This code is contributed by 29AjayKumar*/`

## PHP

 ` 1; ``\$i``--)  ` `    ``{ ` `        ``if` `(``\$prime``[``\$i``]) ` `            ``\$suffix``[``\$i``] = ``\$i``; ` `        ``else` `            ``\$suffix``[``\$i``] = ``\$suffix``[``\$i` `+ 1]; ` `    ``} ` `} ` ` `  `// Function to solve each query ` `function` `query(``\$prefix``, ``\$suffix``, ``\$L``, ``\$R``) ` `{ ` `    ``if` `(``\$prefix``[``\$R``] < ``\$L` `|| ``\$suffix``[``\$L``] > ``\$R``) ` `        ``return` `0; ` `    ``else` `        ``return` `\$prefix``[``\$R``] - ``\$suffix``[``\$L``]; ` `} ` ` `  `// Driver Code ` `\$q` `= 3; ` `\$L` `= ``array``( 2, 2, 24 ); ` `\$R` `= ``array``( 5, 2, 28 ); ` ` `  `\$prefix` `= ``array_fill``(0, ``\$MAX` `+ 1, 0); ` `\$suffix` `= ``array_fill``(0, ``\$MAX` `+ 1, 0); ` `precompute(``\$prefix``, ``\$suffix``); ` ` `  `for` `(``\$i` `= 0; ``\$i` `< ``\$q``; ``\$i``++) ` `    ``echo` `query(``\$prefix``, ``\$suffix``,  ` `               ``\$L``[``\$i``], ``\$R``[``\$i``]) . ``"\n"``; ` ` `  `// This code is contributed by mits ` `?> `

Output:

```3
0
0
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.