# Euclid Euler Theorem

• Difficulty Level : Medium
• Last Updated : 16 Dec, 2022

According to Euclid Euler Theorem, a perfect number which is even, can be represented in the form where n is a prime number and is a Mersenne prime number. It is a product of a power of 2 with a Mersenne prime number. This theorem establishes a connection between a Mersenne prime and an even perfect number.

```Some Examples (Perfect Numbers) which satisfy Euclid Euler Theorem are:

6, 28, 496, 8128, 33550336, 8589869056, 137438691328

Explanations:
1) 6 is an even perfect number.
So, it can be written in the form
(22 - 1) * (2(2 - 1)) = 6
where n = 2 is a prime number and 2^n - 1 = 3 is a Mersenne prime number.

2) 28 is an even perfect number.
So, it can be written in the form
(23 - 1) * (2(3 - 1)) = 28
where n = 3 is a prime number and 2^n - 1 = 7 is a Mersenne prime number.

3) 496 is an even perfect number.
So, it can be written in the form
(25 - 1) * (2(5 - 1)) = 496
where n = 5 is a prime number and 2^n - 1 = 31 is a Mersenne prime number.```

Approach(Brute Force):
Take each prime number and form a Mersenne prime with it. Mersenne prime = where n is prime. Now form the number (2^n – 1)*(2^(n – 1)) and check if it is even and perfect. If the condition satisfies then it follows Euclid Euler Theorem.

## C++

 `// CPP code to verify Euclid Euler Theorem``#include ``using` `namespace` `std;` `#define show(x) cout << #x << " = " << x << "\n";` `bool` `isprime(``long` `long` `n)``{``    ``// check whether a number is prime or not``    ``for` `(``int` `i = 2; i * i <= n; i++)``        ``if` `(n % i == 0)``            ``return` `false``;``    ``return` `true``;``}` `bool` `isperfect(``long` `long` `n) ``// perfect numbers``{``    ``// check is n is perfect sum of divisors``    ``// except the number itself = number``    ``long` `long` `s = -n;``    ``for` `(``long` `long` `i = 1; i * i <= n; i++) {` `        ``// is i is a divisor of n``        ``if` `(n % i == 0) {``            ``long` `long` `factor1 = i, factor2 = n / i;``            ``s += factor1 + factor2;` `            ``// here i*i == n``            ``if` `(factor1 == factor2)``                ``s -= i;``        ``}``    ``}``    ``return` `(n == s);``}` `int` `main()``{``    ``// storing powers of 2 to access in O(1) time``    ``vector<``long` `long``> power2(61);``    ``for` `(``int` `i = 0; i <= 60; i++)``        ``power2[i] = 1LL << i;` `    ``// generation of first few numbers``    ``// satisfying Euclid Euler's theorem` `    ``cout << ``"Generating first few numbers "``            ``"satisfying Euclid Euler's theorem\n"``;``    ``for` `(``long` `long` `i = 2; i <= 25; i++) {``        ``long` `long` `no = (power2[i] - 1) * (power2[i - 1]);``        ``if` `(isperfect(no) and (no % 2 == 0))``            ``cout << ``"(2^"` `<< i << ``" - 1) * (2^("` `<< i``                 ``<< ``" - 1)) = "` `<< no << ``"\n"``;``    ``}``    ``return` `0;``}`

## Java

 `// Java code to verify Euclid Euler Theorem``class` `GFG``{``    ``static` `boolean` `isprime(``long` `n)``    ``{``        ``// check whether a number is prime or not``        ``for` `(``int` `i = ``2``; i * i <= n; i++)``        ``{``            ``if` `(n % i == ``0``)``            ``{``                ``return` `false``;``            ``}``        ``}``        ``return` `false``;``    ``}` `    ``static` `boolean` `isperfect(``long` `n) ``// perfect numbers``    ``{``        ``// check is n is perfect sum of divisors``        ``// except the number itself = number``        ``long` `s = -n;``        ``for` `(``long` `i = ``1``; i * i <= n; i++)``        ``{` `            ``// is i is a divisor of n``            ``if` `(n % i == ``0``)``            ``{``                ``long` `factor1 = i, factor2 = n / i;``                ``s += factor1 + factor2;` `                ``// here i*i == n``                ``if` `(factor1 == factor2)``                ``{``                    ``s -= i;``                ``}``            ``}``        ``}``        ``return` `(n == s);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// storing powers of 2 to access in O(1) time``        ``long` `power2[] = ``new` `long``[``61``];``        ``for` `(``int` `i = ``0``; i <= ``60``; i++)``        ``{``            ``power2[i] = 1L << i;``        ``}` `        ``// generation of first few numbers``        ``// satisfying Euclid Euler's theorem``        ``System.out.print(``"Generating first few numbers "` `+``                         ``"satisfying Euclid Euler's theorem\n"``);``        ``for` `(``int` `i = ``2``; i <= ``25``; i++)``        ``{``            ``long` `no = (power2[i] - ``1``) * (power2[i - ``1``]);``            ``if` `(isperfect(no) && (no % ``2` `== ``0``))``            ``{``                ``System.out.print(``"(2^"` `+ i + ``" - 1) * (2^("` `+``                                 ``i + ``" - 1)) = "` `+ no + ``"\n"``);``            ``}``        ``}``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 code to verify Euclid Euler Theorem``#define show(x) cout << #x << " = " << x << "\n";``def` `isprime(n):``    ``i ``=` `2` `    ``# check whether a number is prime or not``    ``while``(i ``*` `i <``=` `n):``        ``if` `(n ``%` `i ``=``=` `0``):``            ``return` `False``;``        ``i ``+``=` `1``    ``return` `False``;` `def` `isperfect(n): ``# perfect numbers` `    ``# check is n is perfect sum of divisors``    ``# except the number itself = number``    ``s ``=` `-``n;``    ``i ``=``1``    ``while``(i ``*` `i <``=` `n):` `        ``# is i is a divisor of n``        ``if` `(n ``%` `i ``=``=` `0``):``            ``factor1 ``=` `i``            ``factor2 ``=` `n ``/``/` `i;``            ``s ``+``=` `factor1 ``+` `factor2;` `            ``# here i*i == n``            ``if` `(factor1 ``=``=` `factor2):``                ``s ``-``=` `i;   ``        ``i ``+``=` `1``    ``return` `(n ``=``=` `s);` `# Driver code``if` `__name__``=``=``'__main__'``:` `    ``# storing powers of 2 to access in O(1) time``    ``power2 ``=` `[``1``<

## C#

 `// C# code to verify Euclid Euler Theorem``using` `System;``using` `System.Collections.Generic;``    ` `class` `GFG``{``    ``static` `Boolean isprime(``long` `n)``    ``{``        ``// check whether a number is prime or not``        ``for` `(``int` `i = 2; i * i <= n; i++)``        ``{``            ``if` `(n % i == 0)``            ``{``                ``return` `false``;``            ``}``        ``}``        ``return` `false``;``    ``}` `    ``static` `Boolean isperfect(``long` `n) ``// perfect numbers``    ``{``        ``// check is n is perfect sum of divisors``        ``// except the number itself = number``        ``long` `s = -n;``        ``for` `(``long` `i = 1; i * i <= n; i++)``        ``{` `            ``// is i is a divisor of n``            ``if` `(n % i == 0)``            ``{``                ``long` `factor1 = i, factor2 = n / i;``                ``s += factor1 + factor2;` `                ``// here i*i == n``                ``if` `(factor1 == factor2)``                ``{``                    ``s -= i;``                ``}``            ``}``        ``}``        ``return` `(n == s);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// storing powers of 2 to access in O(1) time``        ``long` `[]power2 = ``new` `long``[61];``        ``for` `(``int` `i = 0; i <= 60; i++)``        ``{``            ``power2[i] = 1L << i;``        ``}` `        ``// generation of first few numbers``        ``// satisfying Euclid Euler's theorem``        ``Console.Write(``"Generating first few numbers "` `+``                      ``"satisfying Euclid Euler's theorem\n"``);``        ``for` `(``int` `i = 2; i <= 25; i++)``        ``{``            ``long` `no = (power2[i] - 1) * (power2[i - 1]);``            ``if` `(isperfect(no) && (no % 2 == 0))``            ``{``                ``Console.Write(``"(2^"` `+ i + ``" - 1) * (2^("` `+``                                ``i + ``" - 1)) = "` `+ no + ``"\n"``);``            ``}``        ``}``    ``}``}` `// This code is contributed by Rajput-Ji`

## PHP

 ``

## Javascript

 ``

Output:

```Generating first few numbers satisfying Euclid Euler's theorem
(2^2 - 1) * (2^(2 - 1)) = 6
(2^3 - 1) * (2^(3 - 1)) = 28
(2^5 - 1) * (2^(5 - 1)) = 496
(2^7 - 1) * (2^(7 - 1)) = 8128
(2^13 - 1) * (2^(13 - 1)) = 33550336
(2^17 - 1) * (2^(17 - 1)) = 8589869056
(2^19 - 1) * (2^(19 - 1)) = 137438691328```

Time Complexity: O(sqrt(n))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up