Skip to content
Related Articles

Related Articles

Queries to flip characters of a binary string in given range
  • Last Updated : 18 Nov, 2020

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:

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 strring
    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 strring
            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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output: 

111000







 

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

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :