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.

You can apply the following operation on any of the two strings any number of times:

Choose any two indices i and j such that j - i = 2, then swap the two characters at those indices in the string.

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

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: We can swap positions 0 and 2 in s1 to get "cbad", then swap positions 1 and 3 to get "cdab" which equals s2.

Example 2 — Impossible Case

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

› Output: false

💡 Note: Even positions in s1 are {a,c} but in s2 are {d,c}. Since 'a' and 'd' are different, it's impossible to make them equal.

Example 3 — Already Equal

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

› Output: true

💡 Note: The strings are already equal, so no operations are needed.

Constraints

s1.length == s2.length == 4
s1 and s2 consist of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input Strings

Two strings of length 4 with swap constraint j-i=2

Position Groups

Characters can only move within even or odd position groups

Compare Groups

Check if both strings have same characters in each group

Key Takeaway

🎯 Key Insight: Characters can only swap within the same position parity group (even or odd indices)

Asked in

M Microsoft 15 a Amazon 12

The key insight is that swaps with distance 2 mean characters can only move between positions of the same parity (even or odd). Best approach is to group by position parity and compare character frequencies. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Group by Position Parity	O(1)	O(1)	Group characters by even/odd positions and compare frequencies
Try All Swaps	O(4!)	O(1)	Keep trying all possible swaps until strings match or no progress

Group by Position Parity — Algorithm Steps

Step 1: Group s1 characters by even/odd positions
Step 2: Group s2 characters by even/odd positions
Step 3: Compare if both groups have same character frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Group Characters

Separate characters by even positions (0,2) and odd positions (1,3)

Compare Frequencies

Check if both strings have same characters in each group

Result

True if both groups match, false otherwise

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return *(char*)a - *(char*)b;
}

bool solution(char* s1, char* s2) {
    char s1Even[3] = {s1[0], s1[2], '\0'};
    char s1Odd[3] = {s1[1], s1[3], '\0'};
    char s2Even[3] = {s2[0], s2[2], '\0'};
    char s2Odd[3] = {s2[1], s2[3], '\0'};
    
    qsort(s1Even, 2, sizeof(char), compare);
    qsort(s1Odd, 2, sizeof(char), compare);
    qsort(s2Even, 2, sizeof(char), compare);
    qsort(s2Odd, 2, sizeof(char), compare);
    
    return strcmp(s1Even, s2Even) == 0 && strcmp(s1Odd, s2Odd) == 0;
}

int main() {
    char s1[6], s2[6];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    bool result = solution(s1, s2);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed string length of 4, so constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using arrays of fixed size for character counting

✓ Linear Space

25.0K Views

Medium Frequency

~8 min Avg. Time

850 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

Group by Position Parity — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler