Skip to content
Related Articles
A modified game of Nim
• Last Updated : 27 Apr, 2021

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:
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:

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 ``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);``    ``cout << getWinner(arr, n);` `    ``return` `0;``}`

## 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`

## 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`

## C#

 `// C# implementation of the approach``using` `System;` `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;``        ``Console.WriteLine(getWinner(arr, n));``    ``}``}` `// This code is contributed by``// Rajput-Ji`

## PHP

 ` ``\$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``    ``\$arr` `= ``array``( 1, 2, 3, 5, 6 );``    ``\$n` `= sizeof(``\$arr``) / sizeof(``\$arr``);``    ``echo` `getWinner(``\$arr``, ``\$n``);` `// This code is contributed by ajit.``?>`

## Javascript

 ``
Output:
`A`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up