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] = 0 and i = 1.
• Make arr[i] to min(arr[5], 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 <bits/stdc++.h>
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] = 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] = 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] = 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)