Open In App

# Find winner of game where in each move division of N or subtraction is done

Jon and Arya are playing a game. The rules of the game are as follows:

• They have a single number N initially.
• Both will play an alternate move. Jon starts first.
• Both will play each move optimally.
• In each move, they can perform only one of these operations:
• Divide that number by 2, 3, 4, or 5 and take the floor of the result.
• Subtract that number by 2, 3, 4, or 5.
• If after making a move the number becomes 1, the player who made the move automatically loses the game.
• When the number becomes zero, the game will stop and the player who can’t make a move loses the game.

Find the winner of the game.

Examples:

Input: N = 3
Output: Jon
Explanation: Jon will just subtract 3 from initial
number and win the game.

Input: N = 6
Output: Arya
Explanation: If  Jon subtracts any number or divides N, on the next move Arya can subtract any number and make N as 0.

Approach: The problem can be solved using dynamic programming based on the following idea:

As Jon is starting the game, he will try to maximize his chances of winning. So, for any value of i, check if there is any possible value less than i (say j) that ensures Jon’s win, i.e., if j was the initial then the one who starts the game would lose. Then on the first move Jon can move from N to j and ensure his win.

Follow the below steps to solve this problem:

• If N = 1 return “Arya”.
• If N ? 5 return “Jon”.
• Make a dp[] array of size N + 1
• Set arr = 0 and i = 1.
• Make arr[i] to min(arr, arr[N]) to 1.
• Set i = 6.
• While i ? N, whosever turn will it be, check if there is any move by performing which he can win, which means if any arr[condition] = 0 then he will win for sure else not.
• If, arr[i / 2], arr[i / 4], arr[i / 3] or arr[i / 5] is 0,
• Set, arr[i] = 1.
• Else If, arr[i – 2], arr[i – 3], arr[i – 4] or arr[i – 5] is 0,
• Set, arr[i] = 1.
• Else,
• Set, arr[i] = 0.
• Increment i by 1 after every iteration.
• If arr[N] = 1 then return “Jon”.
• Else return “Arya”.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to return who will win``string divAndSub(``int` `N)``{``    ``// Edge Case``    ``if` `(N == 1)``        ``return` `"Arya"``;` `    ``if` `(N < 6)``        ``return` `"Jon"``;` `    ``// Make a dp array of size N+1``    ``int` `arr[N + 1];``    ``arr = 0;` `    ``// Initialize the variable``    ``int` `i = 1;` `    ``// If it's whose turn it is to win on``    ``// that move, we'll do 1, otherwise 0` `    ``// For 1-5 Jon always win``    ``while` `(i < 6 && i <= N) {``        ``arr[i] = 1;` `        ``i++;``    ``}` `    ``i = 6;` `    ``while` `(i <= N) {` `        ``// Whosever turn will it be we will``        ``// check if there is any move by``        ``// performing, there is a chance for``        ``// him to win, means if any``        ``// arr[condition] = 0 then he will win``        ``// for sure else not``        ``if` `(arr[i / 2] == 0 || arr[i / 4] == 0``            ``|| arr[i / 3] == 0 || arr[i / 5] == 0) {` `            ``// Means the person doing the move``            ``// can win through division``            ``arr[i] = 1;``        ``}` `        ``else` `if` `(arr[i - 2] == 0 || arr[i - 3] == 0``                 ``|| arr[i - 4] == 0 || arr[i - 5] == 0) {` `            ``// Means the person doing the move``            ``// can win through subtraction``            ``arr[i] = 1;``        ``}` `        ``else` `{` `            ``// Else other person will win``            ``arr[i] = 0;``        ``}` `        ``i++;``    ``}` `    ``// If arr[N] is 1 then Jon win``    ``// else Arya win``    ``return` `arr[N] == 1 ? ``"Jon"` `: ``"Arya"``;``}` `// Driver Code``int` `main()``{``    ``int` `N = 3;` `    ``// Function Call``    ``cout << divAndSub(N) << endl;` `    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;` `class` `GFG {` `  ``// Function to return who will win``  ``public` `static` `String divAndSub(``int` `N)``  ``{``    ``// Edge Case``    ``if` `(N == ``1``)``      ``return` `"Arya"``;` `    ``if` `(N < ``6``)``      ``return` `"Jon"``;` `    ``// Make a dp array of size N+1``    ``int``[] arr= ``new` `int``[N + ``1``];``    ``arr[``0``] = ``0``;` `    ``// Initialize the variable``    ``int` `i = ``1``;` `    ``// If it's whose turn it is to win on``    ``// that move, we'll do 1, otherwise 0` `    ``// For 1-5 Jon always win``    ``while` `(i < ``6` `&& i <= N) {``      ``arr[i] = ``1``;` `      ``i++;``    ``}` `    ``i = ``6``;` `    ``while` `(i <= N) {` `      ``// Whosever turn will it be we will``      ``// check if there is any move by``      ``// performing, there is a chance for``      ``// him to win, means if any``      ``// arr[condition] = 0 then he will win``      ``// for sure else not``      ``if` `(arr[i / ``2``] == ``0` `|| arr[i / ``4``] == ``0``          ``|| arr[i / ``3``] == ``0` `|| arr[i / ``5``] == ``0``) {` `        ``// Means the person doing the move``        ``// can win through division``        ``arr[i] = ``1``;``      ``}` `      ``else` `if` `(arr[i - ``2``] == ``0` `|| arr[i - ``3``] == ``0``               ``|| arr[i - ``4``] == ``0` `|| arr[i - ``5``] == ``0``) {` `        ``// Means the person doing the move``        ``// can win through subtraction``        ``arr[i] = ``1``;``      ``}` `      ``else` `{` `        ``// Else other person will win``        ``arr[i] = ``0``;``      ``}` `      ``i++;``    ``}` `    ``// If arr[N] is 1 then Jon win``    ``// else Arya win``    ``return` `arr[N] == ``1` `? ``"Jon"` `: ``"Arya"``;``  ``}``// Driver Code``public` `static` `void` `main (String[] args) {` `    ``int` `N = ``3``;` `    ``// Function Call``    ``System.out.println(divAndSub(N));``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python code to implement the approach` `# Function to return who will win``def` `divAndSub(N):``    ``if``(N ``=``=` `1``):``        ``return` `"Arya"``    ``if``(N < ``6``):``        ``return` `"Jon"` `    ``# make a dp array of size N+1``    ``arr ``=` `[``0``]``*``(N``+``1``)``    ` `    ``# Initialize the variable``    ``i ``=` `1` `    ``# If it's whose turn it is to win on that move, we'll do 1, otherwise 0` `    ``# for 1-5 Jon always win``    ``while``(i < ``6` `and` `i <``=` `N):``        ``arr[i] ``=` `1``        ``i ``+``=` `1` `    ``i ``=` `6``    ``while``(i <``=` `N):``        ``# Whosever turn will it be we will``        ``# check if there is any move by``        ``# performing, there is a chance for``        ``# him to win, means if any``        ``# arr[condition] = 0 then he will win``        ``# for sure else not``        ``if``(arr[i``/``/``2``] ``=``=` `0` `or` `arr[i``/``/``4``] ``=``=` `0` `or` `arr[i``/``/``3``] ``=``=` `0` `or` `arr[i``/``/``5``] ``=``=` `0``):``            ``# Means the person doing the move can win through division``            ``arr[i] ``=` `1``        ``elif``(arr[i``-``2``] ``=``=` `0` `or` `arr[i``-``3``] ``=``=` `0` `or` `arr[i``-``4``] ``=``=` `0` `or` `arr[i``-``5``] ``=``=` `0``):``            ``# Means the person doing the move can win through subtraction``            ``arr[i] ``=` `1``        ``else``:``            ``# Else other person will win``            ``arr[i] ``=` `0``        ``i ``+``=` `1` `    ``# If arr[N] is 1 then Jon win else Arya win``    ``return` `"Jon"` `if``(arr[N] ``=``=` `1``) ``else` `"Arya"` `N ``=` `3` `# Function call``print``(divAndSub(N))` `# This code is contributed by lokesh.`

## C#

 `// C# implementation``using` `System;` `public` `class` `GFG{` `  ``// Function to return who will win``  ``public` `static` `string` `divAndSub(``int` `N)``  ``{``    ``// Edge Case``    ``if` `(N == 1)``      ``return` `"Arya"``;` `    ``if` `(N < 6)``      ``return` `"Jon"``;` `    ``// Make a dp array of size N+1``    ``int``[] arr= ``new` `int``[N + 1];``    ``arr = 0;` `    ``// Initialize the variable``    ``int` `i = 1;` `    ``// If it's whose turn it is to win on``    ``// that move, we'll do 1, otherwise 0` `    ``// For 1-5 Jon always win``    ``while` `(i < 6 && i <= N) {``      ``arr[i] = 1;` `      ``i++;``    ``}` `    ``i = 6;` `    ``while` `(i <= N) {` `      ``// Whosever turn will it be we will``      ``// check if there is any move by``      ``// performing, there is a chance for``      ``// him to win, means if any``      ``// arr[condition] = 0 then he will win``      ``// for sure else not``      ``if` `(arr[i / 2] == 0 || arr[i / 4] == 0``          ``|| arr[i / 3] == 0 || arr[i / 5] == 0) {` `        ``// Means the person doing the move``        ``// can win through division``        ``arr[i] = 1;``      ``}` `      ``else` `if` `(arr[i - 2] == 0 || arr[i - 3] == 0``               ``|| arr[i - 4] == 0 || arr[i - 5] == 0) {` `        ``// Means the person doing the move``        ``// can win through subtraction``        ``arr[i] = 1;``      ``}` `      ``else` `{` `        ``// Else other person will win``        ``arr[i] = 0;``      ``}` `      ``i++;``    ``}` `    ``// If arr[N] is 1 then Jon win``    ``// else Arya win``    ``return` `arr[N] == 1 ? ``"Jon"` `: ``"Arya"``;``  ``}` `  ``static` `public` `void` `Main (){` `    ``int` `N = 3;` `    ``// Function Call``    ``Console.WriteLine(divAndSub(N));` `  ``}``}` `// This code is contributed by ksam24000`

## Javascript

 `// JavaScript code to implement the approach` `// Function to return who will win``const divAndSub = (N) => {``    ``// Edge Case``    ``if` `(N == 1)``        ``return` `"Arya"``;` `    ``if` `(N < 6)``        ``return` `"Jon"``;` `    ``// Make a dp array of size N+1``    ``let arr = ``new` `Array(N + 1).fill(0);``    ``arr = 0;` `    ``// Initialize the variable``    ``let i = 1;` `    ``// If it's whose turn it is to win on``    ``// that move, we'll do 1, otherwise 0` `    ``// For 1-5 Jon always win``    ``while` `(i < 6 && i <= N) {``        ``arr[i] = 1;` `        ``i++;``    ``}` `    ``i = 6;` `    ``while` `(i <= N) {` `        ``// Whosever turn will it be we will``        ``// check if there is any move by``        ``// performing, there is a chance for``        ``// him to win, means if any``        ``// arr[condition] = 0 then he will win``        ``// for sure else not``        ``if` `(arr[parseInt(i / 2)] == 0 || arr[parseInt(i / 4)] == 0``            ``|| arr[parseInt(i / 3)] == 0 || arr[parseInt(i / 5)] == 0) {` `            ``// Means the person doing the move``            ``// can win through division``            ``arr[i] = 1;``        ``}` `        ``else` `if` `(arr[i - 2] == 0 || arr[i - 3] == 0``            ``|| arr[i - 4] == 0 || arr[i - 5] == 0) {` `            ``// Means the person doing the move``            ``// can win through subtraction``            ``arr[i] = 1;``        ``}` `        ``else` `{` `            ``// Else other person will win``            ``arr[i] = 0;``        ``}` `        ``i++;``    ``}` `    ``// If arr[N] is 1 then Jon win``    ``// else Arya win``    ``return` `arr[N] == 1 ? ``"Jon"` `: ``"Arya"``;``}` `// Driver Code` `let N = 3;` `// Function Call``console.log(divAndSub(N));` `// This code is contributed by rakeshsahni`

Output

`Jon`

Time Complexity: O(N)
Auxiliary Space: O(N)

Related Articles: