Minimum Number of Steps to Make Two Strings Anagram

Minimum Number of Steps to Make Two Strings Anagram - Problem

You're given two strings s and t of equal length. Your goal is to transform string t into an anagram of string s by replacing characters in t.

In each step, you can choose any character in t and replace it with any other character. An anagram contains the same characters with the same frequencies, but possibly in different positions.

Example: If s = "bab" and t = "aba", they're already anagrams, so 0 steps are needed. If s = "leetcode" and t = "practice", we need to replace some characters in t to match the character frequencies of s.

Return the minimum number of character replacements needed to make t an anagram of s.

Input & Output

example_1.py — Basic Case

$ Input: s = "bab", t = "aba"

› Output: 1

💡 Note: Replace the first 'a' in t with 'b': "aba" → "bba" (which is an anagram of "bab"). Only 1 step needed.

example_2.py — Complex Case

$ Input: s = "leetcode", t = "practice"

› Output: 5

💡 Note: s has letters {l:1, e:3, t:1, c:1, o:1, d:1}. t has {p:1, r:1, a:1, c:1, t:1, i:1, e:1}. We need to replace p, r, a, i, and one extra consonant to match s's frequencies.

example_3.py — Already Anagram

$ Input: s = "anagram", t = "nagaram"

› Output: 0

💡 Note: The strings are already anagrams of each other, so no replacements are needed.

Visualization

Tap to expand

Understanding the Visualization

Count Differences

Track what you need (+) vs what you have (-)

Find Excess

Identify characters that appear more in t than in s

Calculate Steps

Sum up all the excess characters to get minimum replacements

Key Takeaway

🎯 Key Insight: Count character frequency differences in one pass. The sum of positive differences equals the minimum replacements needed.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings of length n

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 characters (constant space)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s.length == t.length
s and t consist of lowercase English letters only
Both strings have the same length

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a one-pass hash table approach with O(n) time and O(1) space complexity. By tracking character frequency differences in a single pass, we count excess characters in string t that need replacement to match string s's character distribution.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimized (Optimal)	O(n)	O(1)	Count frequencies of both strings simultaneously for maximum efficiency
Brute Force Character Comparison	O(n²)	O(n)	Compare each character in t with all characters in s to find matches
Two-Pass Hash Table	O(n)	O(1)	Count character frequencies in both strings, then calculate differences

One-Pass Optimized (Optimal) — Algorithm Steps

Initialize a single hash map for character frequency differences
Iterate through both strings simultaneously: increment for s[i], decrement for t[i]
Calculate the total number of negative frequencies (excess characters in t)
Return half of the total absolute differences (since each replacement fixes two mismatches)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty difference map

Process

For each position: +1 for s[i], -1 for t[i]

Calculate

Sum all positive differences to get the answer

Code -

solution.c — C

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

int minSteps(char* s, char* t) {
    int charDiff[26] = {0};  // For lowercase letters a-z
    int len = strlen(s);
    
    // Single pass: count s positively, t negatively
    for (int i = 0; i < len; i++) {
        charDiff[s[i] - 'a']++;
        charDiff[t[i] - 'a']--;
    }
    
    // Count positive differences
    int steps = 0;
    for (int i = 0; i < 26; i++) {
        if (charDiff[i] > 0) {
            steps += charDiff[i];
        }
    }
    
    return steps;
}

int main() {
    char s[1001], t[1001];
    scanf("%s %s", s, t);
    printf("%d\n", minSteps(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings of length n

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 characters (constant space)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s.length == t.length
s and t consist of lowercase English letters only
Both strings have the same length

89.0K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Optimized (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler