Loading…

easyStrings0Sometimes asked

Making Anagrams

Q: How do you solve Making Anagrams using the Two Separate Frequency Maps (Baseline) approach?

When to use it: Clear and correct first cut — build both maps, then sum |diff| over the union of keys. Tally `a` into one frequency map and `b` into another. Then, for each of the 26 letters, add `|fa[c] − fb[c]|` to the running total. **Why absolute difference per letter is the deletion count.** Consider letter `c` with `fa[c] = 3` and `fb[c] = 1`. The two strings can only share `min(3,1) = 1` copy of `c`; the other `3 − 1 = 2` copies in `a` are surplus and must be deleted. In general the surplus on whichever side is larger is `|fa[c] − fb[c]|`, and that many deletions are unavoidable for that letter. Summed across the alphabet, that's the minimum total. **Why no division by two.** Unlike the single-sided Anagram problem, a deletion here only shrinks one string. There is no single operation that simultaneously fixes a's surplus and b's deficit, so each letter's gap is paid in full. **Why two maps is fine but slightly wasteful.** Two maps make the logic obvious, which is good for an interview opener. A single signed array fuses both passes and is what you'd ship. Time complexity: O(|a| + |b|). Space complexity: O(1).

Q: How do you solve Making Anagrams using the Single Signed Histogram (Optimal) approach?

When to use it: The polished answer — one int[26], +1 for a, −1 for b, then sum the magnitudes. Keep a single `int[26]` balance. Increment for each character of `a`, decrement for each character of `b`. Slot `c` then equals `fa[c] − fb[c]`. The answer is `Σ |balance[c]|`. **Why one array is enough.** We never need the two raw counts separately — only their difference per letter. Folding both passes into one signed accumulator gives exactly that difference while halving the bookkeeping. **Why we sum magnitudes, not the raw values.** A slot can be positive (a has more) or negative (b has more); both directions represent real deletions, just from different strings. The magnitude `|balance[c]|` is the number of deletions for that letter regardless of which side is heavier. **Why this differs from Anagram by exactly the /2.** In the single-sided Anagram problem, one replacement fixes a surplus in one half and the matching deficit in the other at once, so you count each pair once (sum of positives = sum(|diff|)/2). Here, deletions are one-sided: removing a surplus `c` from `a` does nothing for `b`'s separate surplus of some other letter. So every letter's gap is paid in full — `Σ |balance|`, no division. Time complexity: O(|a| + |b|). Space complexity: O(1).

Arrays & Hashing · 64 of 83 · 7 min

Given two strings a and b, find the minimum number of character deletions required to make a and b anagrams of each other. You may delete characters from either string.

Two strings are anagrams if they contain the same characters with the same multiplicities (in any order).

In plain English

We want the two strings to end up with identical letter multisets. Any letter that appears more often in one string than the other has surplus copies that must be deleted from whichever string holds the extra. The shared core (the per-letter minimum of the two counts) survives untouched. The total deleted is everything outside that shared core.

Examples

Example 1

Input: a = "cde", b = "abc"
Output: 4
Note: Shared letter is 'c'. Delete 'd','e' from a and 'a','b' from b. 2 + 2 = 4 deletions; both become "c".

Example 2

Input: a = "showman", b = "woman"
Output: 2
Note: b's letters {w,o,m,a,n} all appear in a. a has extra 's' and 'h'. Delete those 2; both become anagrams of "woman".

Example 3

Input: a = "fcrxzwscanmligyxyvym", b = "jxwtrhvujlmrpdoqbisbwhmgpmeoke"
Output: 30
Note: Few letters overlap, so most characters on both sides are deleted; the absolute frequency differences sum to 30.

Constraints

1 ≤ |a|, |b| ≤ 10⁴
a and b consist of lowercase English letters only
Deletions are allowed from both strings

Clarifying questions4First question: Can I delete from both strings?Explore questions

Q1.Can I delete from both strings?
Yes — that's the defining difference from the single-sided Anagram problem. Each string sheds its own surplus letters.
Q2.Must the strings be equal length?
No. After deletions they end up the same length (the size of the shared multiset), but the inputs can differ.
Q3.Do I divide the sum by two?
No. A deletion removes from only one string, so a surplus and the matching deficit are NOT fixed together. Sum all absolute differences.
Q4.What alphabet?
Lowercase a–z, so 26 counters give O(1) space.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Count the character frequencies of both strings. For every letter, the number of deletions needed is the absolute difference between its counts in the two strings. The total minimum deletions to make them anagrams is the sum of those absolute differences over all 26 letters. O(|a| + |b|) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you see that two-sided deletion means summing ALL absolute differences, and can tell it apart from the one-sided Anagram problem where you divide by two.

Where candidates slip

Dividing the summed differences by two out of habit from the Anagram problem, or assuming the two strings must be the same length.

How to stand out

Contrast it explicitly with Anagram: there one replacement fixes both sides at once (so /2); here a deletion only removes from one side, so each surplus is paid independently — no /2.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Two Separate Frequency Maps (Baseline)	`O(\|a\| + \|b\|)`	`O(1)`	Clear and correct first cut — build both maps, then sum \|diff\| over the union of keys.	Read
2	Single Signed Histogram (Optimal)Optimal	`O(\|a\| + \|b\|)`	`O(1)`	The polished answer — one int[26], +1 for a, −1 for b, then sum the magnitudes.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewfreq(a)per letter cYesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Two Separate Frequency Maps (Baseline)

TimeO(|a| + |b|)SpaceO(1)

Clear and correct first cut — build both maps, then sum |diff| over the union of keys.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Anagrams share the same multiset. What two structures let you compare multisets directly?

2Hint 2Explore hint

Build a frequency map for a and another for b.

3Hint 3Explore hint

For every letter that appears in either map, add the absolute difference of its two counts to the answer.

A · Core idea

Tally a into one frequency map and b into another. Then, for each of the 26 letters, add |fa[c] − fb[c]| to the running total.

Why absolute difference per letter is the deletion count. Consider letter c with fa[c] = 3 and fb[c] = 1. The two strings can only share min(3,1) = 1 copy of c; the other 3 − 1 = 2 copies in a are surplus and must be deleted. In general the surplus on whichever side is larger is |fa[c] − fb[c]|, and that many deletions are unavoidable for that letter. Summed across the alphabet, that's the minimum total.

Why no division by two. Unlike the single-sided Anagram problem, a deletion here only shrinks one string. There is no single operation that simultaneously fixes a's surplus and b's deficit, so each letter's gap is paid in full.

Why two maps is fine but slightly wasteful. Two maps make the logic obvious, which is good for an interview opener. A single signed array fuses both passes and is what you'd ship.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

a = "cde", b = "abc"

Array state

c:1, d:1, e:1

[0]

[1]

[2]

Current pointerResolved stateNot processed

Final result4

C · Code with teaching comments

Reference implementation previewpublic int makingAnagrams(String a, String b) { int[] fa = new int[26]; int[] fb = new int[26]; for (char c : a.toCharArray()) fa[c - 'a']++; for (char c : b.toCharArray()) fb[c - 'a']++;Explore the full code

solution.javaJava

Two Separate Frequency Maps (Baseline) — reference

3 teaching notes

1
public int makingAnagrams(String a, String b) {
2
    int[] fa = new int[26];
3
    int[] fb = new int[26];
4
    // Histogram of a.
5
    for (char c : a.toCharArray()) fa[c - 'a']++;
6
    // Histogram of b — kept separate in the baseline.
7
    for (char c : b.toCharArray()) fb[c - 'a']++;
8
    int deletions = 0;
9
    for (int i = 0; i < 26; i++) {
10
        // Surplus on either side for letter i is deleted; sum it all (no /2).
11
        deletions += Math.abs(fa[i] - fb[i]);
12
    }
13
    return deletions;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(|a| + |b|) timeO(1) spaceOpen the invariant and proofExplore the proof

The strings keep only their common sub-multiset min(fa, fb) per letter; everything else is deleted. The deletion count is therefore the size of the symmetric difference of the two histograms — sum(|fa − fb|).

ComplexityO(|a| + |b|) time, O(1) space — Building each map is linear in its string's length. Iterating the 26 possible letters to sum differences is O(1). Two fixed-size maps are O(1) space.

E · Edge cases and pitfalls5a = "abc", b = "abc" — Identical multisets → all diffs 0 → 0 deletions.Explore edge cases

Edge cases handled

a = "abc", b = "abc"Identical multisets → all diffs 0 → 0 deletions.
a = "", b = "xyz"Delete all of b → 3 deletions.

Pitfalls

Iterating only one map's keys, missing letters unique to the other string.
Dividing by two like the Anagram problem — wrong when both sides can delete.
Assuming equal lengths and indexing out of bounds.

03.2

Approach 2 of 2 · Optimal

Single Signed Histogram (Optimal)

TimeO(|a| + |b|)SpaceO(1)

The polished answer — one int[26], +1 for a, −1 for b, then sum the magnitudes.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Do you really need two arrays, or can one signed array track the gap directly?

2Hint 2Explore hint

Use a single int[26]: add for every character of a, subtract for every character of b.

3Hint 3Explore hint

After both passes, slot c holds fa[c] − fb[c]. Sum the absolute values of all slots.

A · Core idea

Keep a single int[26] balance. Increment for each character of a, decrement for each character of b. Slot c then equals fa[c] − fb[c]. The answer is Σ |balance[c]|.

Why one array is enough. We never need the two raw counts separately — only their difference per letter. Folding both passes into one signed accumulator gives exactly that difference while halving the bookkeeping.

Why we sum magnitudes, not the raw values. A slot can be positive (a has more) or negative (b has more); both directions represent real deletions, just from different strings. The magnitude |balance[c]| is the number of deletions for that letter regardless of which side is heavier.

Why this differs from Anagram by exactly the /2. In the single-sided Anagram problem, one replacement fixes a surplus in one half and the matching deficit in the other at once, so you count each pair once (sum of positives = sum(|diff|)/2). Here, deletions are one-sided: removing a surplus c from a does nothing for b's separate surplus of some other letter. So every letter's gap is paid in full — Σ |balance|, no division.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

a = "showman", b = "woman"

Array state

after add a

s,h,o,w,m,a,n = +1

s:+1

[0]

h:+1

[1]

o:+1

[2]

w:+1

[3]

m:+1

[4]

a:+1

[5]

n:+1

[6]

Current pointerResolved stateNot processed

Final result2

C · Code with teaching comments

solution.javaJava

Single Signed Histogram (Optimal) — optimal

3 teaching notes

1
public int makingAnagrams(String a, String b) {
2
    int[] balance = new int[26];
3
    // a pushes counts up.
4
    for (char c : a.toCharArray()) balance[c - 'a']++;
5
    // b pulls them down; zero means perfectly shared.
6
    for (char c : b.toCharArray()) balance[c - 'a']--;
7
    int deletions = 0;
8
    for (int v : balance) {
9
        // Either sign is a real deletion — sum magnitudes, never /2.
10
        deletions += Math.abs(v);
11
    }
12
    return deletions;
13
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.13 lines

D · Why it works and complexityO(|a| + |b|) timeO(1) spaceOpen the invariant and proofExplore the proof

Two problems, one histogram, opposite arithmetic: 'replace in one half' → sum positives (=sum|diff|/2); 'delete from both' → sum all |diff|. Knowing which arithmetic the operation implies is the entire interview signal here.

ComplexityO(|a| + |b|) time, O(1) space — Two linear passes (one per string) and a constant 26-slot scan → O(|a| + |b|) time. One fixed array → O(1) space.

E · Edge cases and pitfalls6a = "abc", b = "cba" — Already anagrams → balance all zero → 0.Explore edge cases

Edge cases handled

a = "abc", b = "cba"Already anagrams → balance all zero → 0.
a = "aaa", b = "a"a slot = +2 → 2 deletions from a.
a = "", b = ""No characters → 0 deletions.

Pitfalls

Summing raw balance instead of |balance| — positives and negatives cancel to a wrong total.
Reusing the Anagram /2 — only valid for single-sided replacement.
Using ord(ch) without the − 97 offset in Python (index out of range).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int makingAnagrams(String a, String b) { int[] balance = new int[26]; for (char c : a.toCharArray()) balance[c - 'a']++; for (char c : b.toCharArray()) balance[c - 'a']--; int deletions = 0;Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Dividing by two

Deletions are one-sided — removing a surplus from a does not also fix b. Each letter's gap is paid in full, so there is no /2 here (that belongs to the replacement-based Anagram).

Explore the code comparison

Don't write this

return sum(abs(fa[c] - fb[c]) for c in letters) // 2

Write this instead

return sum(abs(fa[c] - fb[c]) for c in letters)

Summing only one map's keys

Letters that appear in b but not a (or vice versa) contribute deletions too. Iterate the union, or all 26 slots.

Explore the code comparison

Don't write this

return sum(abs(fa[c] - fb[c]) for c in fa)

Write this instead

return sum(abs(fa[c] - fb[c]) for c in set(fa) | set(fb))

Summing signed balance

Positive (a-surplus) and negative (b-surplus) entries cancel, hiding real deletions. Take the absolute value of each slot before summing.

Explore the code comparison

Don't write this

for (int v : balance) deletions += v;

Write this instead

for (int v : balance) deletions += Math.abs(v);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Sum of absolute frequency differences

Code pattern to memorize

fa = freq(a), fb = freq(b)
return sum(|fa[c] - fb[c]| for c in 'a'..'z')

Rules to remember

1Deletions are allowed from both strings, so you sum all absolute differences — no /2 here.
2A shared letter with equal counts costs nothing; only the mismatch is deleted.
3One signed int[26] works: +1 for each char of a, −1 for each char of b, then sum |entries|.
4Lengths need not be equal — anagrams just need matching multisets after deletion.
526 counters → O(1) space regardless of input size.

Use this pattern when

Two strings, deletions allowed on either side, make them anagrams
Cost is per-deletion and you want the minimum total
Order is irrelevant — only character multiplicities matter
Lowercase alphabet so a fixed-size array suffices

Choose another pattern when

Only replacements in one half allowed → Anagram (sum of positive surplus = sum(|diff|)/2)
Yes/no 'are these anagrams' → just compare frequency maps for equality
Insertions allowed too → reframe as edit distance, not pure deletion
Need the resulting common string, not the count → reconstruct from min(fa, fb)

Interview takeaway

When you may delete from both strings, every letter where the two counts disagree forces exactly that many deletions. Summing absolute frequency differences across the alphabet gives the minimum total — and unlike single-sided 'Anagram', there's no division by two because each string pays for its own surplus.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternFrequency-difference counting with two-sided deletion. Reduce both strings to 26-slot histograms and sum the absolute differences. The presence or absence of a /2 is dictated by the operation: two-sided deletion sums everything, single-sided replacement halves it.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Anagram
Single-sided: split one string and replace in one half — sum positive surplus = sum(|diff|)/2.
Valid Anagram
Just YES/NO — frequencies must match exactly with equal lengths.
Delete Operation for Two Strings
Coming soon
Deletions to make strings EQUAL (order matters) — that's LCS-based, not frequency-based.
Minimum Steps to Make Two Strings Anagram
Coming soon
Equal-length, replace in one string only — count positive surplus.

Same pattern

←

HackerRank in a String

Continue · Next problem

Palindrome Index

easyStrings0Sometimes asked

Making Anagrams

Arrays & Hashing · 64 of 83 · 7 min

Given two strings a and b, find the minimum number of character deletions required to make a and b anagrams of each other. You may delete characters from either string.

Two strings are anagrams if they contain the same characters with the same multiplicities (in any order).

In plain English

Examples

Example 1

Input: a = "cde", b = "abc"
Output: 4
Note: Shared letter is 'c'. Delete 'd','e' from a and 'a','b' from b. 2 + 2 = 4 deletions; both become "c".

Example 2

Input: a = "showman", b = "woman"
Output: 2
Note: b's letters {w,o,m,a,n} all appear in a. a has extra 's' and 'h'. Delete those 2; both become anagrams of "woman".

Example 3

Input: a = "fcrxzwscanmligyxyvym", b = "jxwtrhvujlmrpdoqbisbwhmgpmeoke"
Output: 30
Note: Few letters overlap, so most characters on both sides are deleted; the absolute frequency differences sum to 30.

Constraints

1 ≤ |a|, |b| ≤ 10⁴
a and b consist of lowercase English letters only
Deletions are allowed from both strings

Clarifying questions4First question: Can I delete from both strings?Explore questions

Q1.Can I delete from both strings?
Yes — that's the defining difference from the single-sided Anagram problem. Each string sheds its own surplus letters.
Q2.Must the strings be equal length?
No. After deletions they end up the same length (the size of the shared multiset), but the inputs can differ.
Q3.Do I divide the sum by two?
No. A deletion removes from only one string, so a surplus and the matching deficit are NOT fixed together. Sum all absolute differences.
Q4.What alphabet?
Lowercase a–z, so 26 counters give O(1) space.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you see that two-sided deletion means summing ALL absolute differences, and can tell it apart from the one-sided Anagram problem where you divide by two.

Where candidates slip

Dividing the summed differences by two out of habit from the Anagram problem, or assuming the two strings must be the same length.

How to stand out

Contrast it explicitly with Anagram: there one replacement fixes both sides at once (so /2); here a deletion only removes from one side, so each surplus is paid independently — no /2.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Two Separate Frequency Maps (Baseline)	`O(\|a\| + \|b\|)`	`O(1)`	Clear and correct first cut — build both maps, then sum \|diff\| over the union of keys.	Read
2	Single Signed Histogram (Optimal)Optimal	`O(\|a\| + \|b\|)`	`O(1)`	The polished answer — one int[26], +1 for a, −1 for b, then sum the magnitudes.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewfreq(a)per letter cYesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Two Separate Frequency Maps (Baseline)

TimeO(|a| + |b|)SpaceO(1)

Clear and correct first cut — build both maps, then sum |diff| over the union of keys.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Anagrams share the same multiset. What two structures let you compare multisets directly?

2Hint 2Explore hint

Build a frequency map for a and another for b.

3Hint 3Explore hint

For every letter that appears in either map, add the absolute difference of its two counts to the answer.

A · Core idea

Tally a into one frequency map and b into another. Then, for each of the 26 letters, add |fa[c] − fb[c]| to the running total.

Why two maps is fine but slightly wasteful. Two maps make the logic obvious, which is good for an interview opener. A single signed array fuses both passes and is what you'd ship.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

a = "cde", b = "abc"

Array state

c:1, d:1, e:1

[0]

[1]

[2]

Current pointerResolved stateNot processed

Final result4

C · Code with teaching comments

solution.javaJava

Two Separate Frequency Maps (Baseline) — reference

3 teaching notes

1
public int makingAnagrams(String a, String b) {
2
    int[] fa = new int[26];
3
    int[] fb = new int[26];
4
    // Histogram of a.
5
    for (char c : a.toCharArray()) fa[c - 'a']++;
6
    // Histogram of b — kept separate in the baseline.
7
    for (char c : b.toCharArray()) fb[c - 'a']++;
8
    int deletions = 0;
9
    for (int i = 0; i < 26; i++) {
10
        // Surplus on either side for letter i is deleted; sum it all (no /2).
11
        deletions += Math.abs(fa[i] - fb[i]);
12
    }
13
    return deletions;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(|a| + |b|) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(|a| + |b|) time, O(1) space — Building each map is linear in its string's length. Iterating the 26 possible letters to sum differences is O(1). Two fixed-size maps are O(1) space.

E · Edge cases and pitfalls5a = "abc", b = "abc" — Identical multisets → all diffs 0 → 0 deletions.Explore edge cases

Edge cases handled

a = "abc", b = "abc"Identical multisets → all diffs 0 → 0 deletions.
a = "", b = "xyz"Delete all of b → 3 deletions.

Pitfalls

Iterating only one map's keys, missing letters unique to the other string.
Dividing by two like the Anagram problem — wrong when both sides can delete.
Assuming equal lengths and indexing out of bounds.

03.2

Approach 2 of 2 · Optimal

Single Signed Histogram (Optimal)

TimeO(|a| + |b|)SpaceO(1)

The polished answer — one int[26], +1 for a, −1 for b, then sum the magnitudes.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Do you really need two arrays, or can one signed array track the gap directly?

2Hint 2Explore hint

Use a single int[26]: add for every character of a, subtract for every character of b.

3Hint 3Explore hint

After both passes, slot c holds fa[c] − fb[c]. Sum the absolute values of all slots.

A · Core idea

Keep a single int[26] balance. Increment for each character of a, decrement for each character of b. Slot c then equals fa[c] − fb[c]. The answer is Σ |balance[c]|.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

a = "showman", b = "woman"

Array state

after add a

s,h,o,w,m,a,n = +1

s:+1

[0]

h:+1

[1]

o:+1

[2]

w:+1

[3]

m:+1

[4]

a:+1

[5]

n:+1

[6]

Current pointerResolved stateNot processed

Final result2

C · Code with teaching comments

solution.javaJava

Single Signed Histogram (Optimal) — optimal

3 teaching notes

1
public int makingAnagrams(String a, String b) {
2
    int[] balance = new int[26];
3
    // a pushes counts up.
4
    for (char c : a.toCharArray()) balance[c - 'a']++;
5
    // b pulls them down; zero means perfectly shared.
6
    for (char c : b.toCharArray()) balance[c - 'a']--;
7
    int deletions = 0;
8
    for (int v : balance) {
9
        // Either sign is a real deletion — sum magnitudes, never /2.
10
        deletions += Math.abs(v);
11
    }
12
    return deletions;
13
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.13 lines

D · Why it works and complexityO(|a| + |b|) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(|a| + |b|) time, O(1) space — Two linear passes (one per string) and a constant 26-slot scan → O(|a| + |b|) time. One fixed array → O(1) space.

E · Edge cases and pitfalls6a = "abc", b = "cba" — Already anagrams → balance all zero → 0.Explore edge cases

Edge cases handled

a = "abc", b = "cba"Already anagrams → balance all zero → 0.
a = "aaa", b = "a"a slot = +2 → 2 deletions from a.
a = "", b = ""No characters → 0 deletions.

Pitfalls

Summing raw balance instead of |balance| — positives and negatives cancel to a wrong total.
Reusing the Anagram /2 — only valid for single-sided replacement.
Using ord(ch) without the − 97 offset in Python (index out of range).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Dividing by two

Deletions are one-sided — removing a surplus from a does not also fix b. Each letter's gap is paid in full, so there is no /2 here (that belongs to the replacement-based Anagram).

Explore the code comparison

Don't write this

return sum(abs(fa[c] - fb[c]) for c in letters) // 2

Write this instead

return sum(abs(fa[c] - fb[c]) for c in letters)

Summing only one map's keys

Letters that appear in b but not a (or vice versa) contribute deletions too. Iterate the union, or all 26 slots.

Explore the code comparison

Don't write this

return sum(abs(fa[c] - fb[c]) for c in fa)

Write this instead

return sum(abs(fa[c] - fb[c]) for c in set(fa) | set(fb))

Summing signed balance

Positive (a-surplus) and negative (b-surplus) entries cancel, hiding real deletions. Take the absolute value of each slot before summing.

Explore the code comparison

Don't write this

for (int v : balance) deletions += v;

Write this instead

for (int v : balance) deletions += Math.abs(v);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Sum of absolute frequency differences

Code pattern to memorize

fa = freq(a), fb = freq(b)
return sum(|fa[c] - fb[c]| for c in 'a'..'z')

Rules to remember

1Deletions are allowed from both strings, so you sum all absolute differences — no /2 here.
2A shared letter with equal counts costs nothing; only the mismatch is deleted.
3One signed int[26] works: +1 for each char of a, −1 for each char of b, then sum |entries|.
4Lengths need not be equal — anagrams just need matching multisets after deletion.
526 counters → O(1) space regardless of input size.

Use this pattern when

Two strings, deletions allowed on either side, make them anagrams
Cost is per-deletion and you want the minimum total
Order is irrelevant — only character multiplicities matter
Lowercase alphabet so a fixed-size array suffices

Choose another pattern when

Only replacements in one half allowed → Anagram (sum of positive surplus = sum(|diff|)/2)
Yes/no 'are these anagrams' → just compare frequency maps for equality
Insertions allowed too → reframe as edit distance, not pure deletion
Need the resulting common string, not the count → reconstruct from min(fa, fb)

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Anagram
Single-sided: split one string and replace in one half — sum positive surplus = sum(|diff|)/2.
Valid Anagram
Just YES/NO — frequencies must match exactly with equal lengths.
Delete Operation for Two Strings
Coming soon
Deletions to make strings EQUAL (order matters) — that's LCS-based, not frequency-based.
Minimum Steps to Make Two Strings Anagram
Coming soon
Equal-length, replace in one string only — count positive surplus.

Same pattern

←

HackerRank in a String

Continue · Next problem

Palindrome Index