Check if Strings Can be Made Equal With Operations I

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

String Easy

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

Your task is to determine if you can make these strings identical using a special swap operation. You can perform the following operation any number of times on either string:

Choose any two indices i and j such that j - i = 2 (exactly 2 positions apart)
Swap the characters at positions i and j

Example: In string "abcd", you can swap positions 0 and 2 (characters 'a' and 'c') or positions 1 and 3 (characters 'b' and 'd').

Return true if you can make the strings equal, false otherwise.

Input & Output

example_1.py — Basic swap case

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

› Output: true

💡 Note: We can swap positions 0↔2 in s1 to get "cbad", then swap positions 1↔3 to get "cdab" which matches s2. Alternatively, both strings have the same characters in even positions [a,c] and odd positions [b,d] when sorted.

example_2.py — No solution case

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

› Output: false

💡 Note: Even positions: s1 has [a,c], s2 has [d,c]. Odd positions: s1 has [b,d], s2 has [a,b]. Since the character sets don't match for both groups, no amount of swapping can make them equal.

example_3.py — Already equal case

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

› Output: true

💡 Note: The strings are already identical, so no swaps are needed. Both have matching even [a,c] and odd [b,d] position characters.

Constraints

s1.length == s2.length == 4
s1 and s2 consist of lowercase English letters only
Only swaps between positions with difference of exactly 2 are allowed

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

You have two hands of 4 cards each, positions 0,1,2,3

Swap Rules

You can only swap cards at positions 0↔2 and 1↔3

Group Recognition

This creates two independent groups: {0,2} and {1,3}

Solution

Check if both hands have the same cards in each group

Key Takeaway

🎯 Key Insight: Swapping positions 2 apart creates two independent groups. Just compare the sorted cards in each group!

Asked in

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

The optimal solution recognizes that swapping positions 2 apart creates two independent groups: even positions (0,2) and odd positions (1,3). Simply compare the sorted characters in each group between the two strings for an O(1) time and space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(1)	O(1)	Generate all possible states by trying every combination of swaps
Character Frequency Analysis (Optimal)	O(1)	O(1)	Compare character frequencies at even and odd positions separately

Brute Force (Try All Swaps) — Algorithm Steps

Generate all possible states of s1 by applying all combinations of swaps
Generate all possible states of s2 by applying all combinations of swaps
Check if any state from s1 set matches any state from s2 set
Return true if match found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original strings s1 and s2

Generate s1 States

Apply all combinations of swaps (0↔2, 1↔3) to s1

Generate s2 States

Apply all combinations of swaps to s2

Find Intersection

Check if any s1 state matches any s2 state

Code -

solution.c — C

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

void swap(char *a, char *b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

bool canBeEqual(char* s1, char* s2) {
    char states1[4][5];
    char states2[4][5];
    int count1 = 0, count2 = 0;
    
    // Generate all states for s1
    for (int swap02 = 0; swap02 <= 1; swap02++) {
        for (int swap13 = 0; swap13 <= 1; swap13++) {
            strcpy(states1[count1], s1);
            if (swap02) swap(&states1[count1][0], &states1[count1][2]);
            if (swap13) swap(&states1[count1][1], &states1[count1][3]);
            count1++;
        }
    }
    
    // Generate all states for s2
    for (int swap02 = 0; swap02 <= 1; swap02++) {
        for (int swap13 = 0; swap13 <= 1; swap13++) {
            strcpy(states2[count2], s2);
            if (swap02) swap(&states2[count2][0], &states2[count2][2]);
            if (swap13) swap(&states2[count2][1], &states2[count2][3]);
            count2++;
        }
    }
    
    // Check for matches
    for (int i = 0; i < count1; i++) {
        for (int j = 0; j < count2; j++) {
            if (strcmp(states1[i], states2[j]) == 0) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char s1[5], s2[5];
    scanf("%s %s", s1, s2);
    printf("%s\n", canBeEqual(s1, s2) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Since string length is fixed at 4, we have at most 4 possible states per string (2^2 combinations), making it constant time

✓ Linear Growth

Space Complexity

O(1)

Fixed number of possible states regardless of input

✓ Linear Space

24.5K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler