# Lemoine’s Conjecture

Last Updated : 20 Sep, 2022

Any odd integer greater than 5 can be expressed as a sum of an odd prime (all primes other than 2 are odd) and an even semiprime. A semiprime number is a product of two prime numbers. This is called Lemoine’s conjecture
Examples :

7 = 3 + (2 Ã— 2),
where 3 is a prime number (other than 2) and 4 (= 2 Ã— 2) is a semiprime number.
11 = 5 + (2 Ã— 3)
where 5 is a prime number and 6(= 2 Ã— 3) is a semiprime number.
9 = 3 + (2 Ã— 3) or 9 = 5 + (2 Ã— 2)
47 = 13 + 2 Ã— 17 = 37 + 2 Ã— 5 = 41 + 2 Ã— 3 = 43 + 2 Ã— 2

Below is the implementation of Lemoine’s Conjecture:

## C++

 `// C++ code to verify Lemoine's Conjecture` `// for any odd number >= 7` `#include` `using` `namespace` `std;`   `// Function to check if a number is` `// prime or not` `bool` `isPrime(``int` `n)` `{` `    ``if` `(n < 2)` `        ``return` `false``;` `        `  `    ``for` `(``int` `i = 2; i <= ``sqrt``(n); i++) {` `        ``if` `(n % i == 0)` `            ``return` `false``;` `    ``}` `    ``return` `true``;` `}`   `// Representing n as p + (2 * q) to satisfy` `// lemoine's conjecture` `void` `lemoine(``int` `n)` `{` `    ``// Declaring a map to hold pairs (p, q)` `    ``map<``int``, ``int``> pr;` `    `  `    ``// Declaring an iterator for map` `    ``map<``int``, ``int``>::iterator it;` `    ``it = pr.begin();` `    `  `    ``// Finding various values of p for each q` `    ``// to satisfy n = p + (2 * q)` `    ``for` `(``int` `q = 1; q <= n / 2; q++) ` `    ``{ ` `        ``int` `p = n - 2 * q;` `        `  `        ``// After finding a pair that satisfies the` `        ``// equation, check if both p and q are` `        ``// prime or not` `        ``if` `(isPrime(p) && isPrime(q))` `        `  `            ``// If both p and q are prime, store` `            ``// them in the map` `            ``pr.insert(it, pair<``int``, ``int``>(p, q));` `    ``}` `    `  `    ``// Displaying all pairs (p, q) that satisfy` `    ``// lemoine's conjecture for the number 'n'` `    ``for` `(it = pr.begin(); it != pr.end(); ++it)` `        ``cout << n << ``" = "` `<< it->first` `             ``<< ``" + (2 * "` `<< it->second << ``")\n"``;` `}`   `// Driver Function` `int` `main()` `{` `    ``int` `n = 39;` `    ``cout << n << ``" can be expressed as "` `<< endl;` `    `  `    ``// Function calling` `    ``lemoine(n);` `    `  `    ``return` `0;` `}`   `// This code is contributed by Saagnik Adhikary`

## Java

 `// Java code to verify Lemoine's Conjecture` `// for any odd number >= 7`   `import` `java.util.*;`   `class` `GFG {` `    ``static` `class` `pair {` `        ``int` `first, second;`   `        ``public` `pair(``int` `first, ``int` `second) {` `            ``this``.first = first;` `            ``this``.second = second;` `        ``}` `    ``}`   `    ``// Function to check if a number is` `    ``// prime or not` `    ``static` `boolean` `isPrime(``int` `n) {` `        ``if` `(n < ``2``)` `            ``return` `false``;`   `        ``for` `(``int` `i = ``2``; i <= Math.sqrt(n); i++) {` `            ``if` `(n % i == ``0``)` `                ``return` `false``;` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Representing n as p + (2 * q) to satisfy` `    ``// lemoine's conjecture` `    ``static` `void` `lemoine(``int` `n) {` `        ``// Declaring a map to hold pairs (p, q)` `        ``HashMap pr = ``new` `HashMap<>();`   `        ``// Declaring an iterator for map` `        ``// HashMap::iterator it;` `        ``// it = pr.begin();` `        ``int` `i = ``0``;` `        ``// Finding various values of p for each q` `        ``// to satisfy n = p + (2 * q)` `        ``for` `(``int` `q = ``1``; q <= n / ``2``; q++) {` `            ``int` `p = n - ``2` `* q;`   `            ``// After finding a pair that satisfies the` `            ``// equation, check if both p and q are` `            ``// prime or not` `            ``if` `(isPrime(p) && isPrime(q))`   `                ``// If both p and q are prime, store` `                ``// them in the map` `                ``pr.put(i, ``new` `pair(p, q));` `            ``i++;` `        ``}`   `        ``// Displaying all pairs (p, q) that satisfy` `        ``// lemoine's conjecture for the number 'n'` `        ``for` `(Map.Entry it : pr.entrySet())` `            ``System.out.print(n + ``" = "` `+ it.getValue().first + ``" + (2 * "` `+ it.getValue().second + ``")\n"``);` `    ``}`   `    ``// Driver Function` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `n = ``39``;` `        ``System.out.print(n + ``" can be expressed as "` `+ ``"\n"``);`   `        ``// Function calling` `        ``lemoine(n);`   `    ``}` `}`   `// This code contributed by aashish1995`

## Python3

 `# Python code to verify Lemoine's Conjecture` `# for any odd number >= 7` `from` `math ``import` `sqrt`   `# Function to check if a number is` `# prime or not` `def` `isPrime(n: ``int``) ``-``> ``bool``:` `    ``if` `n < ``2``:` `        ``return` `False`   `    ``for` `i ``in` `range``(``2``, ``int``(sqrt(n)) ``+` `1``):` `        ``if` `n ``%` `i ``=``=` `0``:` `            ``return` `False`   `    ``return` `True`   `# Representing n as p + (2 * q) to satisfy` `# lemoine's conjecture` `def` `lemoine(n: ``int``) ``-``> ``None``:`   `    ``# Declaring a map to hold pairs (p, q)` `    ``pr ``=` `dict``()`   `    ``# Finding various values of p for each q` `    ``# to satisfy n = p + (2 * q)` `    ``for` `q ``in` `range``(``1``, n ``/``/` `2` `+` `1``):` `        ``p ``=` `n ``-` `2` `*` `q`   `        ``# After finding a pair that satisfies the` `        ``# equation, check if both p and q are` `        ``# prime or not` `        ``if` `isPrime(p) ``and` `isPrime(q):`   `            ``# If both p and q are prime, store` `            ``# them in the map` `            ``if` `p ``not` `in` `pr:` `                ``pr[p] ``=` `q`   `    ``# Displaying all pairs (p, q) that satisfy` `    ``# lemoine's conjecture for the number 'n'` `    ``for` `it ``in` `pr:` `        ``print``(``"%d = %d + (2 * %d)"` `%` `(n, it, pr[it]))`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``n ``=` `39` `    ``print``(n, ``"can be expressed as "``)`   `    ``# Function calling` `    ``lemoine(n)`   `# This code is contributed by` `# sanjeev2552`

## C#

 `// C# code to verify Lemoine's Conjecture` `// for any odd number >= 7` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{` `    ``public` `   ``class` `pair ` `   ``{` `         ``public` `           ``int` `first, second;`   `          ``public` `pair(``int` `first, ``int` `second) ` `          ``{` `              ``this``.first = first;` `              ``this``.second = second;` `          ``}` `      ``}`   `      ``// Function to check if a number is` `      ``// prime or not` `      ``static` `bool` `isPrime(``int` `n)` `      ``{` `          ``if` `(n < 2)` `              ``return` `false``;`   `          ``for` `(``int` `i = 2; i <= Math.Sqrt(n); i++)` `          ``{` `              ``if` `(n % i == 0)` `                  ``return` `false``;` `          ``}` `          ``return` `true``;` `      ``}`   `      ``// Representing n as p + (2 * q) to satisfy` `      ``// lemoine's conjecture` `      ``static` `void` `lemoine(``int` `n)` `      ``{`   `          ``// Declaring a map to hold pairs (p, q)` `          ``Dictionary<``int``, pair> pr = ``new` `Dictionary<``int``, pair>();`   `          ``// Declaring an iterator for map` `          ``// Dictionary::iterator it;` `          ``// it = pr.begin();` `          ``int` `i = 0;`   `          ``// Finding various values of p for each q` `          ``// to satisfy n = p + (2 * q)` `          ``for` `(``int` `q = 1; q <= n / 2; q++) ` `          ``{` `              ``int` `p = n - 2 * q;`   `              ``// After finding a pair that satisfies the` `              ``// equation, check if both p and q are` `              ``// prime or not` `              ``if` `(isPrime(p) && isPrime(q))`   `                  ``// If both p and q are prime, store` `                  ``// them in the map` `                  ``pr.Add(i, ``new` `pair(p, q));` `              ``i++;` `          ``}`   `          ``// Displaying all pairs (p, q) that satisfy` `          ``// lemoine's conjecture for the number 'n'` `          ``foreach` `(KeyValuePair<``int``, pair> it ``in` `pr)` `              ``Console.Write(n + ``" = "` `+ it.Value.first + ` `                            ``" + (2 * "` `+ it.Value.second + ``")\n"``);` `      ``}`   `      ``// Driver code` `      ``public` `static` `void` `Main(String[] args)` `      ``{` `          ``int` `n = 39;` `          ``Console.Write(n + ``" can be expressed as "` `+ ``"\n"``);`   `          ``// Function calling` `          ``lemoine(n);` `      ``}` `  ``}`   `  ``// This code is contributed by aashish1995 `

## Javascript

 ``

Output :

```39 can be expressed as :
39 = 5 + (2 * 17)
39 = 13 + (2 * 13)
39 = 17 + (2 * 11)
39 = 29 + (2 * 5)```

Time Complexity: O(n*(sqrt(n)+log(n)))
Auxiliary Space: O(n)

Previous
Next