Count valid Bitwise operation combinations for Binary Strings

Last Updated : 07 Nov, 2023

Given an odd integer N (N >= 3), a binary string S of length N and another string O of length (N-1)/2. Here, each character in string O can be one of the following: ‘&’, ‘|’ or ‘^’ representing Bitwise operations AND, OR, and XOR respectively, the task is to find the number of possible combinations for string O that satisfies the following conditions:

S[2] = S[0] O[0] S[1]
S[4] = S[2] O[1] S[3]
S[6] = S[4] O[2] S[5]
And so on, up to the last valid index of S.

Note: Output can be very large so modulo it by (10^9 + 7).

Examples:

Input: “110”
Output: 1
Explanation: The only operation string that satisfies the conditions is “^”. S[0] ^ S[1] = S[2], that is 1 ^ 1 = 0

Input: “10101″
Output: 4
Explanation: There can be four possible strings. They are:

“^^” : S[0] ^ S[1] = S[2], that is 1 ^ 0 = 1 and S[2] ^ S[3] = S[4], that is 1 ^ 0 = 1

“^|” : S[0] ^ S[1] = S[2], that is 1 ^ 0 = 1 and S[2] | S[3] = S[4], that is 1 | 0 = 1

“|^” : S[0] | S[1] = S[2], that is 1 | 0 = 1 and S[2] ^ S[3] = S[4], that is 1 ^ 0 = 1

“||” : S[0] | S[1] = S[2], that is 1 | 0 = 1 and S[2] | S[3] = S[4], that is 1 | 0 = 1

Approach: To solve the problem follow the below idea:

The problem can be solved by using a combination based approach where at every index i (i >= 2 and i is odd), we multiply our answer with the number of possible operators which we can use between S[i-2] and S[i-1] to get S[i]. Suppose, if at any index i, the possible operators are ‘^’ and ‘&’, then we multiply our answer with 2 and so on.

Below are the steps to solve the problem:

Initialize a variable ans = 1 to store the number of possible strings for O.
Iterate over the string S starting from index i = 2.
- Maintain a variable cnt = 0, to count the number of possible operators for that index.
- Check if we can use Bitwise AND for this iteration. If yes, increment cnt by 1.
- Check if we can use Bitwise OR for this iteration. If yes, increment cnt by 1.
- Check if we can use Bitwise XOR for this iteration. If yes, increment cnt by 1.
- Multiply ans by cnt.
- Increment index i by 2.
Return ans to get the number of all possible combinations for string O.

Below is the implementation for the above approach:

C++

// C++ Code for the above approach:
 
#include <bits/stdc++.h>
using namespace std;
 
// MOD value
const int MOD = 1e9 + 7;
 
// Function to process the string
long long getCount(string s)
{
 
    // Variable to store the number of
    // possible strings O
    long long ans = 1;
 
    // Iterate over string S starting
    // from index 2
    for (int i = 2; i < s.length(); i += 2) {
 
        // Store the operands as integers
        int x = s[i - 2] - '0';
        int y = s[i - 1] - '0';
        int z = s[i] - '0';
 
        // We need every equation as x # y = z
        // where # is any operator of {&, |, ^}
 
        // Variable to store the number of
        // valid operators
        int cnt = 0;
 
        // Bitwise-and '&'
        cnt += (x & y) == z;
 
        // Bitwise-or '|'
        cnt += (x | y) == z;
 
        // Bitwise-xor '^'
        cnt += (x ^ y) == z;
 
        // Combinations of the operators
        ans *= cnt;
        ans %= MOD;
    }
    return ans;
}
 
// Drivers code
int main()
{
 
    string s1 = "110";
    string s2 = "10101";
 
    // Function call to get the
    // count of strings
    cout << getCount(s1) << '\n';
    cout << getCount(s2) << '\n';
    return 0;
}

Java

// Java Code for the above approach
 
import java.io.*;
import java.util.*;
 
public class GFG {
 
    // MOD value
    static final int MOD = 1000000007;
 
    // Function to process the string
    static long getCount(String s)
    {
        // variable to store the number of
        // possible strings O
        long ans = 1;
 
        // Iterate over the string S starting
        // from index 2
        for (int i = 2; i < s.length(); i += 2) {
            // Store the operands as ints
            int x = s.charAt(i - 2) - '0';
            int y = s.charAt(i - 1) - '0';
            int z = s.charAt(i) - '0';
 
            // We need every equation as x # y = z
            // where # is any operator of {&, |, ^}
 
            // variable to store the number of
            // valid operators
            int cnt = 0;
 
            // Bitwise-and '&'
            cnt += ((x & y) == z) ? 1 : 0;
 
            // Bitwise-or '|'
            cnt += ((x | y) == z) ? 1 : 0;
 
            // Bitwise-xor '^'
            cnt += ((x ^ y) == z) ? 1 : 0;
 
            // Combinations of the operators
            ans *= cnt;
            ans %= MOD;
        }
        return ans;
    }
 
    public static void main(String[] args)
    {
 
        String s1 = "110";
        String s2 = "10101";
 
        // Function call to get the
        // count of strings
        System.out.println(getCount(s1));
        System.out.println(getCount(s2));
    }
}

Python3

# Python Code for the above approach:
 
MOD = 10**9 + 7
 
# Function to process the string
 
 
def get_count(s):
    # variable to store the number of
    # possible strings O
    ans = 1
    # Iterate over the string S starting
    # from index 2
    for i in range(2, len(s), 2):
 
        # Store the operands as ints
        x = int(s[i - 2])
        y = int(s[i - 1])
        z = int(s[i])
        # We need every equation as x # y = z
        # where # is any operator of {&, |, ^}
 
        # variable to store the number of
        # valid operators
        cnt = 0
 
        # Bitwise-and '&'
        cnt += (x & y) == z
 
        # Bitwise-or '|'
        cnt += (x | y) == z
 
        # Bitwise-xor '^'
        cnt += (x ^ y) == z
 
        # Combinations of the operators
        ans *= cnt
        ans %= MOD
    return ans
 
 
s1 = "110"
s2 = "10101"
 
# Function call to get the count of strings
print(get_count(s1))
print(get_count(s2))

C#

// C# Code for the above approach
 
using System;
 
public class GFG {
 
    // MOD value
    const int MOD = 1000000007;
 
    // Function to process the string
    static long getCount(string s)
    {
        // variable to store the number of
        // possible strings O
        long ans = 1;
 
        // Iterate over the string S starting
        // from index 2
        for (int i = 2; i < s.Length; i += 2) {
            // Store the operands as ints
            int x = s[i - 2] - '0';
            int y = s[i - 1] - '0';
            int z = s[i] - '0';
 
            // We need every equation as x # y = z
            // where # is any operator of {&, |, ^}
 
            // variable to store the number of
            // valid operators
            int cnt = 0;
 
            // Bitwise-and '&'
            cnt += ((x & y) == z) ? 1 : 0;
 
            // Bitwise-or '|'
            cnt += ((x | y) == z) ? 1 : 0;
 
            // Bitwise-xor '^'
            cnt += ((x ^ y) == z) ? 1 : 0;
 
            // Combinations of the operators
            ans *= cnt;
            ans %= MOD;
        }
        return ans;
    }
 
    public static void Main()
    {
 
        string s1 = "110";
        string s2 = "10101";
 
        // Function call to get the
        // count of strings
        Console.WriteLine(getCount(s1));
        Console.WriteLine(getCount(s2));
    }
}
 
// This code is contributed by ragul21

Javascript

// Javascript Code for the above approach:
 
// Function to process the string
function getCount(s) {
    // Variable to store the number of possible strings O
    let ans = 1;
 
    // Iterate over the string S starting from index 2
    for (let i = 2; i < s.length; i += 2) {
        // Store the operands as integers
        const x = parseInt(s[i - 2]);
        const y = parseInt(s[i - 1]);
        const z = parseInt(s[i]);
 
        // We need every equation as x # y = z
        // where # is any operator of {&, |, ^}
 
        // Variable to store the number of valid operators
        let cnt = 0;
 
        // Bitwise-and '&'
        cnt += (x & y) === z ? 1 : 0;
 
        // Bitwise-or '|'
        cnt += (x | y) === z ? 1 : 0;
 
        // Bitwise-xor '^'
        cnt += (x ^ y) === z ? 1 : 0;
 
        // Combinations of the operators
        ans *= cnt;
        ans %= 1000000007; // MOD value
    }
    return ans;
}
 
const s1 = "110";
const s2 = "10101";
 
// Function call to get the count of strings
console.log(getCount(s1));
console.log(getCount(s2));

Output

1
4

Time Complexity: O(N), where N is the length of string S.
Auxiliary Space: O(1)

srihari2222

Improve

Bitwise OR of N binary strings

Count valid Bitwise operation combinations for Binary Strings

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?