# A modified game of Nim

Given an array **arr[]** of integers, two players **A** and **B** are playing a game where **A** can remove any number of non-zero elements from the array that are **multiples of 3**. Similarly, **B** can remove **multiples of 5**. The player who can’t remove any element loses the game. The task is to find the winner of the game if **A** starts first and both play optimally.

**Examples:**

Input:arr[] = {1, 2, 3, 5, 6}

Output:A

3 and 6 are the elements that A can remove.

5 is the only element that B can remove.

A can remove 3 in his first move then B will have to remove 5. In the next turn, A will remove 6 and B will be left with no more moves to make.

Input:arr[] = {3, 5, 15, 20, 6, 9}

Output:A

**Approach:** Store the count of elements only divisible by 3 in **movesA**, count of elements only divisible by 5 in **movesB** and the elements divisible by both in **movesBoth**. Now,

- If
**movesBoth = 0**then both the players can remove only the elements which are divisible by their respective number and**A**will win the game only when**movesA > movesB**. - If
**movesBoth > 0**then in order to play optimally,**A**will remove all the elements that are divisible by both**3**and**5**so that**B**is left with no elements to remove from the common elements then**A**will be the winner only if**movesA + 1 > movesB**

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the winner of the game ` `string getWinner(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `int` `movesA = 0, movesB = 0, movesBoth = 0; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Increment common moves ` ` ` `if` `(arr[i] % 3 == 0 && arr[i] % 5 == 0) ` ` ` `movesBoth++; ` ` ` ` ` `// Increment A's moves ` ` ` `else` `if` `(arr[i] % 3 == 0) ` ` ` `movesA++; ` ` ` ` ` `// Increment B's moves ` ` ` `else` `if` `(arr[i] % 5 == 0) ` ` ` `movesB++; ` ` ` `} ` ` ` ` ` `// If there are no common moves ` ` ` `if` `(movesBoth == 0) { ` ` ` `if` `(movesA > movesB) ` ` ` `return` `"A"` `; ` ` ` `return` `"B"` `; ` ` ` `} ` ` ` ` ` `// 1 is added because A can remove all the elements ` ` ` `// that are part of the common moves in a single move ` ` ` `if` `(movesA + 1 > movesB) ` ` ` `return` `"A"` `; ` ` ` `return` `"B"` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 2, 3, 5, 6 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` `cout << getWinner(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `class` `GfG ` `{ ` ` ` ` ` `// Function to return the winner of the game ` ` ` `static` `String getWinner(` `int` `arr[], ` `int` `n) ` ` ` `{ ` ` ` `int` `movesA = ` `0` `, movesB = ` `0` `, movesBoth = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` ` ` `// Increment common moves ` ` ` `if` `(arr[i] % ` `3` `== ` `0` `&& arr[i] % ` `5` `== ` `0` `) ` ` ` `movesBoth++; ` ` ` ` ` `// Increment A's moves ` ` ` `else` `if` `(arr[i] % ` `3` `== ` `0` `) ` ` ` `movesA++; ` ` ` ` ` `// Increment B's moves ` ` ` `else` `if` `(arr[i] % ` `5` `== ` `0` `) ` ` ` `movesB++; ` ` ` `} ` ` ` ` ` `// If there are no common moves ` ` ` `if` `(movesBoth == ` `0` `) ` ` ` `{ ` ` ` `if` `(movesA > movesB) ` ` ` `return` `"A"` `; ` ` ` `return` `"B"` `; ` ` ` `} ` ` ` ` ` `// 1 is added because A can remove ` ` ` `// all the elements that are part ` ` ` `// of the common moves in a single move ` ` ` `if` `(movesA + ` `1` `> movesB) ` ` ` `return` `"A"` `; ` ` ` `return` `"B"` `; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String []args) ` ` ` `{ ` ` ` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `3` `, ` `5` `, ` `6` `}; ` ` ` `int` `n = arr.length; ` ` ` `System.out.println(getWinner(arr, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Rituraj Jain ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `# Function to return the winner of the game ` `def` `getWinner(arr, n): ` ` ` ` ` `movesA, movesB, movesBoth ` `=` `0` `, ` `0` `, ` `0` ` ` `for` `i ` `in` `range` `(` `0` `, n): ` ` ` ` ` `# Increment common moves ` ` ` `if` `arr[i] ` `%` `3` `=` `=` `0` `and` `arr[i] ` `%` `5` `=` `=` `0` `: ` ` ` `movesBoth ` `+` `=` `1` ` ` ` ` `# Increment A's moves ` ` ` `elif` `arr[i] ` `%` `3` `=` `=` `0` `: ` ` ` `movesA ` `+` `=` `1` ` ` ` ` `# Increment B's moves ` ` ` `elif` `arr[i] ` `%` `5` `=` `=` `0` `: ` ` ` `movesB ` `+` `=` `1` ` ` ` ` `# If there are no common moves ` ` ` `if` `movesBoth ` `=` `=` `0` `: ` ` ` `if` `movesA > movesB: ` ` ` `return` `"A"` ` ` `return` `"B"` ` ` ` ` `# 1 is added because A can ` ` ` `# remove all the elements ` ` ` `# that are part of the common ` ` ` `# moves in a single move ` ` ` `if` `movesA ` `+` `1` `> movesB: ` ` ` `return` `"A"` ` ` `return` `"B"` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `arr ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `5` `, ` `6` `] ` ` ` `n ` `=` `len` `(arr) ` ` ` `print` `(getWinner(arr, n)) ` ` ` `# This code is contributed by Rituraj Jain ` |

*chevron_right*

*filter_none*

**Output:**

A

## Recommended Posts:

- Combinatorial Game Theory | Set 2 (Game of Nim)
- Find the maximum possible value of the minimum value of modified array
- Sum of nth terms of Modified Fibonacci series made by every pair of two arrays
- Check if a king can move a valid move or not when N nights are there in a modified chessboard
- Variation in Nim Game
- Implementation of Tic-Tac-Toe game
- Find the winner in nim-game
- Optimal Strategy for a Game | DP-31
- Check if the game is valid or not
- The prisoner's dilemma in Game theory
- Combinatorial Game Theory | Set 1 (Introduction)
- Count the numbers that can be reduced to zero or less in a game
- Game of Nim with removal of one stone allowed
- Game of replacing array elements
- Game of N stones where each player can remove 1, 3 or 4

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.