1657. Determine if Two Strings Are Close

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.

Understand the problem — what does Close mean?

Close does not mean “roughly similar.” It means you can turn one string into the other using only these two operations (any number of times):

• Operation 1 — swap any two character positions → order does not matter; only which letters you have
• Operation 2 — swap frequencies of existing letters A ↔ B as wholes → frequency counts can be remapped among letters that already exist; you cannot invent a new letter

Don’t simulate the swaps — that search blows up factorially. Translate the operations into checkable conditions instead.

Approach — decode into 3 hard rules

From the two operations, extract three checkpoints — all must pass for the strings to be close:

1. Gate 1 · Same length — len(word1) == len(word2) (swaps / frequency remaps never change length)
2. Gate 2 · Same character set — set(word1) == set(word2) (op 2 remaps frequencies only among existing letters; no foreign letters)
3. Gate 3 · Same frequency pattern — sorted(Counter(word1).values()) == sorted(Counter(word2).values()) (op 2 can reassign counts, so compare the sorted bags of numbers, not which letter owns which count)

Walkthrough — word1 = "cabbba", word2 = "abbccc"

Run all three gates on the main example:

1. Gate 1: len("cabbba") = 6, len("abbccc") = 6 → pass
2. Gate 2: both sets = {a, b, c} → pass (no foreign letters)
3. Gate 3: Counter("cabbba") = {c:1, a:2, b:3} · Counter("abbccc") = {a:1, b:2, c:3} → both sorted values = [1, 2, 3] → pass → True

Quick check on the other examples:

Try it yourself first

The three gates are above — write it yourself, then open the fold below when stuck or ready to compare.

from collections import Counter

def close_strings(word1, word2):
    # Gate 1: lengths must match
    if len(word1) != len(word2):
        return False
    # Gate 2: same character set (op 2 cannot invent letters)
    if set(word1) != set(word2):
        return False
    # Gate 3: same sorted frequency bag
    count1 = Counter(word1)
    count2 = Counter(word2)
    freq1 = sorted(count1.values())
    freq2 = sorted(count2.values())
    return freq1 == freq2

print(close_strings("abc", "bca"))        # True
print(close_strings("a", "aa"))           # False
print(close_strings("cabbba", "abbccc"))  # True
print(close_strings("cabbba", "aabbss"))  # False

True
False
True
False