 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