# Find the player with least 0s after emptying a Binary String by removing non-empty substrings

Given a binary string **S**, the task is to determine the winner of the game when two players play a game optimally in alternate turns with the given string, as per the following conditions:

**Player 1**always starts first.- In each turn, a player removes a non-empty substring from the given string.
- After the given string is emptied, the player having the minimum count of
**0**s will win the game. If both players have an equal count of**0**s, then print “**Tie**”.

**Examples:**

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 experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

Input:S = “00011”Output:Player 1Explanation:Substrings can be chosen as follows:

Turn 1: Player 1 removes the substring S[4…5]. Therefore, Player 1 contains “11”.

Turn 2: Player 2 removes the substring S[0…0]. Therefore, Player 2 contains “0”.

Turn 3: Player 1 removes the substring S[0…0]. Therefore, Player 1 contains “110”.

Turn 4: Player 2 removes the substring S[0…0]. Therefore, Player 2 contains “00”.

Therefore, Player 1 wins the game.

Input:S = “0110011”Output:Player 2

**Approach:** The problem can be solved based on the following observations:

- If the count of
**0**s in the string is an even number then player 1 and player 2 choose the substring**“0”**in each turn and no player will win this game. - Otherwise, store the count of consecutive
**1**s in an array and apply the game of nim rule on the array. **Nim-Sum:**The cumulative XOR value of the number of coins/stones in each pile/heaps(here consecutive 1s) at any point of the game is called Nim-Sum at that point.

Follow the steps below to solve the problem:

- Initialize a variable, say
**cntZero**, to store the count of**0**s in the string. - Initialize a variable, say
**cntConOne**, to store the count of consecutive**1**s in the string. - Initialize a variable, say
**nimSum**, to store the Nim-Sum of consecutive**1**s of the given string. - Traverse the array and calculate the count of
**0**s and**nimSum**. - Finally, check if the value of
**cntZero**is an even number or not. If found to be true, then print**Tie**. - Otherwise, check if the value of
**nimSum**is greater than**0**or not. If found to be true, then print**Player 1**. - Otherwise, print
**player 2**.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the player` `// who wins the game` `void` `FindwinnerOfGame(string& S)` `{` ` ` `// Stores total count` ` ` `// of 0s in the string` ` ` `int` `cntZero = 0;` ` ` `// Stores count of` ` ` `// consecutive 1s` ` ` `int` `cntConOne = 0;` ` ` `// Stores Nim-Sum on count` ` ` `// of consecutive 1s` ` ` `int` `nimSum = 0;` ` ` `// Stores length` ` ` `// of the string` ` ` `int` `N = S.length();` ` ` `// Traverse the string` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// If the current` ` ` `// character is 1` ` ` `if` `(S[i] == ` `'1'` `) {` ` ` `// Update cntConOne` ` ` `cntConOne += 1;` ` ` `}` ` ` `else` `{` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// Update cntConOne` ` ` `cntConOne = 0;` ` ` `// Update cntZero` ` ` `cntZero++;` ` ` `}` ` ` `}` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// If countZero is` ` ` `// an even number` ` ` `if` `(cntZero % 2 == 0) {` ` ` `cout << ` `"Tie"` `;` ` ` `}` ` ` `// nimSum is not 0` ` ` `else` `if` `(nimSum) {` ` ` `cout << ` `"player 1"` `;` ` ` `}` ` ` `// If nimSum is zero` ` ` `else` `{` ` ` `cout << ` `"player 2"` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"0110011"` `;` ` ` `FindwinnerOfGame(S);` `}` |

## Java

`// Java program to implement` `// the above approach` `// Function to find the player` `// who wins the game` `class` `GFG {` ` ` `public` `static` `void` `FindwinnerOfGame(String S)` ` ` `{` ` ` `// Stores total count` ` ` `// of 0s in the string` ` ` `int` `cntZero = ` `0` `;` ` ` `// Stores count of` ` ` `// consecutive 1s` ` ` `int` `cntConOne = ` `0` `;` ` ` `// Stores Nim-Sum on count` ` ` `// of consecutive 1s` ` ` `int` `nimSum = ` `0` `;` ` ` `// Stores length` ` ` `// of the string` ` ` `int` `N = S.length();` ` ` `// Traverse the string` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `// If the current` ` ` `// character is 1` ` ` `if` `(S.charAt(i) == ` `'1'` `) {` ` ` `// Update cntConOne` ` ` `cntConOne += ` `1` `;` ` ` `}` ` ` `else` `{` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// Update cntConOne` ` ` `cntConOne = ` `0` `;` ` ` `// Update cntZero` ` ` `cntZero++;` ` ` `}` ` ` `}` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// If countZero is` ` ` `// an even number` ` ` `if` `(cntZero % ` `2` `== ` `0` `) {` ` ` `System.out.print(` `"Tie"` `);` ` ` `}` ` ` `// nimSum is not 0` ` ` `else` `if` `(nimSum != ` `0` `) {` ` ` `System.out.print(` `"player 1"` `);` ` ` `}` ` ` `// If nimSum is zero` ` ` `else` `{` ` ` `System.out.print(` `"player 2"` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `String S = ` `"0110011"` `;` ` ` `FindwinnerOfGame(S);` ` ` `}` `}` `// This code is contributed by grand_master.` |

## Python3

`# Python 3 program to implement` `# the above approach` `# Function to find the player` `# who wins the game` `def` `FindwinnerOfGame(S):` ` ` ` ` `# Stores total count` ` ` `# of 0s in the string` ` ` `cntZero ` `=` `0` ` ` `# Stores count of` ` ` `# consecutive 1s` ` ` `cntConOne ` `=` `0` ` ` `# Stores Nim-Sum on count` ` ` `# of consecutive 1s` ` ` `nimSum ` `=` `0` ` ` `# Stores length` ` ` `# of the string` ` ` `N ` `=` `len` `(S)` ` ` `# Traverse the string` ` ` `for` `i ` `in` `range` `(N):` ` ` ` ` `# If the current` ` ` `# character is 1` ` ` `if` `(S[i] ` `=` `=` `'1'` `):` ` ` ` ` `# Update cntConOne` ` ` `cntConOne ` `+` `=` `1` ` ` `else` `:` ` ` ` ` `# Update nimSum` ` ` `nimSum ^` `=` `cntConOne` ` ` `# Update cntConOne` ` ` `cntConOne ` `=` `0` ` ` `# Update cntZero` ` ` `cntZero ` `+` `=` `1` ` ` `# Update nimSum` ` ` `nimSum ^` `=` `cntConOne` ` ` `# If countZero is` ` ` `# an even number` ` ` `if` `(cntZero ` `%` `2` `=` `=` `0` `):` ` ` `print` `(` `"Tie"` `)` ` ` `# nimSum is not 0` ` ` `elif` `(nimSum):` ` ` `print` `(` `"player 1"` `)` ` ` `# If nimSum is zero` ` ` `else` `:` ` ` `print` `(` `"player 2"` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `S ` `=` `"0110011"` ` ` `FindwinnerOfGame(S)` ` ` `# this code is contributed by SURENDRA_GANGWAR.` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `// Function to find the player` `// who wins the game` `class` `GFG {` ` ` `public` `static` `void` `FindwinnerOfGame(` `string` `S)` ` ` `{` ` ` `// Stores total count` ` ` `// of 0s in the string` ` ` `int` `cntZero = 0;` ` ` `// Stores count of` ` ` `// consecutive 1s` ` ` `int` `cntConOne = 0;` ` ` `// Stores Nim-Sum on count` ` ` `// of consecutive 1s` ` ` `int` `nimSum = 0;` ` ` `// Stores length` ` ` `// of the string` ` ` `int` `N = S.Length;` ` ` `// Traverse the string` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// If the current` ` ` `// character is 1` ` ` `if` `(S[i] == ` `'1'` `) {` ` ` `// Update cntConOne` ` ` `cntConOne += 1;` ` ` `}` ` ` `else` `{` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// Update cntConOne` ` ` `cntConOne = 0;` ` ` `// Update cntZero` ` ` `cntZero++;` ` ` `}` ` ` `}` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// If countZero is` ` ` `// an even number` ` ` `if` `(cntZero % 2 == 0) {` ` ` `Console.Write(` `"Tie"` `);` ` ` `}` ` ` `// nimSum is not 0` ` ` `else` `if` `(nimSum != 0) {` ` ` `Console.Write(` `"player 1"` `);` ` ` `}` ` ` `// If nimSum is zero` ` ` `else` `{` ` ` `Console.Write(` `"player 2"` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(` `string` `[] args)` ` ` `{` ` ` `string` `S = ` `"0110011"` `;` ` ` `FindwinnerOfGame(S);` ` ` `}` `}` `// This code is contributed by ukasp.` |

## Javascript

`<script>` `// javascript program of the above approach` ` ` `// Function to find the player` `// who wins the game` ` ` `function` `FindwinnerOfGame(S)` ` ` `{` ` ` `// Stores total count` ` ` `// of 0s in the string` ` ` `let cntZero = 0;` ` ` `// Stores count of` ` ` `// consecutive 1s` ` ` `let cntConOne = 0;` ` ` `// Stores Nim-Sum on count` ` ` `// of consecutive 1s` ` ` `let nimSum = 0;` ` ` `// Stores length` ` ` `// of the string` ` ` `let N = S.length;` ` ` `// Traverse the string` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `// If the current` ` ` `// character is 1` ` ` `if` `(S[i] == ` `'1'` `) {` ` ` `// Update cntConOne` ` ` `cntConOne += 1;` ` ` `}` ` ` `else` `{` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// Update cntConOne` ` ` `cntConOne = 0;` ` ` `// Update cntZero` ` ` `cntZero++;` ` ` `}` ` ` `}` ` ` `// Update nimSum` ` ` `nimSum ^= cntConOne;` ` ` `// If countZero is` ` ` `// an even number` ` ` `if` `(cntZero % 2 == 0) {` ` ` `document.write(` `"Tie"` `);` ` ` `}` ` ` `// nimSum is not 0` ` ` `else` `if` `(nimSum != 0) {` ` ` `document.write(` `"player 1"` `);` ` ` `}` ` ` `// If nimSum is zero` ` ` `else` `{` ` ` `document.write(` `"player 2"` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` ` ` `let S = ` `"0110011"` `;` ` ` `FindwinnerOfGame(S);` `</script>` |

**Output:**

player 2

**Time Complexity:** O(N), where N is the length of the string**Auxiliary Space:** O(1)