Apply Bitwise Operations to Make Strings Equal

Apply Bitwise Operations to Make Strings Equal - Problem

Binary String Transformation Challenge

You're given two 0-indexed binary strings s and target of the same length n. Your goal is to determine if you can transform string s into the target string using a special bitwise operation.

The Operation: You can choose any two different indices i and j and simultaneously perform:
• Replace s[i] with (s[i] OR s[j])
• Replace s[j] with (s[i] XOR s[j])

Example: If s = "0110", choosing i = 0 and j = 2:
• s[0] becomes (0 OR 1) = 1
• s[2] becomes (0 XOR 1) = 1
• Result: s = "1110"

Return true if transformation is possible, false otherwise.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "1010", target = "0110"

› Output: true

💡 Note: Both strings have 2 ones, and s contains 1s, so transformation is possible. We can rearrange the 1s to match the target pattern.

example_2.py — Impossible Case

$ Input: s = "0000", target = "1111"

› Output: false

💡 Note: s has no 1s, but target has 1s. Since we cannot create 1s from all 0s using the given operations, transformation is impossible.

example_3.py — Edge Case

$ Input: s = "1111", target = "0000"

› Output: false

💡 Note: While s has 1s, we cannot eliminate all 1s to reach a target of all 0s. The operation maintains at least one 1 when starting with 1s.

Visualization

Tap to expand

Understanding the Visualization

Operation Definition

s[i] = s[i] OR s[j], s[j] = s[i] XOR s[j] simultaneously

Case Analysis

If source has no 1s: cannot create 1s. If source has 1s: can reach non-zero targets

Mathematical Proof

OR operation can only maintain or create 1s, never eliminate all 1s when they exist

Key Takeaway

🎯 Key Insight: The operation preserves the fundamental property of having 1s. We can solve this in O(n) time by simply counting 1s instead of simulating operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to analyze bit patterns

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and patterns

✓ Linear Space

Constraints

n == s.length == target.length
1 ≤ n ≤ 10⁵
s and target consist of only '0' and '1'
Both strings are binary strings of equal length

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses mathematical analysis instead of simulation. Key insight: if the source string has no '1' bits, we can never create '1' bits. If it has '1' bits, we can reach any target with '1' bits, but never an all-zero target. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Analysis (Optimal)	O(n)	O(1)	Analyze the mathematical properties of the bitwise operations

Mathematical Analysis (Optimal) — Algorithm Steps

Count the number of '1' bits in both strings
Check if source string has all zeros
If source has all zeros but target doesn't, return false
If source has at least one '1', check if we can reach target
The operation can rearrange '1' bits but has constraints

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze Operation

OR creates 1s, XOR toggles bits

Find Invariants

No 1s in source means no 1s can be created

Check Constraints

With 1s present, any non-zero pattern is reachable

Return Result

Apply the mathematical rule

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool makeStringsEqual(char* s, char* target) {
    if (strcmp(s, target) == 0) return true;
    
    int sOnes = 0, targetOnes = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        if (s[i] == '1') sOnes++;
        if (target[i] == '1') targetOnes++;
    }
    
    // If s has no 1s, we can never create 1s
    if (sOnes == 0) {
        return targetOnes == 0;
    }
    
    // If s has 1s, we can reach any target except all zeros
    return targetOnes > 0;
}

int main() {
    char s[1001], target[1001];
    scanf("%s %s", s, target);
    printf("%s\n", makeStringsEqual(s, target) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to analyze bit patterns

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and patterns

✓ Linear Space

Constraints

n == s.length == target.length
1 ≤ n ≤ 10⁵
s and target consist of only '0' and '1'
Both strings are binary strings of equal length

28.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler