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.

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.

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!