Find winner of game where simultaneous decrement and increment of two elements done in one move

• Last Updated : 28 Sep, 2022

Given an arr[] of positive integers of length N. Player X and Y plays a game where in each move one person chooses two elements of arr[] (say arr[i] and arr[j]) such that 0 â‰¤ i < j â‰¤ N – 1 and arri should be greater than 0 and Then decrement arri and increment arrj. When one player is unable to make such a move the player loses. The task is to find the winner of the game if Y starts the game.

Examples:

Input: N = 4, arr[] = {2, 3, 1, 3}
Output: Y
Explanation: initial arr[] is: {2, 3, 1, 3}
Player Y applied by selecting i = 0 and j = 1: {1, 4, 1, 3}
Player X applied by selecting i = 0 and j = 1: {0, 5, 1, 3}
Player Y applied by selecting i = 1 and j = 2: {0, 4, 2, 3}
Player X applied by selecting i = 1 and j = 2: {0, 3, 3, 3}
Player Y applied by selecting i = 1 and j = 2: {0, 2, 4, 3}
Player X applied by selecting i = 1 and j = 2: {0, 1, 5, 3}
Player Y applied by selecting i = 1 and j = 2: {0, 0, 6, 3}
Player X applied by selecting i = 2 and j = 3: {0, 0, 5, 4}
Player Y applied by selecting i = 2 and j = 3: {0, 0, 4, 5}
Player X applied by selecting i = 2 and j = 3: {0, 0, 3, 6}
Player Y applied by selecting i = 2 and j = 3: {0, 0, 2, 7}
Player X applied by selecting i = 2 and j = 3: {0, 0, 1, 8}
Player Y applied by selecting i = 2 and j = 3: {0, 0, 0, 9}
As there are no more indices i and j left in arr[],
Which follows 0<=i<j<N-1 and Ai > 0.
Therefore, player X can’t make its next operation.
Therefore, Player Y wins the game.

Input: N = 2, arr[] = {0, 1}
Output: X
Explanation: Player Y can’t make very first operation of the game, Therefore player X wins the game.

Approach: To solve the problem follow the below idea:

As we can see that it is clearly mentioned in the game that index i (0 â‰¤ i â‰¤ N – 1) should be greater than index j for applying operation, Thus by this observation, we can see that at any index i in input arr[] there are N – i – 1 possibles positions for subtracting one from ith index and add it to jth index. Thus the game reduced into sub-games and is similar like “Game of Nim”.

• In Game of Nim, Winner decides on the basis of Nim-Sum. If Nim-sum is not equal to zero then player who makes first move wins and if Nim-Sum is equal to zero then other player Wins.
• Same this problem is related to Combinatorial Game Theory and uses Sprague Grundy Theorem to solve the problem.
•  Game of Nim depends upon only Nim-sum and we have a XOR property as (A^A) = 0.If an element is even at index i, then it will give its part as even N-i in overall Nim-sum else odd N-i in overall Nim-sum.

According to above three lines, we can conclude that to get the answer calculate XOR of N-i-1 with the ith element, where ith element is odd in arr[].

if Nim-Sum comes zero then player X wins else player Y wins.

Follow the steps to solve the problem:

• Create any long type variable let’s say Z and initialize it to 0.
• Iterate on arr[] from left to right, if an element is found odd, Then update  Z as Z âŠ• (N – i – 1).
• After completing iteration if Z = 0, Then player X wins else Y wins.
• Print X/Y as the winner based on the resultant value of Z in the above step.

Below is the implementation of the above approach.

C++

 `#include ` `using` `namespace` `std;`     `void` `find_winner(``int` `N, ``int` `arr[])` `{` `  ``long` `Z = 0;`   `  ``// Loop for iterating on arr[]` `  ``for` `(``int` `i = 0; i < N; i++) {`   `    ``// Checking current iterated` `    ``// element is odd or not` `    ``if` `(arr[i] % 2 == 1) {`   `      ``// Updating value of Z if` `      ``// odd element found` `      ``Z = Z ^ (N - i - 1);` `    ``}` `  ``}`   `  ``// Printing winner by using` `  ``// value of Z` `  ``if` `(Z == 0) {` `    ``cout<<``"X"``;` `  ``}` `  ``else` `{` `    ``cout<<``"Y"``;` `  ``}` `}`   `// Function which is called in main` `int` `main() ` `{`   `  ``// Driver function`   `  ``// Input N which denotes number of` `  ``// positive elements in arr[]` `  ``int` `N = 4;`   `  ``// Input arr[]` `  ``int` `arr[] = { 2, 3, 1, 3 };`   `  ``// Function call` `  ``find_winner(N, arr);` `  ``return` `0;` `}`   `// This code is contributed by satwik4409.`

Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Driver function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Input N which denotes number of` `        ``// positive elements in arr[]` `        ``int` `N = ``4``;`   `        ``// Input arr[]` `        ``int``[] arr = { ``2``, ``3``, ``1``, ``3` `};`   `        ``// Function call` `        ``find_winner(N, arr);` `    ``}`   `    ``// Function which is called in main` `    ``static` `void` `find_winner(``int` `N, ``int``[] arr)` `    ``{` `        ``long` `Z = ``0``;`   `        ``// Loop for iterating on arr[]` `        ``for` `(``int` `i = ``0``; i < N; i++) {`   `            ``// Checking current iterated` `            ``// element is odd or not` `            ``if` `(arr[i] % ``2` `== ``1``) {`   `                ``// Updating value of Z if` `                ``// odd element found` `                ``Z = Z ^ (N - i - ``1``);` `            ``}` `        ``}`   `        ``// Printing winner by using` `        ``// value of Z` `        ``if` `(Z == ``0``) {` `            ``System.out.println(``"X"``);` `        ``}` `        ``else` `{` `            ``System.out.println(``"Y"``);` `        ``}` `    ``}` `}`

Python3

 `# Python3 code to implement the approach` `def` `find_winner(N, arr) :` `    `  `    ``Z ``=` `0`   `    ``# Loop for iterating on arr[]` `    ``for` `i ``in` `range``(N):`   `        ``# Checking current iterated` `        ``# element is odd or not` `        ``if` `(arr[i] ``%` `2` `=``=` `1``) :`   `            ``# Updating value of Z if` `            ``# odd element found` `            ``Z ``=` `Z ^ (N ``-` `i ``-` `1``)` `    `  `  ``# Printing winner by using` `  ``# value of Z` `    ``if` `(Z ``=``=` `0``) :` `        ``print``(``"X"``)` `  `  `    ``else` `:` `        ``print``(``"Y"``)` `  `  `# Function which is called in main` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Driver function`   `    ``# Input N which denotes number of` `    ``# positive elements in arr[]` `    ``N ``=` `4`   `    ``# Input arr[]` `    ``arr ``=` `[ ``2``, ``3``, ``1``, ``3` `]`   `    ``# Function call` `    ``find_winner(N, arr)`   `    ``# This code is contributed by sanjoy_62.`

C#

 `// C# code to implement the approach` `using` `System;`   `public` `class` `GFG {`   `  ``// Function which is called in main` `  ``static` `void` `find_winner(``int` `N, ``int``[] arr)` `  ``{` `    ``long` `Z = 0;`   `    ``// Loop for iterating on arr[]` `    ``for` `(``int` `i = 0; i < N; i++) {`   `      ``// Checking current iterated` `      ``// element is odd or not` `      ``if` `(arr[i] % 2 == 1) {`   `        ``// Updating value of Z if` `        ``// odd element found` `        ``Z = Z ^ (N - i - 1);` `      ``}` `    ``}`   `    ``// Printing winner by using` `    ``// value of Z` `    ``if` `(Z == 0) {` `      ``Console.WriteLine(``"X"``);` `    ``}` `    ``else` `{` `      ``Console.WriteLine(``"Y"``);` `    ``}` `  ``}` `  ``static` `public` `void` `Main()` `  ``{` `    ``// Input N which denotes number of` `    ``// positive elements in arr[]` `    ``int` `N = 4;`   `    ``// Input arr[]` `    ``int``[] arr = { 2, 3, 1, 3 };`   `    ``// Function call` `    ``find_winner(N, arr);` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

Javascript

 `//javascript code to implement the approach`   `function` `find_winner( N, arr)` `{` `  ``let Z = 0;`   `  ``// Loop for iterating on arr[]` `  ``for` `(let i = 0; i < N; i++) {`   `    ``// Checking current iterated` `    ``// element is odd or not` `    ``if` `(arr[i] % 2 == 1) {`   `      ``// Updating value of Z if` `      ``// odd element found` `      ``Z = Z ^ (N - i - 1);` `    ``}` `  ``}`   `  ``// Printing winner by using` `  ``// value of Z` `  ``if` `(Z == 0) {` `    ``console.log(``"X"``);` `  ``}` `  ``else` `{` `    ``console.log(``"Y"``);` `  ``}` `}`   `// Function which is called in main`   `  ``// Driver function`   `  ``// Input N which denotes number of` `  ``// positive elements in arr[]` `  ``let N = 4;`   `  ``// Input arr[]` `  ``let arr = [ 2, 3, 1, 3 ];`   `  ``// Function call` `  ``find_winner(N, arr);` ` `  `//this code is contributed by ksam24000`

Output

`Y`

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

My Personal Notes arrow_drop_up
Related Articles