# Largest odd divisor Game to check which player wins

Two players are playing a game starting with a number n. In each turn, a player can make any one of the subsequent moves:

• Divide n by any of its odd divisors greater than 1. Divisors of a number include the number itself.
• Subtract 1 from n if n > k where k < n.

Player 1 makes the primary move, print “yes” if player 1 wins otherwise print “no” if both play optimally. The player who is unable to make a move loses the game.
Examples:

Input: n = 12, k = 1
Output: Yes
Explanation:
Player 1 first move = 12 / 3 = 4
Player 2 first move = 4 – 1 = 3
Player 1 second move = 3 / 3 = 1
Player 2 second move can be done and hence he looses.
Input: n = 1, k = 1
Output: No
Explanation:
Player 1 first move is not possible because n = k and hence player 1 looses.

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

Approach: The idea is to analyze the problem for the following 3 cases:

• When integer n is odd, player 1 can divide n by itself, since it is odd and hence n / n = 1, and player 2 loses. Note that here n = 1 is an exception.
• When integer n is even and has no odd divisors greater than 1 then n is of the form 2x. Player 1 is bound to subtract it by 1 making n odd. So if x > 1, player 2 wins. Note that for x = 1, n – 1 is equal to 1, so Player 1 wins.
• When integer n is even and has odd divisors, the task remains to check if n is divisible by 4 then player 1 can divide n by its largest odd factor after which n becomes of the form 2x where x > 1, so again player 1 wins.
• Otherwise, n must be of form 2 * p, where p is odd. If p is prime, player 1 loses since he can either reduce n by 1 or divide it by p both of which would be losing for him. If p is not prime then p must be of the form p1 * p2 where p1 is prime and p2 is any odd number > 1, for which player 1 can win by dividing n by p2.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ` `// Largest Odd Divisor Game to ` `// check which player wins ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the ` `// Largest Odd Divisor Game to ` `// check which player wins ` `void` `findWinner(``int` `n, ``int` `k) ` `{ ` `    ``int` `cnt = 0; ` ` `  `    ``// Check if n == 1 then ` `    ``// player 2 will win ` `    ``if` `(n == 1) ` `        ``cout << ``"No"` `<< endl; ` ` `  `    ``// Check if n == 2 or n is odd ` `    ``else` `if` `((n & 1) or n == 2) ` `        ``cout << ``"Yes"` `<< endl; ` ` `  `    ``else` `{ ` `        ``int` `tmp = n; ` `        ``int` `val = 1; ` ` `  `        ``// While n is greater than k and ` `        ``// divisible by 2 keep ` `        ``// incrementing tha val ` `        ``while` `(tmp > k and tmp % 2 == 0) { ` `            ``tmp /= 2; ` `            ``val *= 2; ` `        ``} ` ` `  `        ``// Loop to find greatest ` `        ``// odd divisor ` `        ``for` `(``int` `i = 3; i <= ``sqrt``(tmp); i++) { ` `            ``while` `(tmp % i == 0) { ` `                ``cnt++; ` `                ``tmp /= i; ` `            ``} ` `        ``} ` `        ``if` `(tmp > 1) ` `            ``cnt++; ` ` `  `        ``// Check if n is a power of 2 ` `        ``if` `(val == n) ` `            ``cout << ``"No"` `<< endl; ` ` `  `        ``else` `if` `(n / tmp == 2 and cnt == 1) ` `            ``cout << ``"No"` `<< endl; ` ` `  `        ``// Check if cnt is not one ` `        ``// then player 1 wins ` `        ``else` `            ``cout << ``"Yes"` `<< endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``long` `long` `n = 1, k = 1; ` `    ``findWinner(n, k); ` `    ``return` `0; ` `}`

## Java

 `// Java implementation to find the ` `// Largest Odd Divisior Game to ` `// check which player wins ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `     `  `// Function to find the ` `// Largest Odd Divisior Game to ` `// check which player wins ` `public` `static` `void` `findWinner(``int` `n, ``int` `k) ` `{ ` `    ``int` `cnt = ``0``; ` ` `  `    ``// Check if n == 1 then ` `    ``// player 2 will win ` `    ``if` `(n == ``1``) ` `        ``System.out.println(``"No"``); ` `     `  `    ``// Check if n == 2 or n is odd ` `    ``else` `if` `((n & ``1``) != ``0` `|| n == ``2``) ` `        ``System.out.println(``"Yes"``); ` ` `  `    ``else` `    ``{ ` `        ``int` `tmp = n; ` `        ``int` `val = ``1``; ` ` `  `        ``// While n is greater than k and ` `        ``// divisible by 2 keep ` `        ``// incrementing tha val ` `        ``while` `(tmp > k && tmp % ``2` `== ``0``) ` `        ``{ ` `            ``tmp /= ``2``; ` `            ``val *= ``2``; ` `        ``} ` ` `  `        ``// Loop to find greatest ` `        ``// odd divisor ` `        ``for``(``int` `i = ``3``;  ` `                ``i <= Math.sqrt(tmp); i++) ` `        ``{ ` `           ``while` `(tmp % i == ``0``) ` `           ``{ ` `               ``cnt++; ` `               ``tmp /= i; ` `           ``} ` `        ``} ` `        ``if` `(tmp > ``1``) ` `            ``cnt++; ` ` `  `        ``// Check if n is a power of 2 ` `        ``if` `(val == n) ` `            ``System.out.println(``"No"``); ` ` `  `        ``else` `if` `(n / tmp == ``2` `&& cnt == ``1``) ` `            ``System.out.println(``"No"``); ` ` `  `        ``// Check if cnt is not one ` `        ``// then player 1 wins ` `        ``else` `            ``System.out.println(``"Yes"``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``1``, k = ``1``; ` `     `  `    ``findWinner(n, k); ` `} ` `} ` ` `  `// This code is contributed by jrishabh99  `

## Python3

 `# Python3 implementation to find   ` `# the Largest Odd Divisor Game  ` `# to check which player wins  ` `import` `math   ` ` `  `# Function to find the Largest  ` `# Odd Divisor Game to check ` `# which player wins  ` `def` `findWinner(n, k):  ` `     `  `    ``cnt ``=` `0``;  ` ` `  `    ``# Check if n == 1 then  ` `    ``# player 2 will win  ` `    ``if` `(n ``=``=` `1``): ` `        ``print``(``"No"``);  ` ` `  `    ``# Check if n == 2 or n is odd  ` `    ``elif` `((n & ``1``) ``or` `n ``=``=` `2``): ` `        ``print``(``"Yes"``);  ` ` `  `    ``else``: ` `        ``tmp ``=` `n;  ` `        ``val ``=` `1``;  ` ` `  `        ``# While n is greater than k and  ` `        ``# divisible by 2 keep  ` `        ``# incrementing tha val  ` `        ``while` `(tmp > k ``and` `tmp ``%` `2` `=``=` `0``):  ` `            ``tmp ``/``/``=` `2``;  ` `            ``val ``*``=` `2``;  ` `             `  `        ``# Loop to find greatest  ` `        ``# odd divisor  ` `        ``for` `i ``in` `range``(``3``, ``int``(math.sqrt(tmp)) ``+` `1``):  ` `            ``while` `(tmp ``%` `i ``=``=` `0``): ` `                ``cnt ``+``=` `1``;  ` `                ``tmp ``/``/``=` `i;  ` `         `  `        ``if` `(tmp > ``1``): ` `            ``cnt ``+``=` `1``;  ` ` `  `        ``# Check if n is a power of 2  ` `        ``if` `(val ``=``=` `n): ` `            ``print``(``"No"``);  ` ` `  `        ``elif` `(n ``/` `tmp ``=``=` `2` `and` `cnt ``=``=` `1``): ` `            ``print``(``"No"``);  ` ` `  `        ``# Check if cnt is not one  ` `        ``# then player 1 wins  ` `        ``else``: ` `            ``print``(``"Yes"``);  ` `             `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``n ``=` `1``; k ``=` `1``;  ` `     `  `    ``findWinner(n, k);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation to find the ` `// Largest Odd Divisior Game to ` `// check which player wins ` `using` `System; ` `  `  `class` `GFG{ ` `      `  `// Function to find the ` `// Largest Odd Divisior Game to ` `// check which player wins ` `public` `static` `void` `findWinner(``int` `n, ``int` `k) ` `{ ` `    ``int` `cnt = 0; ` `  `  `    ``// Check if n == 1 then ` `    ``// player 2 will win ` `    ``if` `(n == 1) ` `        ``Console.Write(``"No"``); ` `      `  `    ``// Check if n == 2 or n is odd ` `    ``else` `if` `((n & 1) != 0 || n == 2) ` `        ``Console.Write(``"Yes"``); ` `  `  `    ``else` `    ``{ ` `        ``int` `tmp = n; ` `        ``int` `val = 1; ` `  `  `        ``// While n is greater than k and ` `        ``// divisible by 2 keep ` `        ``// incrementing tha val ` `        ``while` `(tmp > k && tmp % 2 == 0) ` `        ``{ ` `            ``tmp /= 2; ` `            ``val *= 2; ` `        ``} ` `  `  `        ``// Loop to find greatest ` `        ``// odd divisor ` `        ``for``(``int` `i = 3;  ` `                ``i <= Math.Sqrt(tmp); i++) ` `        ``{ ` `           ``while` `(tmp % i == 0) ` `           ``{ ` `               ``cnt++; ` `               ``tmp /= i; ` `           ``} ` `        ``} ` `        ``if` `(tmp > 1) ` `            ``cnt++; ` `  `  `        ``// Check if n is a power of 2 ` `        ``if` `(val == n) ` `            ``Console.Write(``"No"``); ` `  `  `        ``else` `if` `(n / tmp == 2 && cnt == 1) ` `            ``Console.Write(``"No"``); ` `  `  `        ``// Check if cnt is not one ` `        ``// then player 1 wins ` `        ``else` `            ``Console.Write(``"Yes"``); ` `    ``} ` `} ` `  `  `// Driver code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int` `n = 1, k = 1; ` `      `  `    ``findWinner(n, k); ` `} ` `} ` `// This code is contributed by rutvik_56 `

Output:

```No
```

Time Complexity: O(sqrt(n))
Auxiliary Space: O(1) 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.