Check if Strings Can be Made Equal With Operations II

Check if Strings Can be Made Equal With Operations II - Problem

You are given two strings s1 and s2 of equal length n, both consisting of lowercase English letters.

Your mission is to determine if you can transform either string into the other using a special swapping operation. You can perform this operation any number of times on either string:

Operation: Choose any two indices i and j where i < j and the difference j - i is even, then swap the characters at positions i and j.

The key insight is that this constraint creates two separate "groups" within each string:

Even positions: 0, 2, 4, 6, ... (can only swap with other even positions)
Odd positions: 1, 3, 5, 7, ... (can only swap with other odd positions)

Return true if the strings can be made equal, false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: s1 = "abcdxyz", s2 = "cbadfgh"

› Output: false

💡 Note: Even positions: s1 has [a,c,x,z], s2 has [c,a,f,h]. The characters f,h,x,z don't match between the two groups, so no amount of swapping can make them equal.

example_2.py — Successful Match

$ Input: s1 = "abcd", s2 = "cdab"

› Output: true

💡 Note: Even positions: s1 has [a,c], s2 has [c,a]. Odd positions: s1 has [b,d], s2 has [d,b]. Both groups have matching character frequencies, so we can swap within each group to make strings equal.

example_3.py — Edge Case

$ Input: s1 = "ab", s2 = "ba"

› Output: false

💡 Note: Even positions: s1 has [a] at position 0, s2 has [b] at position 0. Odd positions: s1 has [b] at position 1, s2 has [a] at position 1. Since characters at even and odd positions can't be swapped with each other, these strings cannot be made equal.

Constraints

1 ≤ n ≤ 10⁵ where n is the length of both strings
Both strings consist of lowercase English letters only
s1.length == s2.length (equal length guaranteed)

Visualization

Tap to expand

Understanding the Visualization

Identify the Constraint

Positions 0,2,4,... form one group, positions 1,3,5,... form another

Apply the Insight

Characters can only swap within their position parity group

Count Frequencies

For each group, count character frequencies in both strings

Compare Groups

Strings can be equal if and only if both groups have matching frequency distributions

Key Takeaway

🎯 Key Insight: The even-odd position constraint creates two independent groups. Strings can be made equal if and only if both groups have identical character frequency distributions!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The key insight is that characters can only be swapped within positions of the same parity (even with even, odd with odd). The optimal solution uses a one-pass frequency difference approach that tracks character count differences between the two strings separately for even and odd positions, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Frequency Check (Optimal)	O(n)	O(1)	Count and compare character frequencies for even/odd positions in a single pass
Two-Pass Character Frequency	O(n)	O(1)	Count character frequencies at even/odd positions separately for both strings
Brute Force (Try All Swaps)	O(n! × n)	O(n! × n)	Recursively try all possible valid swaps until strings match or exhaust possibilities

One-Pass Frequency Check (Optimal) — Algorithm Steps

Initialize frequency difference maps for even and odd positions
Iterate through both strings simultaneously
For each position i: increment freq[s1[i]] and decrement freq[s2[i]]
Use separate maps based on position parity (even/odd)
Check if all frequency differences are zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create difference maps for even and odd positions

Process Each Position

+1 for s1[i], -1 for s2[i] in appropriate map

Track Differences

Maintain running difference of character frequencies

Verify Zero Differences

All differences must be zero for equality

Code -

solution.c — C

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

bool canBeEqual(char* s1, char* s2) {
    int n = strlen(s1);
    if (n != strlen(s2)) return false;
    
    // Character frequency difference arrays (26 lowercase letters)
    int evenDiff[26] = {0}, oddDiff[26] = {0};
    
    // Single pass: count differences
    for (int i = 0; i < n; i++) {
        int idx1 = s1[i] - 'a';
        int idx2 = s2[i] - 'a';
        
        if (i % 2 == 0) { // Even position
            evenDiff[idx1]++;
            evenDiff[idx2]--;
        } else { // Odd position
            oddDiff[idx1]++;
            oddDiff[idx2]--;
        }
    }
    
    // Check if all differences are zero
    for (int i = 0; i < 26; i++) {
        if (evenDiff[i] != 0 || oddDiff[i] != 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through strings of length n, plus O(1) time to verify all frequencies are zero

✓ Linear Growth

Space Complexity

O(1)

Hash tables store at most 26 lowercase letters each, which is constant space

✓ Linear Space

42.0K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Frequency Check (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler