📌  相关文章
📜  替换二进制字符串中所有出现的 X 后字符串出现频率最高的字符

📅  最后修改于: 2021-09-07 02:34:09             🧑  作者: Mango

给定一个由10X组成的长度为N的字符串S ,任务是在按照以下条件替换每次出现的X后以最大频率打印字符( ‘1’ 或 ‘0’ ):

  • 如果存在邻接X左侧的字符为1,1代替X。
  • 如果存在邻接X右侧的字符是0,其中0替换X。
  • 如果上述两个条件都满足,则X保持不变。

注意:如果替换后10的频率相同,则打印X

例子:

方法:根据以下观察可以解决给定的问题:

  • 所有位于‘1’‘0’之间的‘X’ (例如1XXX0 )都没有意义,因为‘1’‘0’都不能转换它。
  • 位于‘0’‘1’之间所有‘X’ (例如0XXX1 )也没有意义,因为它对10 的贡献相同。考虑形式为“0X….X1”的任何子串,然后在从字符串的开头结尾更改X的第一次出现后,子串中01的实际频率保持不变。

从以上观察可以得出结论,结果取决于以下条件:

  • 原始字符串中“1”“0”的计数。
  • X出现在两个连续0或两个连续1之间的频率,即分别为“0XXX0”“1XXXX1”
  • 出现在字符串开头且右端为‘1’的连续‘X’的数量,即“XXXX1…..”
  • 出现在字符串且左端为‘0’的连续‘X’的数量,即…..0XXX

因此,根据上述条件计算1 s 和0 s 的数量并打印结果计数。

下面是上述方法的实现:

C++
// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the most frequent
// character after replacing X with
// either '0' or '1' according as per
// the given conditions
void maxOccuringCharacter(string s)
{
 
    // Store the count of 0s and
    // 1s in the string S
    int count0 = 0, count1 = 0;
 
    // Count the frequency of
    // 0 and 1
    for (int i = 0; i < s.length(); i++) {
 
        // If the character is 1
        if (s[i] == '1') {
            count1++;
        }
 
        // If the character is 0
        else if (s[i] == '0') {
            count0++;
        }
    }
 
    // Stores first occurence of 1
    int prev = -1;
    for (int i = 0; i < s.length(); i++) {
 
        if (s[i] == '1') {
            prev = i;
            break;
        }
    }
 
    // Traverse the string to count
    // the number of X between two
    // consecutive 1s
    for (int i = prev + 1; i < s.length(); i++) {
 
        // If the current character
        // is not X
        if (s[i] != 'X') {
 
            // If the current character
            // is 1, add the number of
            // Xs to count1 and set
            // prev to i
            if (s[i] == '1') {
                count1 += i - prev - 1;
                prev = i;
            }
 
            // Otherwise
            else {
 
                // Find next occurence
                // of 1 in the string
                bool flag = true;
 
                for (int j = i + 1; j < s.length(); j++) {
                    if (s[j] == '1') {
                        flag = false;
                        prev = j;
                        break;
                    }
                }
 
                // If it is found,
                // set i to prev
                if (!flag) {
                    i = prev;
                }
 
                // Otherwise, break
                // out of the loop
                else {
                    i = s.length();
                }
            }
        }
    }
 
    // Store the first occurence of 0
    prev = -1;
    for (int i = 0; i < s.length(); i++) {
 
        if (s[i] == '0') {
            prev = i;
            break;
        }
    }
 
    // Repeat the same procedure to
    // count the number of X between
    // two consecutive 0s
    for (int i = prev + 1; i < s.length(); i++) {
 
        // If the current character is not X
        if (s[i] != 'X') {
 
            // If the current character is 0
            if (s[i] == '0') {
 
                // Add the count of Xs to count0
                count0 += i - prev - 1;
 
                // Set prev to i
                prev = i;
            }
 
            // Otherwise
            else {
 
                // Find the next occurence
                // of 0 in the string
                bool flag = true;
 
                for (int j = i + 1; j < s.length(); j++) {
 
                    if (s[j] == '0') {
                        prev = j;
                        flag = false;
                        break;
                    }
                }
 
                // If it is found,
                // set i to prev
                if (!flag) {
                    i = prev;
                }
 
                // Otherwise, break out
                // of the loop
                else {
                    i = s.length();
                }
            }
        }
    }
 
    // Count number of X present in
    // the starting of the string
    // as XXXX1...
    if (s[0] == 'X') {
 
        // Store the count of X
        int count = 0;
        int i = 0;
        while (s[i] == 'X') {
            count++;
            i++;
        }
 
        // Increment count1 by
        // count if the condition
        // is satisfied
        if (s[i] == '1') {
            count1 += count;
        }
    }
 
    // Count the number of X
    // present in the ending of
    // the string as ...XXXX0
    if (s[(s.length() - 1)] == 'X') {
 
        // Store the count of X
        int count = 0;
        int i = s.length() - 1;
        while (s[i] == 'X') {
            count++;
            i--;
        }
 
        // Increment count0 by
        // count if the condition
        // is satisfied
        if (s[i] == '0') {
            count0 += count;
        }
    }
 
    // If count of 1 is equal to
    // count of 0, print X
    if (count0 == count1) {
        cout << "X" << endl;
    }
 
    // Otherwise, if count of 1
    // is greater than count of 0
    else if (count0 > count1) {
        cout << 0 << endl;
    }
 
    // Otherwise, print 0
    else
        cout << 1 << endl;
}
 
// Driver Code
int main()
{
    string S = "XX10XX10XXX1XX";
    maxOccuringCharacter(S);
}
 
// This code is contributed by SURENDAR_GANGWAR.


Java
// Java program for the above approach
import java.io.*;
 
class GFG {
 
    // Function to find the most frequent
    // character after replacing X with
    // either '0' or '1' according as per
    // the given conditions
    public static void
    maxOccuringCharacter(String s)
    {
        // Store the count of 0s and
        // 1s in the string S
        int count0 = 0, count1 = 0;
 
        // Count the frequency of
        // 0 and 1
        for (int i = 0;
             i < s.length(); i++) {
 
            // If the character is 1
            if (s.charAt(i) == '1') {
                count1++;
            }
 
            // If the character is 0
            else if (s.charAt(i) == '0') {
                count0++;
            }
        }
 
        // Stores first occurence of 1
        int prev = -1;
 
        for (int i = 0;
             i < s.length(); i++) {
 
            if (s.charAt(i) == '1') {
                prev = i;
                break;
            }
        }
 
        // Traverse the string to count
        // the number of X between two
        // consecutive 1s
        for (int i = prev + 1;
             i < s.length(); i++) {
 
            // If the current character
            // is not X
            if (s.charAt(i) != 'X') {
 
                // If the current character
                // is 1, add the number of
                // Xs to count1 and set
                // prev to i
                if (s.charAt(i) == '1') {
                    count1 += i - prev - 1;
                    prev = i;
                }
 
                // Otherwise
                else {
 
                    // Find next occurence
                    // of 1 in the string
                    boolean flag = true;
 
                    for (int j = i + 1;
                         j < s.length();
                         j++) {
                        if (s.charAt(j) == '1') {
                            flag = false;
                            prev = j;
                            break;
                        }
                    }
 
                    // If it is found,
                    // set i to prev
                    if (!flag) {
                        i = prev;
                    }
 
                    // Otherwise, break
                    // out of the loop
                    else {
                        i = s.length();
                    }
                }
            }
        }
 
        // Store the first occurence of 0
        prev = -1;
        for (int i = 0; i < s.length(); i++) {
 
            if (s.charAt(i) == '0') {
                prev = i;
                break;
            }
        }
 
        // Repeat the same procedure to
        // count the number of X between
        // two consecutive 0s
        for (int i = prev + 1;
             i < s.length(); i++) {
 
            // If the current character is not X
            if (s.charAt(i) != 'X') {
 
                // If the current character is 0
                if (s.charAt(i) == '0') {
 
                    // Add the count of Xs to count0
                    count0 += i - prev - 1;
 
                    // Set prev to i
                    prev = i;
                }
 
                // Otherwise
                else {
 
                    // Find the next occurence
                    // of 0 in the string
                    boolean flag = true;
 
                    for (int j = i + 1;
                         j < s.length(); j++) {
 
                        if (s.charAt(j) == '0') {
                            prev = j;
                            flag = false;
                            break;
                        }
                    }
 
                    // If it is found,
                    // set i to prev
                    if (!flag) {
                        i = prev;
                    }
 
                    // Otherwise, break out
                    // of the loop
                    else {
                        i = s.length();
                    }
                }
            }
        }
 
        // Count number of X present in
        // the starting of the string
        // as XXXX1...
        if (s.charAt(0) == 'X') {
 
            // Store the count of X
            int count = 0;
            int i = 0;
            while (s.charAt(i) == 'X') {
                count++;
                i++;
            }
 
            // Increment count1 by
            // count if the condition
            // is satisfied
            if (s.charAt(i) == '1') {
                count1 += count;
            }
        }
 
        // Count the number of X
        // present in the ending of
        // the string as ...XXXX0
        if (s.charAt(s.length() - 1)
            == 'X') {
 
            // Store the count of X
            int count = 0;
            int i = s.length() - 1;
            while (s.charAt(i) == 'X') {
                count++;
                i--;
            }
 
            // Increment count0 by
            // count if the condition
            // is satisfied
            if (s.charAt(i) == '0') {
                count0 += count;
            }
        }
 
        // If count of 1 is equal to
        // count of 0, print X
        if (count0 == count1) {
            System.out.println("X");
        }
 
        // Otherwise, if count of 1
        // is greater than count of 0
        else if (count0 > count1) {
            System.out.println(0);
        }
 
        // Otherwise, print 0
        else
            System.out.println(1);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        String S = "XX10XX10XXX1XX";
        maxOccuringCharacter(S);
    }
}


Python3
# Python program for the above approach
 
# Function to find the most frequent
# character after replacing X with
# either '0' or '1' according as per
# the given conditions
def maxOccuringCharacter(s):
   
  # Store the count of 0s and
  # 1s in the S
  count0 = 0
  count1 = 0
 
  # Count the frequency of
  # 0 and 1
  for i in range(len(s)):
 
    # If the character is 1
    if (s[i] == '1') :
      count1 += 1
     
    # If the character is 0
    elif (s[i] == '0') :
      count0 += 1
     
  # Stores first occurence of 1
  prev = -1
  for i in range(len(s)):
    if (s[i] == '1') :
      prev = i
      break
     
  # Traverse the to count
  # the number of X between two
  # consecutive 1s
  for i in range(prev + 1, len(s)):
 
    # If the current character
    # is not X
    if (s[i] != 'X') :
 
      # If the current character
      # is 1, add the number of
      # Xs to count1 and set
      # prev to i
      if (s[i] == '1') :
        count1 += i - prev - 1
        prev = i
       
      # Otherwise
      else :
 
        # Find next occurence
        # of 1 in the string
        flag = True
        for j in range(i+1, len(s)):
          if (s[j] == '1') :
            flag = False
            prev = j
            break
           
        # If it is found,
        # set i to prev
        if (flag == False) :
          i = prev
         
        # Otherwise, break
        # out of the loop
        else :
          i = len(s)
         
  # Store the first occurence of 0
  prev = -1
  for i in range(0, len(s)):
 
    if (s[i] == '0') :
      prev = i
      break
     
  # Repeat the same procedure to
  # count the number of X between
  # two consecutive 0s
  for i in range(prev + 1, len(s)):
 
    # If the current character is not X
    if (s[i] != 'X') :
 
      # If the current character is 0
      if (s[i] == '0') :
 
        # Add the count of Xs to count0
        count0 += i - prev - 1
 
        # Set prev to i
        prev = i
       
      # Otherwise
      else :
 
        # Find the next occurence
        # of 0 in the string
        flag = True
 
        for j in range(i + 1, len(s)):
          if (s[j] == '0') :
            prev = j
            flag = False
            break
          
        # If it is found,
        # set i to prev
        if (flag == False) :
          i = prev
         
        # Otherwise, break out
        # of the loop
        else :
          i = len(s)
        
  # Count number of X present in
  # the starting of the string
  # as XXXX1...
  if (s[0] == 'X') :
 
    # Store the count of X
    count = 0
    i = 0
    while (s[i] == 'X') :
      count += 1
      i += 1
     
    # Increment count1 by
    # count if the condition
    # is satisfied
    if (s[i] == '1') :
      count1 += count
    
  # Count the number of X
  # present in the ending of
  # the as ...XXXX0
  if (s[(len(s) - 1)]
      == 'X') :
 
    # Store the count of X
    count = 0
    i = len(s) - 1
    while (s[i] == 'X') :
      count += 1
      i -= 1
     
    # Increment count0 by
    # count if the condition
    # is satisfied
    if (s[i] == '0') :
      count0 += count
     
  # If count of 1 is equal to
  # count of 0, prX
  if (count0 == count1) :
    print("X")
   
  # Otherwise, if count of 1
  # is greater than count of 0
  elif (count0 > count1) :
    print( 0 )
   
  # Otherwise, pr0
  else:
    print(1)
 
# Driver Code
 
S = "XX10XX10XXX1XX"
maxOccuringCharacter(S)
 
# This code is contributed by sanjoy_62.


C#
// C# program for the above approach
using System;
public class GFG
{
 
  // Function to find the most frequent
  // character after replacing X with
  // either '0' or '1' according as per
  // the given conditions
  public static void maxOccuringCharacter(string s)
  {
 
    // Store the count of 0s and
    // 1s in the string S
    int count0 = 0, count1 = 0;
 
    // Count the frequency of
    // 0 and 1
    for (int i = 0;
         i < s.Length; i++) {
 
      // If the character is 1
      if (s[i] == '1') {
        count1++;
      }
 
      // If the character is 0
      else if (s[i] == '0') {
        count0++;
      }
    }
 
    // Stores first occurence of 1
    int prev = -1;
 
    for (int i = 0;
         i < s.Length; i++) {
 
      if (s[i] == '1') {
        prev = i;
        break;
      }
    }
 
    // Traverse the string to count
    // the number of X between two
    // consecutive 1s
    for (int i = prev + 1;
         i < s.Length; i++) {
 
      // If the current character
      // is not X
      if (s[i] != 'X') {
 
        // If the current character
        // is 1, add the number of
        // Xs to count1 and set
        // prev to i
        if (s[i] == '1') {
          count1 += i - prev - 1;
          prev = i;
        }
 
        // Otherwise
        else {
 
          // Find next occurence
          // of 1 in the string
          bool flag = true;
 
          for (int j = i + 1;
               j < s.Length;
               j++) {
            if (s[j] == '1') {
              flag = false;
              prev = j;
              break;
            }
          }
 
          // If it is found,
          // set i to prev
          if (!flag) {
            i = prev;
          }
 
          // Otherwise, break
          // out of the loop
          else {
            i = s.Length;
          }
        }
      }
    }
 
    // Store the first occurence of 0
    prev = -1;
    for (int i = 0; i < s.Length; i++) {
 
      if (s[i] == '0') {
        prev = i;
        break;
      }
    }
 
    // Repeat the same procedure to
    // count the number of X between
    // two consecutive 0s
    for (int i = prev + 1;
         i < s.Length; i++) {
 
      // If the current character is not X
      if (s[i] != 'X') {
 
        // If the current character is 0
        if (s[i] == '0') {
 
          // Add the count of Xs to count0
          count0 += i - prev - 1;
 
          // Set prev to i
          prev = i;
        }
 
        // Otherwise
        else {
 
          // Find the next occurence
          // of 0 in the string
          bool flag = true;
 
          for (int j = i + 1;
               j < s.Length; j++) {
 
            if (s[j] == '0') {
              prev = j;
              flag = false;
              break;
            }
          }
 
          // If it is found,
          // set i to prev
          if (!flag) {
            i = prev;
          }
 
          // Otherwise, break out
          // of the loop
          else {
            i = s.Length;
          }
        }
      }
    }
 
    // Count number of X present in
    // the starting of the string
    // as XXXX1...
    if (s[0] == 'X') {
 
      // Store the count of X
      int count = 0;
      int i = 0;
      while (s[i] == 'X') {
        count++;
        i++;
      }
 
      // Increment count1 by
      // count if the condition
      // is satisfied
      if (s[i] == '1') {
        count1 += count;
      }
    }
 
    // Count the number of X
    // present in the ending of
    // the string as ...XXXX0
    if (s[s.Length - 1]
        == 'X') {
 
      // Store the count of X
      int count = 0;
      int i = s.Length - 1;
      while (s[i] == 'X') {
        count++;
        i--;
      }
 
      // Increment count0 by
      // count if the condition
      // is satisfied
      if (s[i] == '0') {
        count0 += count;
      }
    }
 
    // If count of 1 is equal to
    // count of 0, print X
    if (count0 == count1) {
      Console.WriteLine("X");
    }
 
    // Otherwise, if count of 1
    // is greater than count of 0
    else if (count0 > count1) {
      Console.WriteLine(0);
    }
 
    // Otherwise, print 0
    else
      Console.WriteLine(1);
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    string S = "XX10XX10XXX1XX";
    maxOccuringCharacter(S);
  }
}
 
// This code is contributed by AnkThon


Javascript


输出:
1

时间复杂度: O(N)
辅助空间: O(1)

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live