Determine if Two Strings Are Close

Determine if Two Strings Are Close - Problem

Two strings are considered close if you can attain one from the other using the following operations:

Operation 1: Swap any two existing characters.

For example, abcde → aecdb

Operation 2: Transform every occurrence of one existing character into another existing character, and do the same with the other character.

For example, aacabb → bbcbaa (all a's turn into b's, and all b's turn into a's)

You can use the operations on either string as many times as necessary.

Given two strings, word1 and word2, return true if word1 and word2 are close, and false otherwise.

Input & Output

Example 1 — Basic Character Swap

$ Input: word1 = "abc", word2 = "bca"

› Output: true

💡 Note: Both strings have same characters {a,b,c} and same frequency distribution [1,1,1]. We can transform abc → bca using swaps and character transformations.

Example 2 — Different Characters

$ Input: word1 = "a", word2 = "aa"

› Output: false

💡 Note: Different lengths and word2 has frequency [2] while word1 has frequency [1]. Cannot make them close.

Example 3 — Character Transformation

$ Input: word1 = "cabbba", word2 = "abbccc"

› Output: false

💡 Note: Both have characters {a,b,c}. word1 frequencies: c=1,a=1,b=4 → sorted [1,1,4]. word2 frequencies: a=1,b=2,c=4 → sorted [1,2,4]. Different frequency distributions [1,1,4] vs [1,2,4], so they cannot be made close.

Constraints

1 ≤ word1.length, word2.length ≤ 10⁵
word1 and word2 contain only lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is that two strings are close if they have the same set of characters and the same frequency distribution pattern. Best approach uses frequency counting arrays for O(n) time and O(1) space complexity.

Common Approaches

✓ Brute Force - Try All Operations

⏱️ Time: O(n! × 26²) Space: O(n! × n)

Apply all possible swaps and character transformations to word1, generating all reachable strings. Check if word2 is among them. This involves exploring an exponential number of possibilities.

Frequency Count Analysis

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

Two strings are close if they have the same set of unique characters and the same frequency distribution (frequencies can be rearranged). Count frequencies of each character and sort these counts to compare.

Optimized Character Set + Frequency Check

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

Use fixed-size arrays for counting since we only have lowercase letters. Check character sets and frequency distributions in linear time without sorting by using frequency counting arrays.

Brute Force - Try All Operations — Algorithm Steps

Generate all possible swaps of characters
For each swap result, try all character transformations
Check if any generated string equals word2

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Swaps

Try all possible character position swaps

Try Transformations

For each swap result, attempt character mappings

Check Match

See if any result matches target string

Code -

solution.c — C

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

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

bool solution(char* word1, char* word2) {
    int len1 = strlen(word1);
    int len2 = strlen(word2);
    
    if (len1 != len2) {
        return false;
    }
    
    // Count character frequencies (assuming ASCII)
    int count1[256] = {0};
    int count2[256] = {0};
    
    for (int i = 0; i < len1; i++) {
        count1[(unsigned char)word1[i]]++;
    }
    
    for (int i = 0; i < len2; i++) {
        count2[(unsigned char)word2[i]]++;
    }
    
    // Check if both strings have same set of characters
    for (int i = 0; i < 256; i++) {
        if ((count1[i] > 0) != (count2[i] > 0)) {
            return false;
        }
    }
    
    // Get frequency distributions
    int freq1[256], freq2[256];
    int freq1_size = 0, freq2_size = 0;
    
    for (int i = 0; i < 256; i++) {
        if (count1[i] > 0) {
            freq1[freq1_size++] = count1[i];
        }
        if (count2[i] > 0) {
            freq2[freq2_size++] = count2[i];
        }
    }
    
    if (freq1_size != freq2_size) {
        return false;
    }
    
    // Sort frequency arrays
    qsort(freq1, freq1_size, sizeof(int), compare);
    qsort(freq2, freq2_size, sizeof(int), compare);
    
    // Compare sorted frequencies
    for (int i = 0; i < freq1_size; i++) {
        if (freq1[i] != freq2[i]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char word1[100001], word2[100001];
    
    if (fgets(word1, sizeof(word1), stdin)) {
        // Remove newline if present
        char *newline = strchr(word1, '\n');
        if (newline) *newline = '\0';
    }
    
    if (fgets(word2, sizeof(word2), stdin)) {
        // Remove newline if present
        char *newline = strchr(word2, '\n');
        if (newline) *newline = '\0';
    }
    
    bool result = solution(word1, word2);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 26²)

n! swaps times 26² character transformation combinations

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all generated strings of length n

⚠ Quadratic Space

85.4K Views

Medium Frequency

~15 min Avg. Time

2.2K 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 Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler