 Open in App
Not now

# Find winner of the Game where Array elements are reduced in each turn

• Last Updated : 06 Oct, 2022

Given a circular array arr[] of size N containing positive integers only, Player A and B are playing a game, turn by turn, the game will start with player A at index 0 and then player B at the next index.

• In every turn a player can deduct some value from arr[i] and decrease the value of an element arr[i] to X ( 0 to arr[i]-1 ).
• Then, other player turn will come and he/she will do the same with the next element in right circular order.

If a player cannot decrease the value of the element then he/she loses. Find if A and B play optimally, who will win?

Note: In each turn, a player moves to a new position than his/her previous position.

Examples:

Input: arr[] = {1, 2, 4, 3}
Output: B
Explanation: A have to deduct 1 from 1,
Now it’s B turn, B deduct whatever from 2,
Again, A deduct whatever from index 3,
Again, B deduct whatever from index 4,
Now, it’s A turn, and A is on index 0, and index 0th element is 0.
So, A will lose, B win.

Input: arr[] = {5}
Output: A
Explanation: A will decrease the value of arr[i]( 5 ) to 0.
So, for B the number become 0 and B will lose, A win.

Approach: To solve the problem follow the below idea:

The idea is, A only remove some amount from even indexed integers and B only remove some amount from odd indexed integers.

If N = odd, A will always win because

• A will remove all the amount from index 0 element making the number = 0,
• Now the other numbers whatever maybe and whatever amount will both of them remove from them, the thing is, B will always come to 0th indexed element i.e., 0, after one rotation, So, B will lose for sure,

But for N = Even, we check in what position the minimum element occur, even or odd, because

• The optimal strategy is that every one remove 1 unit from their parity element.
• And in whichever parity the first time minimum element will occur that parity element will become 0 for the first time and the player will lose and other parity element will win.

Follow the below steps to solve the problem:

• If N is Odd, A will win for sure, so just print A.
• Else find position of the first minimum element in the arr[].
• If the position is even A will win.
• Else B will win.

Below is the implementation of the above approach.

## C++

```// C++ code to implement the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find who will win A or B
void findAorB(int* arr, int N)
{
int K, Min = INT_MAX;

// If N is odd A will win
if (N & 1)
cout << "A" << endl;

// Else find position of minimum element
else {
for (int i = 0; i < N; i++) {
if (Min > arr[i]) {
Min = arr[i];
K = i + 1;
}
}

// If position of Min element is odd
// B will win
if (K & 1)
cout << "B" << endl;

// If position of Min element is even
// A will win
else
cout << "A" << endl;
}
}

// Driver Code
int main()
{
int arr[] = { 1, 2, 4, 3 };
int N = sizeof(arr) / sizeof(arr);

// Function call
findAorB(arr, N);
return 0;
}```

## Java

```// Java code to implement the above approach
import java.io.*;

class GFG {
// Function to find who will win A or B
public static void findAorB(int arr[], int N)
{
int K = 0, Min = Integer.MAX_VALUE;

// If N is odd A will win
if (N % 2 != 0)
System.out.println("A");

// Else find position of minimum element
else {
for (int i = 0; i < N; i++) {
if (Min > arr[i]) {
Min = arr[i];
K = i + 1;
}
}

// If position of Min element is odd
// B will win
if (K % 2 != 0)
System.out.println("B");

// If position of Min element is even
// A will win
else
System.out.println("A");
}
}

// Driver Code
public static void main(String[] args)
{
int arr[] = { 1, 2, 4, 3 };
int N = 4;

// Function call
findAorB(arr, N);
}
}

// This code is contributed by Rohit Pradhan```

## Python3

```# python3 code to implement the above approach

INT_MAX = 2147483647

# Function to find who will win A or B

def findAorB(arr, N):

K = 0
Min = INT_MAX

# If N is odd A will win
if (N & 1):
print("A")

# Else find position of minimum element
else:
for i in range(0, N):
if (Min > arr[i]):
Min = arr[i]
K = i + 1

# If position of Min element is odd
# B will win
if (K & 1):
print("B")

# If position of Min element is even
# A will win
else:
print("A")

# Driver Code
if __name__ == "__main__":

arr = [1, 2, 4, 3]
N = len(arr)

# Function call
findAorB(arr, N)

# This code is contributed by rakeshsahni
```

## C#

```// C# code to implement the above approach
using System;
public class GFG
{

// Function to find who will win A or B
public static void findAorB(int []arr, int N)
{
int K = 0, Min = int.MaxValue;

// If N is odd A will win
if (N % 2 != 0)
Console.WriteLine("A");

// Else find position of minimum element
else {
for (int i = 0; i < N; i++) {
if (Min > arr[i]) {
Min = arr[i];
K = i + 1;
}
}

// If position of Min element is odd
// B will win
if (K % 2 != 0)
Console.WriteLine("B");

// If position of Min element is even
// A will win
else
Console.WriteLine("A");
}
}

// Driver Code
public static void Main(string[] args)
{
int []arr = { 1, 2, 4, 3 };
int N = 4;

// Function call
findAorB(arr, N);
}
}

// This code is contributed by AnkThon```

## Javascript

```<script>
// Javascript code to implement the above approach

// Function to find who will win A or B
function findAorB(arr,N)
{
let K, Min = Number.MAX_VALUE;

// If N is odd A will win
if (N & 1)
document.write("A" );

// Else find position of minimum element
else {
for (let i = 0; i < N; i++) {
if (Min > arr[i]) {
Min = arr[i];
K = i + 1;
}
}

// If position of Min element is odd
// B will win
if (K & 1)
document.write("B");

// If position of Min element is even
// A will win
else
document.write("A");
}
}

// Driver Code

let arr = [ 1, 2, 4, 3 ];
let N = arr.length;

// Function call
findAorB(arr, N);
</script>```
Output

`B`

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

My Personal Notes arrow_drop_up
Related Articles