Open in App
Not now

# Find the winner if player removes any number of 0 from one side of 1

• Last Updated : 09 Mar, 2023

Given an arr[] of binary digits. Consider two players X and Y are playing a game where in one move a player can remove any number of zeros from either the left or right of an element 1. A player loses the game if he/she can’t make any move. The task is to find the winner of the game if both players play optimally and Y starts first.

Examples:

Input: arr[] = {1}
Output: X
Explanation: There are no zeros initially in the arr[], Therefore, player Y can’t make any move. Hence, Player X wins the game.

Input: arr[] = {0, 1, 0, 0, 1, 1, 0 }
Output:
Explanation:
Y choose 1 at index 5 along which the game will be played as marked as bold in all below operations, Then:
Player Y removes 2 zeros from the left side of element 1. Then arr[] = {0, 1, 1, 1, 0 }
player X removes 1 zero from the left side of element 1. Then arr[] = {1, 1, 1, 0 }
Player Y removes 1 zero from the right side of element 1. Then arr[] = {1, 1, 1}
Now, It’s impossible to make any move for player X, because no zeros are present there. Hence player Y wins.

Approach: Implement the idea below to solve the problem:

There’s always a winning state present for Y, if zeros at right or left of those 1 are not equal. So this problem can be solved by Counting a number of zeros present left and right of each element 1 present in arr[], Y will choose that 1 optimally at which a number of zeros right or left to that 1 are not equal. If the number of zeros on the left and right side are equal, Then X wins else Y wins.

Follow the below steps to solve the problem:

• Initialize two variables counter1 = 0 and counter2= 0 to store the count of zeroes initially in arr[] and for counting zeroes at left and right of 1s in the array.
• Store the number of zeros in counter1 variable by traversing arr[] from the start.
• Iterate through the whole array again from the right:
• If the current element is zero, Then increment counter2.
• If the current element is one, Then check if counter2 is equal to  (counter1-counter2).
• If yes return true. Otherwise, return false.

Below is the implementation of the above approach.

## C++

 // C++ implementation #include using namespace std;   // Function for finding winner string findWinner(int arr[], int n) {   //  int n= arr.size();   // Variable to store number of   // zeros present initially in arr[]   int counter1 = 0;     // Variable to store number of   // zeros while traversing   // arr[] again   int counter2 = 0;     // Loop for traversing on input arr[]   for (int i = 0; i < n; i++) {       // Incrementing counter1 if     // 0 is found     counter1 = arr[i] == 0 ? counter1 + 1 : counter1;   }     // Loop for traversing again on arr[]   for (int i = 0; i < n; i++) {       // If zero is found then increment     // counter2     counter2 = arr[i] == 0 ? counter2 + 1 : counter2;       // If one is found then check     // zero at left or right side     // are equal?     if (arr[i] == 1) {         // Checking that zero at left       // or right side of current       // element 1 are equal?       if (counter2 == (counter1 - counter2)) {           // If equal then         // returning X         return "X";       }     }   }   // If zeros are not equal then   // returning Y   return "Y"; }   int main() {   int n = 8;   int arr[] = { 0, 1, 0, 0, 1, 1, 0, 0 };     // Function call   cout << (findWinner(arr, n));   return 0; }   // this code is contributed by ksam24000

## Java

 // Java code to implement the approach   import java.io.*; import java.lang.*; import java.util.*;   class GFG {       // Driver code     public static void main(String[] args)     {         int[] arr = { 0, 1, 0, 0, 1, 1, 0, 0 };           // Function call         System.out.println(findWinner(arr));     }       // Function for finding winner     static String findWinner(int[] arr)     {         // Variable to store number of         // zeros present initially in arr[]         int counter1 = 0;           // Variable to store number of         // zeros while traversing         // arr[] again         int counter2 = 0;           // Loop for traversing on input arr[]         for (int i = 0; i < arr.length; i++) {               // Incrementing counter1 if             // 0 is found             counter1                 = arr[i] == 0 ? counter1 + 1 : counter1;         }           // Loop for traversing again on arr[]         for (int i = 0; i < arr.length; i++) {               // If zero is found then increment             // counter2             counter2                 = arr[i] == 0 ? counter2 + 1 : counter2;               // If one is found then check             // zero at left or right side             // are equal?             if (arr[i] == 1) {                   // Checking that zero at left                 // or right side of current                 // element 1 are equal?                 if (counter2 == (counter1 - counter2)) {                       // If equal then                     // returning X                     return "X";                 }             }         }           // If zeros are not equal then         // returning Y         return "Y";     } }

## Python3

 # Python code to implement the approach   # Function for finding winner def findWinner(arr,n):     # n=len(arr)     # Variable to store number of     # zeros present initially in arr[]     counter1=0           # Variable to store number of     # zeros while traversing     # arr[] again     counter2=0           # Loop for traversing on input arr[]     for i in range(n):         # Incrementing counter1 if         # 0 is found         counter1 = (counter1+1) if arr[i]==0 else counter1           # Loop for traversing again on arr[]     for i in range(n):         # If zero is found then increment         # counter2         counter2 = (counter2+1) if arr[i]==0 else counter2                   # If one is found then check         # zero at left or right side         # are equal?         if(arr[i]==1):             # Checking that zero at left             # or right side of current             # element 1 are equal?             if(counter2==(counter1-counter2)):                 # If equal then                 # returning X                 return "X"     # If zeros are not equal then     # returning Y     return "Y"       # Driver code n=8 arr=[0, 1, 0, 0, 1, 1, 0, 0]   # Function call print(findWinner(arr,n))   # This code is contributed by Pushpesh Raj.

## C#

 // C# code to implement the approach using System; class GFG {     // Driver code   public static void Main()   {     int[] arr = { 0, 1, 0, 0, 1, 1, 0, 0 };       // Function call     Console.WriteLine(findWinner(arr));   }     // Function for finding winner   static string findWinner(int[] arr)   {     // Variable to store number of     // zeros present initially in arr[]     int counter1 = 0;       // Variable to store number of     // zeros while traversing     // arr[] again     int counter2 = 0;       // Loop for traversing on input arr[]     for (int i = 0; i < arr.Length; i++) {         // Incrementing counter1 if       // 0 is found       counter1         = arr[i] == 0 ? counter1 + 1 : counter1;     }       // Loop for traversing again on arr[]     for (int i = 0; i < arr.Length; i++) {         // If zero is found then increment       // counter2       counter2         = arr[i] == 0 ? counter2 + 1 : counter2;         // If one is found then check       // zero at left or right side       // are equal?       if (arr[i] == 1) {           // Checking that zero at left         // or right side of current         // element 1 are equal?         if (counter2 == (counter1 - counter2)) {             // If equal then           // returning X           return "X";         }       }     }       // If zeros are not equal then     // returning Y     return "Y";   } }   // This code is contributed by Samim Hossain Mondal.

## Javascript

 // JS implementation   // Function for finding winner function findWinner(arr,n) {   //  int n= arr.size();   // Variable to store number of   // zeros present initially in arr[]   let counter1 = 0;     // Variable to store number of   // zeros while traversing   // arr[] again   let counter2 = 0;     // Loop for traversing on input arr[]   for (let i = 0; i < n; i++) {       // Incrementing counter1 if     // 0 is found     counter1 = arr[i] == 0 ? counter1 + 1 : counter1;   }     // Loop for traversing again on arr[]   for (let i = 0; i < n; i++) {       // If zero is found then increment     // counter2     counter2 = arr[i] == 0 ? counter2 + 1 : counter2;       // If one is found then check     // zero at left or right side     // are equal?     if (arr[i] == 1) {         // Checking that zero at left       // or right side of current       // element 1 are equal?       if (counter2 == (counter1 - counter2)) {           // If equal then         // returning X         return "X";       }     }   }   // If zeros are not equal then   // returning Y   return "Y"; }      let n = 8;   let arr = [ 0, 1, 0, 0, 1, 1, 0, 0 ];     // Function call   console.log(findWinner(arr, n));    // this code is contributed by ksam24000

Output

Y

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

Related Articles:

My Personal Notes arrow_drop_up
Related Articles