Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Find the maximum occurring character after performing the given operations

  • Last Updated : 12 Nov, 2021

Given a string str consisting of 0, 1, and *, the task is to find the maximum occurring character out of 0 and 1 after performing the given operations: 
 

  • Replace * with 0 where * appears on the left side of the existing 0s in the string.
  • Replace * with 1 where * appears on the right side of the existing 1s in the string.
  • If any * can be replaced by both 0 and 1, then it remains unchanged.

Note: If the frequency of 0 and 1 is same after performing the given operations then print -1.

Examples:

Input: str = “**0**1***0” 
Output:
Explanation: 
Since 0 can replace the * to its left and 1 can replace the * to its right thus string becomes 000**1***0

Input: str = “0*1” 
Output: -1 
Explanation: 
Both 0 and 1 have the same frequency hence the output is -1.

Approach: The idea to generate the final resultant string and then compare the frequency of 0 and 1. Below are the steps:

  • Count the initial frequencies of 0 and 1 in the string and store them in variables say count_0 and count_1.
  • Initialize a variable, say prev, as -1. Iterate over the string and check if the current character is *. If so, then continue.
  • If it is the first character encountered and is 0 then add all * to count_0 and change prev to current index.
  • Otherwise, if the first character is 1 then change prev to current index.
  • If the previous character is 1 and the current character is 0 then add half of * in between the characters to 0 and half to 1.
  • If the previous character is 0 and the current character is 1 then no * character in between them can be replaced.
  • If the previous and current both characters are of the same type then add the count of * to the frequencies.
  • Compare the frequencies of 0 and 1 and print the maximum occurring character.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// maximum occurring character
void solve(string S)
{
    // Initialize count of
    // zero and one
    int count_0 = 0, count_1 = 0;
 
    int prev = -1;
 
    // Iterate over the given string
    for (int i = 0; i < S.length(); i++) {
 
        // Count the zeros
        if (S[i] == '0')
            count_0++;
 
        // Count the ones
        else if (S[i] == '1')
            count_1++;
    }
 
    // Iterate over the given string
    for (int i = 0; i < S.length(); i++) {
 
        // Check if character
        // is * then continue
        if (S[i] == '*')
            continue;
 
        // Check if first character
        // after * is X
        else if (S[i] == '0' && prev == -1) {
 
            // Add all * to
            // the frequency of X
            count_0 = count_0 + i;
 
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if first character
        // after * is Y
        else if (S[i] == '1' && prev == -1) {
 
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if prev character is 1
        // and current character is 0
        else if (S[prev] == '1' && S[i] == '0') {
 
            // Half of the * will be
            // converted to 0
            count_0 = count_0 + (i - prev - 1) / 2;
 
            // Half of the * will be
            // converted to 1
            count_1 = count_1 + (i - prev - 1) / 2;
            prev = i;
        }
 
        // Check if prev and current are 1
        else if (S[prev] == '1' && S[i] == '1') {
 
            // All * will get converted to 1
            count_1 = count_1 + (i - prev - 1);
            prev = i;
        }
 
        // No * can be replaced
        // by either 0 or 1
        else if (S[prev] == '0' && S[i] == '1')
 
            // Prev becomes the ith character
            prev = i;
 
        // Check if prev and current are 0
        else if (S[prev] == '0' && S[i] == '0') {
 
            // All * will get converted to 0
            count_0 = count_0 + (i - prev - 1);
            prev = i;
        }
    }
 
    // If frequency of 0
    // is more
    if (count_0 > count_1)
        cout << "0";
 
    // If frequency of 1
    // is more
    else if (count_1 > count_0)
        cout << "1";
 
    else {
        cout << -1;
    }
}
 
// Driver code
int main()
{
    // Given string
    string str = "**0**1***0";
 
    // Function Call
    solve(str);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
 
class GFG{
     
// Function to find the
// maximum occurring character
static void solve(String S)
{
     
    // Initialize count of
    // zero and one
    int count_0 = 0, count_1 = 0;
 
    int prev = -1;
 
    // Iterate over the given string
    for(int i = 0; i < S.length(); i++)
    {
         
        // Count the zeros
        if (S.charAt(i) == '0')
            count_0++;
 
        // Count the ones
        else if (S.charAt(i) == '1')
            count_1++;
    }
 
    // Iterate over the given string
    for(int i = 0; i < S.length(); i++)
    {
 
        // Check if character
        // is * then continue
        if (S.charAt(i) == '*')
            continue;
 
        // Check if first character
        // after * is X
        else if (S.charAt(i) == '0' && prev == -1)
        {
             
            // Add all * to
            // the frequency of X
            count_0 = count_0 + i;
 
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if first character
        // after * is Y
        else if (S.charAt(i) == '1' && prev == -1)
        {
 
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if prev character is 1
        // and current character is 0
        else if (S.charAt(prev) == '1' &&
                 S.charAt(i) == '0')
        {
 
            // Half of the * will be
            // converted to 0
            count_0 = count_0 + (i - prev - 1) / 2;
 
            // Half of the * will be
            // converted to 1
            count_1 = count_1 + (i - prev - 1) / 2;
            prev = i;
        }
 
        // Check if prev and current are 1
        else if (S.charAt(prev) == '1' &&
                 S.charAt(i) == '1')
        {
 
            // All * will get converted to 1
            count_1 = count_1 + (i - prev - 1);
            prev = i;
        }
 
        // No * can be replaced
        // by either 0 or 1
        else if (S.charAt(prev) == '0' &&
                 S.charAt(i) == '1')
 
            // Prev becomes the ith character
            prev = i;
 
        // Check if prev and current are 0
        else if (S.charAt(prev) == '0' &&
                 S.charAt(i) == '0')
        {
 
            // All * will get converted to 0
            count_0 = count_0 + (i - prev - 1);
            prev = i;
        }
    }
 
    // If frequency of 0
    // is more
    if (count_0 > count_1)
        System.out.print("0");
 
    // If frequency of 1
    // is more
    else if (count_1 > count_0)
        System.out.print("1");
 
    else
    {
        System.out.print("-1");
    }
}
 
// Driver code
public static void main (String[] args)
{
     
    // Given string
    String str = "**0**1***0";
 
    // Function call
    solve(str);
}
}
 
// This code is contributed by code_hunt

Python3




# Python3 program for the above approach
 
# Function to find the
# maximum occurring character
def solve(S):
     
    # Initialize count of
    # zero and one
    count_0 = 0
    count_1 = 0
 
    prev = -1
 
    # Iterate over the given string
    for i in range(len(S)) :
 
        # Count the zeros
        if (S[i] == '0'):
            count_0 += 1
 
        # Count the ones
        elif (S[i] == '1'):
            count_1 += 1
     
    # Iterate over the given string
    for i in range(len(S)):
 
        # Check if character
        # is * then continue
        if (S[i] == '*'):
            continue
 
        # Check if first character
        # after * is X
        elif (S[i] == '0' and prev == -1):
 
            # Add all * to
            # the frequency of X
            count_0 = count_0 + i
 
            # Set prev to the
            # i-th character
            prev = i
         
        # Check if first character
        # after * is Y
        elif (S[i] == '1' and prev == -1):
 
            # Set prev to the
            # i-th character
            prev = i
         
        # Check if prev character is 1
        # and current character is 0
        elif (S[prev] == '1' and S[i] == '0'):
 
            # Half of the * will be
            # converted to 0
            count_0 = count_0 + (i - prev - 1) / 2
 
            # Half of the * will be
            # converted to 1
            count_1 = count_1 + (i - prev - 1) // 2
            prev = i
         
        # Check if prev and current are 1
        elif (S[prev] == '1' and S[i] == '1'):
 
            # All * will get converted to 1
            count_1 = count_1 + (i - prev - 1)
            prev = i
         
        # No * can be replaced
        # by either 0 or 1
        elif (S[prev] == '0' and S[i] == '1'):
 
            # Prev becomes the ith character
            prev = i
 
        # Check if prev and current are 0
        elif (S[prev] == '0' and S[i] == '0'):
 
            # All * will get converted to 0
            count_0 = count_0 + (i - prev - 1)
            prev = i
         
    # If frequency of 0
    # is more
    if (count_0 > count_1):
        print("0")
 
    # If frequency of 1
    # is more
    elif (count_1 > count_0):
        print("1")
    else:
        print("-1")
     
# Driver code
 
# Given string
str = "**0**1***0"
 
# Function call
solve(str)
 
# This code is contributed by code_hunt

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the
// maximum occurring character
static void solve(string S)
{
     
    // Initialize count of
    // zero and one
    int count_0 = 0, count_1 = 0;
 
    int prev = -1;
 
    // Iterate over the given string
    for(int i = 0; i < S.Length; i++)
    {
         
        // Count the zeros
        if (S[i] == '0')
            count_0++;
 
        // Count the ones
        else if (S[i] == '1')
            count_1++;
    }
 
    // Iterate over the given string
    for(int i = 0; i < S.Length; i++)
    {
         
        // Check if character
        // is * then continue
        if (S[i] == '*')
            continue;
 
        // Check if first character
        // after * is X
        else if (S[i] == '0' && prev == -1)
        {
 
            // Add all * to
            // the frequency of X
            count_0 = count_0 + i;
 
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if first character
        // after * is Y
        else if (S[i] == '1' && prev == -1)
        {
             
            // Set prev to the
            // i-th character
            prev = i;
        }
 
        // Check if prev character is 1
        // and current character is 0
        else if (S[prev] == '1' && S[i] == '0')
        {
             
            // Half of the * will be
            // converted to 0
            count_0 = count_0 + (i - prev - 1) / 2;
 
            // Half of the * will be
            // converted to 1
            count_1 = count_1 + (i - prev - 1) / 2;
            prev = i;
        }
 
        // Check if prev and current are 1
        else if (S[prev] == '1' && S[i] == '1')
        {
             
            // All * will get converted to 1
            count_1 = count_1 + (i - prev - 1);
            prev = i;
        }
 
        // No * can be replaced
        // by either 0 or 1
        else if (S[prev] == '0' && S[i] == '1')
 
            // Prev becomes the ith character
            prev = i;
 
        // Check if prev and current are 0
        else if (S[prev] == '0' && S[i] == '0')
        {
             
            // All * will get converted to 0
            count_0 = count_0 + (i - prev - 1);
            prev = i;
        }
    }
 
    // If frequency of 0
    // is more
    if (count_0 > count_1)
        Console.Write("0");
 
    // If frequency of 1
    // is more
    else if (count_1 > count_0)
        Console.Write("1");
 
    else
    {
        Console.Write("-1");
    }
}
 
// Driver code
public static void Main ()
{
     
    // Given string
    string str = "**0**1***0";
 
    // Function call
    solve(str);
}
}
 
// This code is contributed by code_hunt

Javascript




<script>
// javascript program for the above approach
 
    // Function to find the
    // maximum occurring character
    function solve( S) {
 
        // Initialize count of
        // zero and one
        var count_0 = 0, count_1 = 0;
 
        var prev = -1;
 
        // Iterate over the given string
        for (i = 0; i < S.length; i++) {
 
            // Count the zeros
            if (S.charAt(i) == '0')
                count_0++;
 
            // Count the ones
            else if (S.charAt(i) == '1')
                count_1++;
        }
 
        // Iterate over the given string
        for (i = 0; i < S.length; i++) {
 
            // Check if character
            // is * then continue
            if (S.charAt(i) == '*')
                continue;
 
            // Check if first character
            // after * is X
            else if (S.charAt(i) == '0' && prev == -1) {
 
                // Add all * to
                // the frequency of X
                count_0 = count_0 + i;
 
                // Set prev to the
                // i-th character
                prev = i;
            }
 
            // Check if first character
            // after * is Y
            else if (S.charAt(i) == '1' && prev == -1) {
 
                // Set prev to the
                // i-th character
                prev = i;
            }
 
            // Check if prev character is 1
            // and current character is 0
            else if (S.charAt(prev) == '1' && S.charAt(i) == '0') {
 
                // Half of the * will be
                // converted to 0
                count_0 = count_0 + (i - prev - 1) / 2;
 
                // Half of the * will be
                // converted to 1
                count_1 = count_1 + (i - prev - 1) / 2;
                prev = i;
            }
 
            // Check if prev and current are 1
            else if (S.charAt(prev) == '1' && S.charAt(i) == '1') {
 
                // All * will get converted to 1
                count_1 = count_1 + (i - prev - 1);
                prev = i;
            }
 
            // No * can be replaced
            // by either 0 or 1
            else if (S.charAt(prev) == '0' && S.charAt(i) == '1')
 
                // Prev becomes the ith character
                prev = i;
 
            // Check if prev and current are 0
            else if (S.charAt(prev) == '0' && S.charAt(i) == '0') {
 
                // All * will get converted to 0
                count_0 = count_0 + (i - prev - 1);
                prev = i;
            }
        }
 
        // If frequency of 0
        // is more
        if (count_0 > count_1)
            document.write("0");
 
        // If frequency of 1
        // is more
        else if (count_1 > count_0)
            document.write("1");
 
        else {
            document.write("-1");
        }
    }
 
    // Driver code
        // Given string
        var str = "**0**1***0";
 
        // Function call
        solve(str);
 
// This code IS contributed by umadevi9616
</script>
Output: 
0

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!