Apply Bitwise Operations to Make Strings Equal

Apply Bitwise Operations to Make Strings Equal - Problem

You are given two 0-indexed binary strings s and target of the same length n. You can do the following operation on s any number of times:

Choose two different indices i and j where 0 <= i, j < n.

Simultaneously replace s[i] with (s[i] OR s[j]) and s[j] with (s[i] XOR s[j]).

For example, if s = "0110", you can choose i = 0 and j = 2, then simultaneously replace s[0] with (s[0] OR s[2] = 0 OR 1 = 1), and s[2] with (s[0] XOR s[2] = 0 XOR 1 = 1), so we will have s = "1110".

Return true if you can make the string s equal to target, or false otherwise.

Input & Output

Example 1 — Basic Transformation

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

› Output: true

💡 Note: Choose i=1, j=2: s[1] OR s[2] = 1|1 = 1, s[1] XOR s[2] = 1^1 = 0. Result: "1100"

Example 2 — Impossible Case

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

› Output: false

💡 Note: Since s has no 1s, we cannot create any 1s using OR/XOR operations

Example 3 — Already Equal

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

› Output: true

💡 Note: s already equals target, no operations needed

Constraints

1 ≤ s.length ≤ 10⁵
s.length == target.length
s and target consist of only '0' and '1'

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 8

The key insight is that OR operations can only create or maintain 1s, never eliminate them. If the source string has no 1s, we can only reach targets with no 1s. If source has 1s, we can reach most targets except the special case of all-1s target from non-all-1s source. Best approach is Mathematical Analysis with Time: O(n), Space: O(1).

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Bit Manipulation

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(2^n) Space: O(2^n)

Generate all possible operation sequences and check if any sequence transforms s into target. This involves trying every pair of indices with OR/XOR operations.

Mathematical Analysis

⏱️ Time: O(n) Space: O(1)

Instead of trying all operations, analyze what the OR/XOR operations can and cannot achieve. The key insight is that certain invariants are preserved.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool solution(const char* s, const char* target) {
    // Key insight: OR operation can only increase or maintain 1s, never decrease
    // XOR can flip bits but the OR component ensures we can generate 1s
    // If target has more 1s than s, and s has at least one 1, we can reach target
    // If s has no 1s, we cannot generate any 1s
    
    int countS = 0;
    int countTarget = 0;
    int lenS = strlen(s);
    int lenTarget = strlen(target);
    
    for (int i = 0; i < lenS; i++) {
        if (s[i] == '1') countS++;
    }
    
    for (int i = 0; i < lenTarget; i++) {
        if (target[i] == '1') countTarget++;
    }
    
    // If s has no 1s, we can only reach target if target also has no 1s
    if (countS == 0) {
        return countTarget == 0;
    }
    
    // If s has at least one 1, we can reach any target with same or more 1s
    // except the all-1s case when s is not all-1s
    if (countTarget == lenTarget && countS < lenS) {
        return false;
    }
    
    return true;
}

int main() {
    char s[1001];
    char target[1001];
    
    fgets(s, sizeof(s), stdin);
    fgets(target, sizeof(target), stdin);
    
    // Remove newline characters
    s[strcspn(s, "\n")] = 0;
    target[strcspn(target, "\n")] = 0;
    
    bool result = solution(s, target);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

387 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