Open In App

Find the last remaining Character in the Binary String according to the given conditions

Improve
Improve
Like Article
Like
Save
Share
Report

Given a binary string str consisting of only 0’s and 1’s. The following two operations can be performed on it: 
 

  1. One digit can delete another digit i.e. a 0 can delete a 1 and vice versa.
  2. If at any moment, the entire string consists only 0’s or 1’s, then the respective digit is printed.

The task is to print the remaining digit which will be left at the end.
Examples: 
 

Input: str = “100” 
Output:
Explanation: 
The 1st digit is 1 and it deletes the next digit 0. 
The 2nd digit, i.e. 0, is deleted and now does not exists. 
Now, the 3rd digit 0 deletes the 1st digit 1. 
Since now only 0 is left, the output is 0.
Input: str = “10” 
Output:
 

 

Approach: For this queue data structure is used. The following steps can be followed to compute the answer: 
 

  1. All the digits are added to the queue.
  2. Two counters are maintained as an array of size 2 del[2] which will represent the number of floating deletes present for each digit.
  3. The queue is traversed until there exits at least one digit of both the types.
  4. Then for each digit in the queue if the delete counter for this digit is not 0, then it is deleted.
  5. Else, the delete counter for the opposite digit is incremented and placed back into the queue.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
string remainingDigit(string S, int N)
{
     
 
    // Delete counters for each to
    // count the deletes
    int del[] = { 0, 0 };
 
    // Counters to keep track
    // of characters left from each type
    int count[] = { 0, 0 };
 
    // Queue to simulate the process
    queue<int> q;
 
    // Initializing the queue
    for (int i = 0; i < N; i++)
    {
        int x = S[i] == '1' ? 1 : 0;
        count[x]++;
        q.push(x);
    }
 
    // Looping till at least 1 digit is
    // left from both the type
    while (count[0] > 0 && count[1] > 0)
    {
        int t = q.front();
        q.pop();
 
        // If there is a floating delete for
        // current character we will
        // delete it and move forward otherwise
        // we will increase delete counter for
        // opposite digit
        if (del[t] > 0)
        {
            del[t]--;
            count[t]--;
        }
        else
        {
            del[t ^ 1]++;
            q.push(t);
        }
    }
 
    // If 0 are left
    // then answer is 0 else
    // answer is 1
    if (count[0] > 0)
        return "0";
    return "1";
}
 
// Driver Code
int main()
{
 
    // Input String
    string S = "1010100100000";
 
    // Length of String
    int N = S.length();
 
    // Printing answer
    cout << remainingDigit(S, N);
}
 
// This code is contributed by tufan_gupta2000


Java




// Java implementation of the above approach
 
import java.util.*;
 
public class GfG {
    private static String remainingDigit(String S, int N)
    {
        // Converting string to array
        char c[] = S.toCharArray();
 
        // Delete counters for each to
        // count the deletes
        int del[] = { 0, 0 };
 
        // Counters to keep track
        // of characters left from each type
        int count[] = { 0, 0 };
 
        // Queue to simulate the process
        Queue<Integer> q = new LinkedList<>();
 
        // Initializing the queue
        for (int i = 0; i < N; i++) {
            int x = c[i] == '1' ? 1 : 0;
            count[x]++;
            q.add(x);
        }
 
        // Looping till at least 1 digit is
        // left from both the type
        while (count[0] > 0 && count[1] > 0) {
            int t = q.poll();
 
            // If there is a floating delete for
            // current character we will
            // delete it and move forward otherwise
            // we will increase delete counter for
            // opposite digit
            if (del[t] > 0) {
                del[t]--;
                count[t]--;
            }
            else {
                del[t ^ 1]++;
                q.add(t);
            }
        }
 
        // If 0 are left
        // then answer is 0 else
        // answer is 1
        if (count[0] > 0)
            return "0";
        return "1";
    }
 
    // Driver Code
    public static void main(String args[])
    {
 
        // Input String
        String S = "1010100100000";
 
        // Length of String
        int N = S.length();
 
        // Printing answer
        System.out.print(remainingDigit(S, N));
    }
}


Python3




# Python3 implementation of the above approach
from collections import deque;
 
def remainingDigit(S, N):
     
    # Converting string to array
    c = [i for i in S]
 
    # Delete counters for each to
    # count the deletes
    de = [0, 0]
 
    # Counters to keep track
    # of characters left from each type
    count = [0, 0]
 
    # Queue to simulate the process
    q = deque()
 
    # Initializing the queue
    for i in c:
        x = 0
        if i == '1':
            x = 1
        count[x] += 1
        q.append(x)
 
    # Looping till at least 1 digit is
    # left from both the type
    while (count[0] > 0 and count[1] > 0):
        t = q.popleft()
 
        # If there is a floating delete for
        # current character we will
        # delete it and move forward otherwise
        # we will increase delete counter for
        # opposite digit
        if (de[t] > 0):
            de[t] -= 1
            count[t] -= 1
        else:
            de[t ^ 1] += 1
            q.append(t)
 
    # If 0 are left
    # then answer is 0 else
    # answer is 1
    if (count[0] > 0):
        return "0"
    return "1"
 
# Driver Code
if __name__ == '__main__':
 
    # Input String
    S = "1010100100000"
 
    # Length of String
    N = len(S)
 
    # Printing answer
    print(remainingDigit(S, N))
 
# This code is contributed by mohit kumar 29


C#




// C# implementation of the above approach
using System;
using System.Collections.Generic;
 
public class GfG
{
    private static String remainingDigit(String S, int N)
    {
        // Converting string to array
        char []c = S.ToCharArray();
 
        // Delete counters for each to
        // count the deletes
        int []del = { 0, 0 };
 
        // Counters to keep track
        // of characters left from each type
        int []count = { 0, 0 };
 
        // Queue to simulate the process
        List<int> q = new List<int>();
 
        // Initializing the queue
        for (int i = 0; i < N; i++)
        {
            int x = c[i] == '1' ? 1 : 0;
            count[x]++;
            q.Add(x);
        }
 
        // Looping till at least 1 digit is
        // left from both the type
        while (count[0] > 0 && count[1] > 0)
        {
            int t = q[0];
            q.RemoveAt(0);
 
            // If there is a floating delete for
            // current character we will
            // delete it and move forward otherwise
            // we will increase delete counter for
            // opposite digit
            if (del[t] > 0)
            {
                del[t]--;
                count[t]--;
            }
            else
            {
                del[t ^ 1]++;
                q.Add(t);
            }
        }
 
        // If 0 are left
        // then answer is 0 else
        // answer is 1
        if (count[0] > 0)
            return "0";
        return "1";
    }
 
    // Driver Code
    public static void Main(String []args)
    {
 
        // Input String
        String S = "1010100100000";
 
        // Length of String
        int N = S.Length;
 
        // Printing answer
        Console.Write(remainingDigit(S, N));
    }
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
// Javascript implementation of the above approach
 
function remainingDigit(S,N)
{
     // Converting string to array
        let c = S.split("");
   
        // Delete counters for each to
        // count the deletes
        let del = [ 0, 0 ];
   
        // Counters to keep track
        // of characters left from each type
        let count = [ 0, 0 ];
   
        // Queue to simulate the process
        let q = [];
   
        // Initializing the queue
        for (let i = 0; i < N; i++) {
            let x = (c[i] == '1' ? 1 : 0);
            count[x]++;
            q.push(x);
        }   
         
        // Looping till at least 1 digit is
        // left from both the type
        while (count[0] > 0 && count[1] > 0) {
            let t = q.shift();
   
            // If there is a floating delete for
            // current character we will
            // delete it and move forward otherwise
            // we will increase delete counter for
            // opposite digit
            if (del[t] > 0) {
                del[t]--;
                count[t]--;
            }
            else {
                del[t ^ 1]++;
                q.push(t);
            }
        }
   
        // If 0 are left
        // then answer is 0 else
        // answer is 1
        if (count[0] > 0)
            return "0";
        return "1";
}
 
// Driver Code
 
let S = "1010100100000";
   
// Length of String
let N = S.length;
 
// Printing answer
document.write(remainingDigit(S, N));
 
 
// This code is contributed by unknown2108
</script>


Output: 

0

 

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



Last Updated : 28 Mar, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads