Skip to content
Related Articles
Nearest prime less than given number n
• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

You are given a number n ( 3 <= n < 10^6 ) and you have to find nearest prime less than n?

Examples:

```Input : n = 10
Output: 7

Input : n = 17
Output: 13

Input : n = 30
Output: 29 ```

A simple solution for this problem is to iterate from n-1 to 2, and for every number, check if it is a prime. If prime, then return it and break the loop. This solution looks fine if there is only one query. But not efficient if there are multiple queries for different values of n.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to return nearest prime number``int` `prime(``int` `n)``{` `    ``// All prime numbers are odd except two``    ``if` `(n & 1)``        ``n -= 2;``    ``else``        ``n--;` `    ``int` `i, j;``    ``for` `(i = n; i >= 2; i -= 2) {``        ``if` `(i % 2 == 0)``            ``continue``;``        ``for` `(j = 3; j <= ``sqrt``(i); j += 2) {``            ``if` `(i % j == 0)``                ``break``;``        ``}``        ``if` `(j > ``sqrt``(i))``            ``return` `i;``    ``}` `    ``// It will only be executed when n is 3``    ``return` `2;``}` `// Driver Code``int` `main()``{``    ``int` `n = 17;``    ``cout << prime(n);``    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to return nearest prime number``    ``static` `int` `prime(``int` `n)``    ``{` `        ``// All prime numbers are odd except two``        ``if` `(n % ``2` `!= ``0``)``            ``n -= ``2``;``        ``else``            ``n--;` `        ``int` `i, j;``        ``for` `(i = n; i >= ``2``; i -= ``2``) {``            ``if` `(i % ``2` `== ``0``)``                ``continue``;``            ``for` `(j = ``3``; j <= Math.sqrt(i); j += ``2``) {``                ``if` `(i % j == ``0``)``                    ``break``;``            ``}``            ``if` `(j > Math.sqrt(i))``                ``return` `i;``        ``}` `        ``// It will only be executed when n is 3``        ``return` `2``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``17``;``        ``System.out.print(prime(n));``    ``}``}` `// This code is contributed by subham348.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG``{` `    ``// Function to return nearest prime number``    ``static` `int` `prime(``int` `n)``    ``{` `        ``// All prime numbers are odd except two``        ``if` `(n % 2 != 0)``            ``n -= 2;``        ``else``            ``n--;` `        ``int` `i, j;``        ``for` `(i = n; i >= 2; i -= 2) {``            ``if` `(i % 2 == 0)``                ``continue``;``            ``for` `(j = 3; j <= Math.Sqrt(i); j += 2) {``                ``if` `(i % j == 0)``                    ``break``;``            ``}``            ``if` `(j > Math.Sqrt(i))``                ``return` `i;``        ``}` `        ``// It will only be executed when n is 3``        ``return` `2;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 17;``        ``Console.Write(prime(n));``    ``}``}` `// This code is contributed by subham348.`

## Javascript

 ``
Output

`13`

An efficient solution for this problem is to generate all primes less tha 10^6 using Sieve of Sundaram and store then in a array in increasing order. Now apply modified binary search to search nearest prime less than n. Time complexity of this solution is O(n log n + log n) = O(n log n).

## C++

 `// C++ program to find the nearest prime to n.``#include``#define MAX 1000000``using` `namespace` `std;` `// array to store all primes less than 10^6``vector<``int``> primes;` `// Utility function of Sieve of Sundaram``void` `Sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram, produces primes``    ``// smaller than (2*x + 2) for a number given``    ``// number x``    ``int` `nNew = ``sqrt``(n);` `    ``// This array is used to separate numbers of the``    ``// form i+j+2ij from others where  1 <= i <= j``    ``int` `marked[n/2+500] = {0};` `    ``// eliminate indexes which does not produce primes``    ``for` `(``int` `i=1; i<=(nNew-1)/2; i++)``        ``for` `(``int` `j=(i*(i+1))<<1; j<=n/2; j=j+2*i+1)``            ``marked[j] = 1;` `    ``// Since 2 is a prime number``    ``primes.push_back(2);` `    ``// Remaining primes are of the form 2*i + 1 such``    ``// that marked[i] is false.``    ``for` `(``int` `i=1; i<=n/2; i++)``        ``if` `(marked[i] == 0)``            ``primes.push_back(2*i + 1);``}` `// modified binary search to find nearest prime less than N``int` `binarySearch(``int` `left,``int` `right,``int` `n)``{``    ``if` `(left<=right)``    ``{``        ``int` `mid = (left + right)/2;` `        ``// base condition is, if we are reaching at left``        ``// corner or right corner of primes[] array then``        ``// return that corner element because before or``        ``// after that we don't have any prime number in``        ``// primes array``        ``if` `(mid == 0 || mid == primes.size()-1)``            ``return` `primes[mid];` `        ``// now if n is itself a prime so it will be present``        ``// in primes array and here we have to find nearest``        ``// prime less than n so we will return primes[mid-1]``        ``if` `(primes[mid] == n)``            ``return` `primes[mid-1];` `        ``// now if primes[mid]n that``        ``// mean we reached at nearest prime``        ``if` `(primes[mid] < n && primes[mid+1] > n)``            ``return` `primes[mid];``        ``if` `(n < primes[mid])``            ``return` `binarySearch(left, mid-1, n);``        ``else``            ``return` `binarySearch(mid+1, right, n);``    ``}``    ``return` `0;``}` `// Driver program to run the case``int` `main()``{``    ``Sieve();``    ``int` `n = 17;``    ``cout << binarySearch(0, primes.size()-1, n);``    ``return` `0;``}`

## Java

 `// Java program to find the nearest prime to n.``import` `java.util.*;` `class` `GFG``{``    ` `static` `int` `MAX=``1000000``;` `// array to store all primes less than 10^6``static` `ArrayList primes = ``new` `ArrayList();` `// Utility function of Sieve of Sundaram``static` `void` `Sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram, produces primes``    ``// smaller than (2*x + 2) for a number given``    ``// number x``    ``int` `nNew = (``int``)Math.sqrt(n);` `    ``// This array is used to separate numbers of the``    ``// form i+j+2ij from others where 1 <= i <= j``    ``int``[] marked = ``new` `int``[n / ``2` `+ ``500``];` `    ``// eliminate indexes which does not produce primes``    ``for` `(``int` `i = ``1``; i <= (nNew - ``1``) / ``2``; i++)``        ``for` `(``int` `j = (i * (i + ``1``)) << ``1``;``                ``j <= n / ``2``; j = j + ``2` `* i + ``1``)``            ``marked[j] = ``1``;` `    ``// Since 2 is a prime number``    ``primes.add(``2``);` `    ``// Remaining primes are of the form 2*i + 1 such``    ``// that marked[i] is false.``    ``for` `(``int` `i = ``1``; i <= n / ``2``; i++)``        ``if` `(marked[i] == ``0``)``            ``primes.add(``2` `* i + ``1``);``}` `// modified binary search to find nearest prime less than N``static` `int` `binarySearch(``int` `left,``int` `right,``int` `n)``{``    ``if` `(left <= right)``    ``{``        ``int` `mid = (left + right) / ``2``;` `        ``// base condition is, if we are reaching at left``        ``// corner or right corner of primes[] array then``        ``// return that corner element because before or``        ``// after that we don't have any prime number in``        ``// primes array``        ``if` `(mid == ``0` `|| mid == primes.size() - ``1``)``            ``return` `primes.get(mid);` `        ``// now if n is itself a prime so it will be present``        ``// in primes array and here we have to find nearest``        ``// prime less than n so we will return primes[mid-1]``        ``if` `(primes.get(mid) == n)``            ``return` `primes.get(mid - ``1``);` `        ``// now if primes[mid]n that``        ``// mean we reached at nearest prime``        ``if` `(primes.get(mid) < n && primes.get(mid + ``1``) > n)``            ``return` `primes.get(mid);``        ``if` `(n < primes.get(mid))``            ``return` `binarySearch(left, mid - ``1``, n);``        ``else``            ``return` `binarySearch(mid + ``1``, right, n);``    ``}``    ``return` `0``;``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``Sieve();``    ``int` `n = ``17``;``    ``System.out.println(binarySearch(``0``,``                        ``primes.size() - ``1``, n));``}``}` `// This code is contributed by mits`

## Python3

 `# Python3 program to find the nearest``# prime to n.``import` `math``MAX` `=` `10000``;` `# array to store all primes less``# than 10^6``primes ``=` `[];` `# Utility function of Sieve of Sundaram``def` `Sieve():` `    ``n ``=` `MAX``;` `    ``# In general Sieve of Sundaram, produces``    ``# primes smaller than (2*x + 2) for a``    ``# number given number x``    ``nNew ``=` `int``(math.sqrt(n));` `    ``# This array is used to separate numbers``    ``# of the form i+j+2ij from others where``    ``# 1 <= i <= j``    ``marked ``=` `[``0``] ``*` `(``int``(n ``/` `2` `+` `500``));` `    ``# eliminate indexes which does not``    ``# produce primes``    ``for` `i ``in` `range``(``1``, ``int``((nNew ``-` `1``) ``/` `2``) ``+` `1``):``        ``for` `j ``in` `range``(((i ``*` `(i ``+` `1``)) << ``1``),``                        ``(``int``(n ``/` `2``) ``+` `1``), (``2` `*` `i ``+` `1``)):``            ``marked[j] ``=` `1``;` `    ``# Since 2 is a prime number``    ``primes.append(``2``);` `    ``# Remaining primes are of the form``    ``# 2*i + 1 such that marked[i] is false.``    ``for` `i ``in` `range``(``1``, ``int``(n ``/` `2``) ``+` `1``):``        ``if` `(marked[i] ``=``=` `0``):``            ``primes.append(``2` `*` `i ``+` `1``);` `# modified binary search to find nearest``# prime less than N``def` `binarySearch(left, right, n):``    ``if` `(left <``=` `right):``        ``mid ``=` `int``((left ``+` `right) ``/` `2``);` `        ``# base condition is, if we are reaching``        ``# at left corner or right corner of``        ``# primes[] array then return that corner``        ``# element because before or after that``        ``# we don't have any prime number in``        ``# primes array``        ``if` `(mid ``=``=` `0` `or` `mid ``=``=` `len``(primes) ``-` `1``):``            ``return` `primes[mid];` `        ``# now if n is itself a prime so it will``        ``# be present in primes array and here``        ``# we have to find nearest prime less than``        ``# n so we will return primes[mid-1]``        ``if` `(primes[mid] ``=``=` `n):``            ``return` `primes[mid ``-` `1``];` `        ``# now if primes[mid]n``        ``# that means we reached at nearest prime``        ``if` `(primes[mid] < n ``and` `primes[mid ``+` `1``] > n):``            ``return` `primes[mid];``        ``if` `(n < primes[mid]):``            ``return` `binarySearch(left, mid ``-` `1``, n);``        ``else``:``            ``return` `binarySearch(mid ``+` `1``, right, n);` `    ``return` `0``;` `# Driver Code``Sieve();``n ``=` `17``;``print``(binarySearch(``0``, ``len``(primes) ``-` `1``, n));``    ` `# This code is contributed by chandan_jnu`

## C#

 `// C# program to find the nearest prime to n.``using` `System;``using` `System.Collections;``class` `GFG``{``    ` `static` `int` `MAX = 1000000;` `// array to store all primes less than 10^6``static` `ArrayList primes = ``new` `ArrayList();` `// Utility function of Sieve of Sundaram``static` `void` `Sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram, produces``    ``// primes smaller than (2*x + 2) for a``    ``// number given number x``    ``int` `nNew = (``int``)Math.Sqrt(n);` `    ``// This array is used to separate numbers of the``    ``// form i+j+2ij from others where 1 <= i <= j``    ``int``[] marked = ``new` `int``[n / 2 + 500];` `    ``// eliminate indexes which does not produce primes``    ``for` `(``int` `i = 1; i <= (nNew - 1) / 2; i++)``        ``for` `(``int` `j = (i * (i + 1)) << 1;``                 ``j <= n / 2; j = j + 2 * i + 1)``            ``marked[j] = 1;` `    ``// Since 2 is a prime number``    ``primes.Add(2);` `    ``// Remaining primes are of the form 2*i + 1``    ``// such that marked[i] is false.``    ``for` `(``int` `i = 1; i <= n / 2; i++)``        ``if` `(marked[i] == 0)``            ``primes.Add(2 * i + 1);``}` `// modified binary search to find``// nearest prime less than N``static` `int` `binarySearch(``int` `left, ``int` `right, ``int` `n)``{``    ``if` `(left <= right)``    ``{``        ``int` `mid = (left + right) / 2;` `        ``// base condition is, if we are reaching at left``        ``// corner or right corner of primes[] array then``        ``// return that corner element because before or``        ``// after that we don't have any prime number in``        ``// primes array``        ``if` `(mid == 0 || mid == primes.Count - 1)``            ``return` `(``int``)primes[mid];` `        ``// now if n is itself a prime so it will be``        ``// present in primes array and here we have``        ``// to find nearest prime less than n so we``        ``// will return primes[mid-1]``        ``if` `((``int``)primes[mid] == n)``            ``return` `(``int``)primes[mid - 1];` `        ``// now if primes[mid]n``        ``// that mean we reached at nearest prime``        ``if` `((``int``)primes[mid] < n &&``            ``(``int``)primes[mid + 1] > n)``            ``return` `(``int``)primes[mid];``        ``if` `(n < (``int``)primes[mid])``            ``return` `binarySearch(left, mid - 1, n);``        ``else``            ``return` `binarySearch(mid + 1, right, n);``    ``}``    ``return` `0;``}` `// Driver code``static` `void` `Main()``{``    ``Sieve();``    ``int` `n = 17;``    ``Console.WriteLine(binarySearch(0,``                      ``primes.Count - 1, n));``}``}` `// This code is contributed by chandan_jnu`

## PHP

 `n``        ``// that means we reached at nearest prime``        ``if` `(``\$primes``[``\$mid``] < ``\$n` `&& ``\$primes``[``\$mid` `+ 1] > ``\$n``)``            ``return` `\$primes``[``\$mid``];``        ``if` `(``\$n` `< ``\$primes``[``\$mid``])``            ``return` `binarySearch(``\$left``, ``\$mid` `- 1, ``\$n``);``        ``else``            ``return` `binarySearch(``\$mid` `+ 1, ``\$right``, ``\$n``);``    ``}``    ``return` `0;``}` `// Driver Code``Sieve();``\$n` `= 17;``echo` `binarySearch(0, ``count``(``\$primes``) - 1, ``\$n``);``    ` `// This code is contributed by chandan_jnu``?>`

## Javascript

 ``
Output
`13`

If you have another approach to solve this problem then please share in comments.
This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up