Buddy Strings - Practice Coding Problems

Buddy Strings - Problem

You are given two strings s and goal. Your task is to determine if you can make s equal to goal by swapping exactly two characters in s.

Here's the twist: you must perform exactly one swap operation - no more, no less. A swap operation involves choosing two different indices i and j (where i ≠ j) and exchanging the characters at positions s[i] and s[j].

Examples:

Swapping indices 0 and 2 in "abcd" results in "cbad"
If s = "ab" and goal = "ba", swapping indices 0 and 1 makes them equal
If both strings are already identical but have duplicate characters, you can swap the duplicates

Return true if such a swap is possible, false otherwise.

Input & Output

example_1.py — Basic Swap

$ Input: s = "ab", goal = "ba"

› Output: true

💡 Note: We can swap s[0] = 'a' and s[1] = 'b' to get "ba" which equals goal.

example_2.py — Identical Strings with Duplicates

$ Input: s = "aa", goal = "aa"

› Output: true

💡 Note: The strings are already equal, but we can swap the two 'a' characters at positions 0 and 1.

example_3.py — No Valid Swap

$ Input: s = "ab", goal = "ab"

› Output: false

💡 Note: The strings are identical but have no duplicate characters, so any swap would make them different.

Constraints

1 ≤ s.length, goal.length ≤ 2 × 10⁴
s and goal consist of lowercase English letters
Must perform exactly one swap operation

Visualization

Tap to expand

Understanding the Visualization

Initial Investigation

Compare both statements word by word to find inconsistencies

Identify Discrepancies

Mark all positions where the statements differ

Analyze Pattern

Check if differences follow the 'buddy strings' pattern

Validate Theory

Confirm that swapping two positions resolves all differences

Key Takeaway

🎯 Key Insight: Just like a detective solving a case, we only need to track the differences. Buddy strings are possible when there are exactly 2 differences that can resolve each other through a single swap!

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses a single pass comparison approach with O(n) time complexity. Key insight: buddy strings are possible only when there are exactly 0 differences (with duplicate characters) or exactly 2 differences that can be swapped to make the strings equal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n³)	O(n)	Try swapping every possible pair of characters and check if result equals goal
Single Pass Comparison (Optimal)	O(n)	O(1)	Compare strings once, tracking differences to determine if exactly one swap can make them equal

Brute Force (Try All Swaps) — Algorithm Steps

Check if strings have same length (if not, return false)
For each position i in the string
For each position j > i in the string
Swap characters at positions i and j
Check if the swapped string equals goal
If match found, return true; otherwise restore and continue
If no valid swap found, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Compare s='ab' with goal='ba', mark all possible swap positions

Try Swap (0,1)

Swap positions 0 and 1: 'ab' becomes 'ba'

Check Match

Compare result 'ba' with goal 'ba' - match found!

Code -

solution.c — C

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

bool buddyStrings(char* s, char* goal) {
    int sLen = strlen(s);
    int goalLen = strlen(goal);
    
    if (sLen != goalLen) {
        return false;
    }
    
    // Try all possible swaps
    for (int i = 0; i < sLen; i++) {
        for (int j = i + 1; j < sLen; j++) {
            // Swap characters at positions i and j
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
            
            // Check if swapped string equals goal
            if (strcmp(s, goal) == 0) {
                return true;
            }
            
            // Restore original string
            temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all pairs of swaps, and O(n) for string comparison each time

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to create temporary swapped strings for comparison

⚡ Linearithmic Space

24.3K Views

Medium Frequency

~15 min Avg. Time

856 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