Queries to flip characters of a binary string in given range

Last Updated : 21 Jun, 2021

Given a binary string, str and a 2D array Q[][] representing queries of the form {L, R}. In each query, toggle all the characters of the binary strings present in the indices [L, R]. The task is to print the binary string by performing all the queries.

Examples:

Input: str = “101010”, Q[][] = { {0, 1}, {2, 5}, {2, 3}, {1, 4}, {0, 5} }
Output: 111000
Explanation:
Query 1: Toggling all the characters of str in the indices [0, 1]. Therefore, str becomes “011010”.
Query 2: Toggling all the characters of str in the indices [2, 5]. Therefore, str becomes “010101”.
Query 3: Toggling all the characters of str in the indices [2, 3]. Therefore, str becomes “011001”.
Query 4: Toggling all the characters of str in the indices [1, 4]. Therefore, str becomes “000111”.
Query 5: Toggling all the characters of str in the indices [0, 5]. Therefore, str becomes “111000”.
Therefore, the required binary string is “111000”.

Input: str = “00101”, Q[][]={ {0, 2}, {2, 3}, {1, 4} }
Output: 10000

Naive Approach: The simplest approach to solve the problem is to traverse all the queries arrays and toggle all the characters in the indices [L, R]. Finally, print the binary string.

Time Complexity: O(M * N), Where N denotes the length of the binary string.
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach the idea is to use the Prefix Sum array technique. Follow the steps below to solve the problem:

Initialize an array, say prefixCnt[] to store the value of the number of times i^th element of the binary string toggled.
Traverse the query Q[][] array and for each query, update the value of prefixCnt[Q[i][0]] += 1 and prefixCnt[Q[i][1] + 1] -= 1.
Traverse the prefixCnt[] array and take the prefix sum of prefixCnt[] array.
Finally, traverse the binary string and check if the value of prefixCnt[i] % 2 == 1 or not. If found to be true then toggled i^th element of the binary string.

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 binary string by
// performing all the given queries
string toggleQuery(string str, int Q[][2],
                   int M)
{
 
    // Stores length of the string
    int N = str.length();
 
    // prefixCnt[i]: Stores number
    // of times str[i] toggled by
    // performing all the queries
    int prefixCnt[N + 1] = { 0 };
 
    for (int i = 0; i < M; i++) {
 
        // Update prefixCnt[Q[i][0]]
        prefixCnt[Q[i][0]] += 1;
 
        // Update prefixCnt[Q[i][1] + 1]
        prefixCnt[Q[i][1] + 1] -= 1;
    }
 
    // Calculate prefix sum of prefixCnt[i]
    for (int i = 1; i <= N; i++) {
        prefixCnt[i] += prefixCnt[i - 1];
    }
 
    // Traverse prefixCnt[] array
    for (int i = 0; i < N; i++) {
 
        // If ith element toggled
        // odd number of times
        if (prefixCnt[i] % 2) {
 
            // Toggled i-th element
            // of binary string
            str[i] = '1' - str[i] + '0';
        }
    }
    return str;
}
 
// Driver Code
int main()
{
    string str = "101010";
    int Q[][2] = { { 0, 1 }, { 2, 5 }, 
                   { 2, 3 }, { 1, 4 }, 
                   { 0, 5 } };
    int M = sizeof(Q) / sizeof(Q[0]);
    cout << toggleQuery(str, Q, M);
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to find the binary 
// String by performing all the
// given queries
static String toggleQuery(char[] str, 
                          int Q[][], int M)
{
  // Stores length of the String
  int N = str.length;
 
  // prefixCnt[i]: Stores number
  // of times str[i] toggled by
  // performing all the queries
  int prefixCnt[] = new int[N + 1];
 
  for (int i = 0; i < M; i++) 
  {
    // Update prefixCnt[Q[i][0]]
    prefixCnt[Q[i][0]] += 1;
 
    // Update prefixCnt[Q[i][1] + 1]
    prefixCnt[Q[i][1] + 1] -= 1;
  }
 
  // Calculate prefix sum of 
  // prefixCnt[i]
  for (int i = 1; i <= N; i++) 
  {
    prefixCnt[i] += prefixCnt[i - 1];
  }
 
  // Traverse prefixCnt[] array
  for (int i = 0; i < N; i++) 
  {
    // If ith element toggled
    // odd number of times
    if (prefixCnt[i] % 2 == 1) 
    {
      // Toggled i-th element
      // of binary String
      str[i] = (char)('1' - 
                str[i] + '0');
 
    }
  }
  return String.valueOf(str);
}
 
// Driver Code
public static void main(String[] args)
{
  String str = "101010";
  int Q[][] = {{0, 1}, {2, 5}, 
               {2, 3}, {1, 4}, 
               {0, 5}};
  int M = Q.length;
  System.out.print(
  toggleQuery(str.toCharArray(), 
              Q, M));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program to implement
# the above approach
 
# Function to find the binary by
# performing all the given queries
def toggleQuery(strr, Q, M):
     
    strr = [i for i in strr]
 
    # Stores length of the string
    N = len(strr)
 
    # prefixCnt[i]: Stores number
    # of times strr[i] toggled by
    # performing all the queries
    prefixCnt = [0] * (N + 1)
 
    for i in range(M):
 
        # Update prefixCnt[Q[i][0]]
        prefixCnt[Q[i][0]] += 1
 
        # Update prefixCnt[Q[i][1] + 1]
        prefixCnt[Q[i][1] + 1] -= 1
 
    # Calculate prefix sum of prefixCnt[i]
    for i in range(1, N + 1):
        prefixCnt[i] += prefixCnt[i - 1]
 
    # Traverse prefixCnt[] array
    for i in range(N):
 
        # If ith element toggled
        # odd number of times
        if (prefixCnt[i] % 2):
 
            # Toggled i-th element
            # of binary string
            strr[i] = (chr(ord('1') -
                           ord(strr[i]) +
                           ord('0')))
                            
    return "".join(strr)
 
# Driver Code
if __name__ == '__main__':
     
    strr = "101010";
    Q = [ [ 0, 1 ],[ 2, 5 ],
          [ 2, 3 ],[ 1, 4 ],
          [ 0, 5 ] ]
    M = len(Q)
 
    print(toggleQuery(strr, Q, M))
 
# This code is contributed by mohit kumar 29

C#

// C# program to implement
// the above approach
using System;
class GFG{
 
// Function to find the binary 
// String by performing all the
// given queries
static String toggleQuery(char[] str, 
                          int [,]Q ,
                          int M)
{
  // Stores length of the String
  int N = str.Length;
 
  // prefixCnt[i]: Stores number
  // of times str[i] toggled by
  // performing all the queries
  int []prefixCnt = new int[N + 1];
 
  for (int i = 0; i < M; i++) 
  {
    // Update prefixCnt[Q[i,0]]
    prefixCnt[Q[i, 0]] += 1;
 
    // Update prefixCnt[Q[i,1] + 1]
    prefixCnt[Q[i, 1] + 1] -= 1;
  }
 
  // Calculate prefix sum of 
  // prefixCnt[i]
  for (int i = 1; i <= N; i++) 
  {
    prefixCnt[i] += prefixCnt[i - 1];
  }
 
  // Traverse prefixCnt[] array
  for (int i = 0; i < N; i++) 
  {
    // If ith element toggled
    // odd number of times
    if (prefixCnt[i] % 2 == 1) 
    {
      // Toggled i-th element
      // of binary String
      str[i] = (char)('1' - 
                str[i] + '0');
 
    }
  }
  return String.Join("", str);
}
 
// Driver Code
public static void Main(String[] args)
{
  String str = "101010";
  int [,]Q = {{0, 1}, {2, 5}, 
              {2, 3}, {1, 4}, 
              {0, 5}};
  int M = Q.GetLength(0);
  Console.Write(toggleQuery(str.ToCharArray(), 
                            Q, M));
}
}
 
// This code is contributed by shikhasingrajput

Javascript

<script>
// Javascript program to implement
// the above approach
 
// Function to find the binary
// String by performing all the
// given queries
function toggleQuery(str, Q, M)
{
 
    // Stores length of the String
  let N = str.length;
  
  // prefixCnt[i]: Stores number
  // of times str[i] toggled by
  // performing all the queries
  let prefixCnt = new Array(N + 1);
  for(let i = 0; i < N + 1; i++)
  {
      prefixCnt[i] = 0;
  }
  
  for (let i = 0; i < M; i++)
  {
    // Update prefixCnt[Q[i][0]]
    prefixCnt[Q[i][0]] += 1;
  
    // Update prefixCnt[Q[i][1] + 1]
    prefixCnt[Q[i][1] + 1] -= 1;
  }
  
  // Calculate prefix sum of
  // prefixCnt[i]
  for (let i = 1; i <= N; i++)
  {
    prefixCnt[i] += prefixCnt[i - 1];
  }
  
  // Traverse prefixCnt[] array
  for (let i = 0; i < N; i++)
  {
    // If ith element toggled
    // odd number of times
    if (prefixCnt[i] % 2 == 1)
    {
      // Toggled i-th element
      // of binary String
      str[i] = String.fromCharCode('1'.charCodeAt(0) -
                str[i].charCodeAt(0) + '0'.charCodeAt(0));
  
    }
  }
  return (str).join("");
}
 
// Driver Code
let str = "101010";
let Q = [[0, 1], [2, 5],
[2, 3], [1, 4],
[0, 5]];
let M = Q.length;
document.write(
toggleQuery(str.split(""),
            Q, M));
 
// This code is contributed by patel2127
</script>

Output:

Time Complexity: O(N + |Q|), Where N is the length of binary string.
Auxiliary Space: O(N)

Count of substrings of a given Binary string with all characters same

aaryaverma112

Improve

Article Tags :

Practice Tags :

Queries to flip characters of a binary string in given range

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?