# Find a positive number M such that gcd(N^M, N&M) is maximum

• Last Updated : 16 Jun, 2022

Given a number N, the task is to find a positive number M such that gcd(N^M, N&M) is the maximum possible and M < N. The task is to print the maximum gcd thus obtained.
Examples:

```Input: N = 5
Output: 7
gcd(2^5, 2&5) = 7

Input: N = 15
Output: 5 ```

Approach: There are two cases that need to be solved to get the maximum gcd possible.

• If a minimum of one bit is not set in the number, then M will be a number whose bits are flipped at every position of N. And after that get the maximum gcd.
• If all bits are set, then the answer will the maximum factor of that number except the number itself.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement above approach` `#include ``using` `namespace` `std;` `// Recursive function to count``// the number of unset bits``int` `countBits(``int` `n)``{``    ``// Base case``    ``if` `(n == 0)``        ``return` `0;` `    ``// unset bit count``    ``else``        ``return` `!(n & 1) + countBits(n >> 1);``}` `// Function to return the max gcd``int` `maxGcd(``int` `n)``{` `    ``// If no unset bits``    ``if` `(countBits(n) == 0) {``        ``// Find the maximum factor``        ``for` `(``int` `i = 2; i * i <= n; i++) {``            ``// Highest factor``            ``if` `(n % i == 0) {``                ``return` `n / i;``            ``}``        ``}``    ``}``    ``else` `{` `        ``int` `val = 0;``        ``int` `power = 1;``        ``int` `dupn = n;` `        ``// Find the flipped bit number``        ``while` `(n) {``            ``// If bit is not set``            ``if` `(!(n & 1)) {``                ``val += power;``            ``}` `            ``// Next power of 2``            ``power = power * 2;` `            ``// Right shift the number``            ``n = n >> 1;``        ``}` `        ``// Return the answer``        ``return` `__gcd(val ^ dupn, val & dupn);``    ``}` `    ``// If a prime number``    ``return` `1;``}` `// Driver Code``int` `main()``{``    ``// First example``    ``int` `n = 5;``    ``cout << maxGcd(n) << endl;` `    ``// Second example``    ``n = 15;``    ``cout << maxGcd(n) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to implement above approach` `class` `GFG``{` `static` `int` `__gcd(``int` `a,``int` `b)``{``    ``if``(b == ``0``)``    ``return` `a;``    ``return` `__gcd(b, a % b);``}` `// Recursive function to count``// the number of unset bits``static` `int` `countBits(``int` `n)``{``    ``// Base case``    ``if` `(n == ``0``)``        ``return` `0``;` `    ``// unset bit count``    ``else``        ``return` `((n & ``1``) == ``0` `? ``1` `: ``0``) + countBits(n >> ``1``);``}` `// Function to return the max gcd``static` `int` `maxGcd(``int` `n)``{` `    ``// If no unset bits``    ``if` `(countBits(n) == ``0``)``    ``{``        ``// Find the maximum factor``        ``for` `(``int` `i = ``2``; i * i <= n; i++)``        ``{``            ``// Highest factor``            ``if` `(n % i == ``0``)``            ``{``                ``return` `n / i;``            ``}``        ``}``    ``}``    ``else``    ``{` `        ``int` `val = ``0``;``        ``int` `power = ``1``;``        ``int` `dupn = n;` `        ``// Find the flipped bit number``        ``while` `(n > ``0``)``        ``{``            ``// If bit is not set``            ``if` `((n & ``1``) == ``0``)``            ``{``                ``val += power;``            ``}` `            ``// Next power of 2``            ``power = power * ``2``;` `            ``// Right shift the number``            ``n = n >> ``1``;``        ``}` `        ``// Return the answer``        ``return` `__gcd(val ^ dupn, val & dupn);``    ``}` `    ``// If a prime number``    ``return` `1``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// First example``    ``int` `n = ``5``;``    ``System.out.println(maxGcd(n));` `    ``// Second example``    ``n = ``15``;``    ``System.out.println(maxGcd(n));``}``}` `// This code contributed by Rajput-Ji`

## Python3

 `# Python 3 program to implement``# above approach``from` `math ``import` `gcd, sqrt` `# Recursive function to count``# the number of unset bits``def` `countBits(n):``    ` `    ``# Base case``    ``if` `(n ``=``=` `0``):``        ``return` `0` `    ``# unset bit count``    ``else``:``        ``return` `(((n & ``1``) ``=``=` `0``) ``+``                  ``countBits(n >> ``1``))` `# Function to return the max gcd``def` `maxGcd(n):``    ` `    ``# If no unset bits``    ``if` `(countBits(n) ``=``=` `0``):``        ` `        ``# Find the maximum factor``        ``for` `i ``in` `range``(``2``, ``int``(sqrt(n)) ``+` `1``):``            ` `            ``# Highest factor``            ``if` `(n ``%` `i ``=``=` `0``):``                ``return` `int``(n ``/` `i)``        ` `    ``else``:``        ``val ``=` `0``        ``power ``=` `1``        ``dupn ``=` `n` `        ``# Find the flipped bit number``        ``while` `(n):``            ` `            ``# If bit is not set``            ``if` `((n & ``1``) ``=``=` `0``):``                ``val ``+``=` `power` `            ``# Next power of 2``            ``power ``=` `power ``*` `2` `            ``# Right shift the number``            ``n ``=` `n >> ``1``        ` `        ``# Return the answer``        ``return` `gcd(val ^ dupn, val & dupn)` `    ``# If a prime number``    ``return` `1` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# First example``    ``n ``=` `5``    ``print``(maxGcd(n))` `    ``# Second example``    ``n ``=` `15``    ``print``(maxGcd(n))` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# program to implement above approach``using` `System;``class` `GFG``{` `static` `int` `__gcd(``int` `a,``int` `b)``{``    ``if``(b == 0)``    ``return` `a;``    ``return` `__gcd(b, a % b);``}``// Recursive function to count``// the number of unset bits``static` `int` `countBits(``int` `n)``{``    ``// Base case``    ``if` `(n == 0)``        ``return` `0;` `    ``// unset bit count``    ``else``        ``return` `((n & 1) == 0 ? 1 : 0) + countBits(n >> 1);``}` `// Function to return the max gcd``static` `int` `maxGcd(``int` `n)``{` `    ``// If no unset bits``    ``if` `(countBits(n) == 0)``    ``{``        ``// Find the maximum factor``        ``for` `(``int` `i = 2; i * i <= n; i++)``        ``{``            ``// Highest factor``            ``if` `(n % i == 0)``            ``{``                ``return` `n / i;``            ``}``        ``}``    ``}``    ``else``    ``{` `        ``int` `val = 0;``        ``int` `power = 1;``        ``int` `dupn = n;` `        ``// Find the flipped bit number``        ``while` `(n > 0)``        ``{``            ``// If bit is not set``            ``if` `((n & 1) == 0)``            ``{``                ``val += power;``            ``}` `            ``// Next power of 2``            ``power = power * 2;` `            ``// Right shift the number``            ``n = n >> 1;``        ``}` `        ``// Return the answer``        ``return` `__gcd(val ^ dupn, val & dupn);``    ``}` `    ``// If a prime number``    ``return` `1;``}` `// Driver Code``static` `void` `Main()``{``    ``// First example``    ``int` `n = 5;``    ``Console.WriteLine(maxGcd(n));` `    ``// Second example``    ``n = 15;``    ``Console.WriteLine(maxGcd(n));``}``}` `// This code is contributed by mits`

## PHP

 `> 1);``}` `// Recursive function to return``// gcd of a and b``function` `gcd(``\$a``, ``\$b``)``{` `    ``// Everything divides 0``    ``if` `(``\$a` `== 0)``        ``return` `\$b``;``    ``if` `(``\$b` `== 0)``        ``return` `\$a``;` `    ``// base case``    ``if``(``\$a` `== ``\$b``)``        ``return` `\$a` `;``    ` `    ``// a is greater``    ``if``(``\$a` `> ``\$b``)``        ``return` `gcd(``\$a` `- ``\$b` `, ``\$b` `);` `    ``return` `gcd(``\$a` `, ``\$b` `- ``\$a` `);``}` `// Function to return the max gcd``function` `maxGcd(``\$n``)``{` `    ``// If no unset bits``    ``if` `(countBits(``\$n``) == 0)``    ``{``        ` `        ``// Find the maximum factor``        ``for` `(``\$i` `= 2; ``\$i` `* ``\$i` `<= ``\$n``; ``\$i``++)``        ``{``            ` `            ``// Highest factor``            ``if` `(``\$n` `% ``\$i` `== 0)``            ``{``                ``return` `floor``(``\$n` `/ ``\$i``);``            ``}``        ``}``    ``}``    ``else``    ``{``        ``\$val` `= 0;``        ``\$power` `= 1;``        ``\$dupn` `= ``\$n``;` `        ``// Find the flipped bit number``        ``while` `(``\$n``)``        ``{``            ` `            ``// If bit is not set``            ``if` `(!(``\$n` `& 1))``            ``{``                ``\$val` `+= ``\$power``;``            ``}` `            ``// Next power of 2``            ``\$power` `= ``\$power` `* 2;` `            ``// Right shift the number``            ``\$n` `= ``\$n` `>> 1;``        ``}` `        ``// Return the answer``        ``return` `gcd(``\$val` `^ ``\$dupn``, ``\$val` `& ``\$dupn``);``    ``}` `    ``// If a prime number``    ``return` `1;``}` `// Driver Code` `// First example``\$n` `= 5;``echo` `maxGcd(``\$n``), ``"\n"``;` `// Second example``\$n` `= 15;``echo` `maxGcd(``\$n``), ``"\n"``;` `// This code is contributed by Ryuga``?>`

## Javascript

 ``

Output:

```7
5```

Time Complexity: O(sqrt(N) + logN), as we are using a loop to traverse sqrt(N) times, as the condition is i*i<=N, which is equivalent to i<=sqrt(N).

Auxiliary Space: O(logN), due to recursive stack space.

My Personal Notes arrow_drop_up