Leetcode_Sol

LeetCode 2839: Check Strings Equal (Easy Explanation + Code)

by

Problem Summary

You are given two strings s1 and s2, both of length 4.

You can perform the following operation any number of times:

  • Swap characters at indices:
    • 0 ↔ 2
    • 1 ↔ 3

Return true if you can make s1 equal to s2, otherwise false.

🔍 Key Observation

The allowed swaps create two independent groups of indices:

  • Group 1: {0, 2}
  • Group 2: {1, 3}

Within each group, characters can be freely swapped, but cannot move between groups.

👉 That means:

  • Characters at indices {0, 2} in s1 must match those in s2
  • Characters at indices {1, 3} in s1 must match those in s2

💡 Core Idea

Instead of simulating swaps, we:

  1. Compare characters in the same groups
  2. Sort or count them
  3. Check if both groups match between s1 and s2

✅ Approach

Step-by-step:

  1. Extract characters:
    • group1_s1 = [s1[0], s1[2]]
    • group2_s1 = [s1[1], s1[3]]
  2. Do the same for s2
  3. Sort both groups and compare

🧠 Why Sorting Works

Since we can swap freely inside a group, only the multiset (frequency) matters—not order.

🧾 Code Implementation

Python

class Solution:
    def canBeEqual(self, s1: str, s2: str) -> bool:
        return (
            sorted([s1[0], s1[2]]) == sorted([s2[0], s2[2]]) and
            sorted([s1[1], s1[3]]) == sorted([s2[1], s2[3]])
        )

Java

class Solution {
    public boolean canBeEqual(String s1, String s2) {
        char[] g1_s1 = {s1.charAt(0), s1.charAt(2)};
        char[] g1_s2 = {s2.charAt(0), s2.charAt(2)};
        char[] g2_s1 = {s1.charAt(1), s1.charAt(3)};
        char[] g2_s2 = {s2.charAt(1), s2.charAt(3)};        Arrays.sort(g1_s1);
        Arrays.sort(g1_s2);
        Arrays.sort(g2_s1);
        Arrays.sort(g2_s2);        return Arrays.equals(g1_s1, g1_s2) && Arrays.equals(g2_s1, g2_s2);
    }
}

C++

class Solution {
public:
    bool canBeEqual(string s1, string s2) {
        vector<char> g1_s1 = {s1[0], s1[2]};
        vector<char> g1_s2 = {s2[0], s2[2]};
        vector<char> g2_s1 = {s1[1], s1[3]};
        vector<char> g2_s2 = {s2[1], s2[3]};        sort(g1_s1.begin(), g1_s1.end());
        sort(g1_s2.begin(), g1_s2.end());
        sort(g2_s1.begin(), g2_s1.end());
        sort(g2_s2.begin(), g2_s2.end());        return g1_s1 == g1_s2 && g2_s1 == g2_s2;
    }
};

⏱️ Complexity Analysis

  • Time Complexity: O(1)
    (Only 4 characters → constant work)
  • Space Complexity: O(1)

🧪 Example

Input

s1 = "abcd"
s2 = "cdab"

Explanation

  • Group1: a, c → matches c, a
  • Group2: b, d → matches d, b

✅ Output: true

🚀 Takeaway

This problem is not about simulating swaps—it’s about recognizing index grouping constraints.

Once you see the pattern:

“Swaps only within fixed index sets”

👉 It reduces to a simple group comparison problem.

Leave a Comment