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

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: Y 
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 <bits/stdc++.h>
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)