Minimum Number of Steps to Make Two Strings Anagram II - Problem

You are given two strings s and t. In one step, you can append any character to either s or t.

Return the minimum number of steps to make s and t anagrams of each other.

An anagram of a string is a string that contains the same characters with a different (or the same) ordering.

Input & Output

Example 1 — Basic Case

$ Input: s = "abc", t = "cde"

› Output: 4

💡 Note: String s has 'a' and 'b' that t doesn't have. String t has 'd' and 'e' that s doesn't have. We need to add 'd' and 'e' to s, and add 'a' and 'b' to t, totaling 4 steps.

Example 2 — Partial Overlap

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

› Output: 11

💡 Note: s has: l(1), e(4), t(1), c(1), o(1), d(1). t has: p(1), r(1), a(1), c(2), t(1), i(1), e(1). Character frequency differences: |1-0|+|4-1|+|1-1|+|1-2|+|1-0|+|1-0|+|0-1|+|0-1|+|0-1|+|0-1| = 1+3+0+1+1+1+1+1+1+1 = 11 steps.

Example 3 — Same Strings

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

› Output: 0

💡 Note: Both strings are already anagrams of each other, so no steps are needed.

Constraints

1 ≤ s.length, t.length ≤ 5 × 10⁴
s and t consist of lowercase English letters only

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 12 M Microsoft 8

The key insight is to count character frequency differences between the two strings. The optimal approach uses a frequency array to track differences in O(n+m) time and O(1) space. Best approach: Frequency Counting. Time: O(n+m), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(26^n) Space: O(n)

Try adding every possible character to both strings and check if they form anagrams. This explores all combinations of character additions until finding the minimum steps needed.

Optimal - Frequency Counting

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

Count the frequency of each character in both strings, then sum the absolute differences. This directly gives us the minimum steps needed since we need to balance the character counts.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible character additions
Check if resulting strings are anagrams
Track minimum steps across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count each character in both strings

Calculate Differences

Find absolute difference for each character

Sum Differences

Total differences give minimum steps

Code -

solution.c — C

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

int solution(char* s, char* t) {
    // Count character frequencies (assuming lowercase letters)
    int freqS[26] = {0};
    int freqT[26] = {0};
    
    int lenS = strlen(s);
    int lenT = strlen(t);
    
    for (int i = 0; i < lenS; i++) {
        freqS[s[i] - 'a']++;
    }
    
    for (int i = 0; i < lenT; i++) {
        freqT[t[i] - 'a']++;
    }
    
    int steps = 0;
    for (int i = 0; i < 26; i++) {
        steps += abs(freqS[i] - freqT[i]);
    }
    
    return steps;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove newline characters
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    int result = solution(s, t);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^n)

Exponential combinations of adding 26 possible characters

✓ Linear Growth

Space Complexity

O(n)

Space for storing string copies during generation

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 min Avg. Time

892 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

Minimum Number of Steps to Make Two Strings Anagram II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler