Skip to content
Related Articles

Related Articles

Find the player with least 0s after emptying a Binary String by removing non-empty substrings
  • Last Updated : 03 Mar, 2021

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 0s will win the game. If both players have equal count of 0s, then print “Tie”.

Examples:

Input: S = “00011” 
Output: Player 1 
Explanation: 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 count of 0s in the string is an even number then the 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 1s 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 piles/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 count of 0s in the string.
  • Initialize a variable, say cntConOne, to store the count of consecutive 1s in the string.
  • Initialize a variable, say nimSum, to store the Nim-Sum of consecutive 1s of the given string.
  • Traverse the array and calculate count of 0s 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 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.
Output: 
player 2
 
Time Complexity: O(N), where N is the length of the string
Auxiliary Space: O(1)
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.
My Personal Notes
arrow_drop_up
Previous
Queries to count numbers from given range which are divisible by all its digits
Next

Longest subset of nested elements from a given array
Recommended Articles
Page :
Two player game in which a player can remove all occurrences of a number
21, May 20
Count binary strings of length same as given string after removal of substrings "01" and "00" that consists of at least one '1'
18, Nov 20
Find the player to reach at least N by multiplying with any value from given range
24, Jan 21
Find the player who wins the game by removing the last of given N cards
02, Sep 20
Minimize a binary string by repeatedly removing even length substrings of same characters
03, Dec 20
Subsequence queries after removing substrings
24, Dec 17
Find the player who is the last to remove any character from the beginning of a Binary String
30, Sep 20
Find the last player to be able to flip a character in a Binary String
15, Feb 21
Print string after removing all (“10” or “01”) from the binary string
14, Apr 20
Find the player to last modify a string such that even number of consonants and no vowels are left in the string
14, Oct 20
Lexicographically smallest permutation of a string that can be reduced to length K by removing K-length prefixes from palindromic substrings of length 2K
11, Nov 20
Find the player who rearranges the characters to get a palindrome string first
21, Nov 18
Find the last player to be able to remove a string from an array which is not already removed from other array
03, Feb 21
Find the winner of a game of removing any number of stones from the least indexed non-empty pile from given N piles
07, Sep 20
Minimum score possible for a player by selecting one or two consecutive array elements from given binary array
16, Nov 20
Check if binary representations of 0 to N are present as substrings in given binary string
23, Jul 20
Find the resultant String after replacing X with Y and removing Z
09, Jan 20
Minimize length of Substrings containing at least one common Character
27, Jul 20
Count of Substrings with at least K pairwise Distinct Characters having same Frequency
14, Aug 20
Maximum score possible by removing substrings made up of single distinct character
17, Mar 21
Minimum steps to delete a string after repeated deletion of palindrome substrings
18, May 17
Count pairs of substrings from a string S such that S1 does not occur after S2 in each pair
04, Jan 21
Find probability that a player wins when probabilities of hitting the target are given
03, Jan 19
Find the minimum possible health of the winning player
13, Nov 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
koulick_sadhu
@koulick_sadhu
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox