Change Minimum Characters to Satisfy One of Three Conditions

Change Minimum Characters to Satisfy One of Three Conditions - Problem

You are given two strings a and b consisting only of lowercase English letters. Your mission is to transform these strings with the minimum number of character changes to satisfy one of three winning conditions:

Alphabetical Dominance (a < b): Every character in string a must be strictly less than every character in string b alphabetically
Alphabetical Dominance (b < a): Every character in string b must be strictly less than every character in string a alphabetically
Uniform Strings: Both strings must consist of only one distinct character (they can be different characters)

In one operation, you can change any character in either string to any lowercase letter. Your goal is to find the minimum number of operations needed to achieve any one of these three conditions.

Example: If a = "aba" and b = "caa", you could change one character to make a = "aaa" and b = "aaa" (condition 3), requiring just 1 operation.

Input & Output

example_1.py — Basic Case

$ Input: a = "aba", b = "caa"

› Output: 1

💡 Note: We can change one character in string a to make both strings uniform: change 'b' to 'a' to get a="aaa", b="caa" (condition 3). Only 1 operation needed.

example_2.py — Alphabetical Ordering

$ Input: a = "dabadd", b = "cda"

› Output: 3

💡 Note: Best strategy is to make all characters in a ≤ 'c' and all characters in b > 'c'. We need to change 'd','d','d' in string a to characters ≤ 'c' (3 operations).

example_3.py — Edge Case

$ Input: a = "abc", b = "def"

› Output: 0

💡 Note: The strings already satisfy condition 1: every character in a ('a','b','c') is strictly less than every character in b ('d','e','f'). No operations needed.

Visualization

Tap to expand

Understanding the Visualization

Count Character Types

Count how many of each letter type we have in both strings

Try Alphabetical Split

For each possible split point, calculate cost of moving characters

Try Uniform Strings

Calculate cost of making both strings consist of single character

Choose Minimum

Select the strategy that requires the fewest operations

Key Takeaway

🎯 Key Insight: Use frequency counting with prefix sums to efficiently evaluate all possible transformation strategies in optimal O(n+m) time

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass to count frequencies O(n + m), then O(26) to try all splits and characters

✓ Linear Growth

Space Complexity

O(1)

Only using fixed-size arrays of length 26 for character frequencies

✓ Linear Space

Constraints

1 ≤ a.length, b.length ≤ 10⁵
a and b consist only of lowercase English letters
The strings are guaranteed to be non-empty

Asked in

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

The optimal solution uses frequency counting with prefix sums to efficiently calculate the minimum operations. We count character frequencies in O(n+m) time, then use prefix sums to compute split costs in O(1) per split point, trying all three conditions to find the minimum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Split Points)	O(26 * (n + m))	O(1)	Try every possible alphabetical split point for conditions 1&2, and every character for condition 3
Frequency Counting with Prefix Sums (Optimal)	O(n + m)	O(1)	Count character frequencies once, then use prefix sums to efficiently calculate all split costs

Brute Force (Try All Split Points) — Algorithm Steps

For each letter 'c' from 'a' to 'y', calculate cost to make all chars in string a ≤ c and all chars in string b > c
For each letter 'c' from 'b' to 'z', calculate cost to make all chars in string b ≤ c and all chars in string a > c
For each letter 'c' from 'a' to 'z', calculate cost to make both strings consist only of character c
Return minimum cost among all attempts

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split at 'a'

Check cost of making a ≤ 'a' and b > 'a'

Try Split at 'b'

Check cost of making a ≤ 'b' and b > 'b'

Continue for all letters

Test each possible boundary character

Code -

solution.c — C

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

int minCharacters(char* a, char* b) {
    int n = strlen(a), m = strlen(b);
    int minOps = INT_MAX;
    
    // Condition 1: All chars in a < all chars in b
    for (int splitChar = 'a'; splitChar < 'z'; splitChar++) {
        int ops = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] > splitChar) ops++;
        }
        for (int i = 0; i < m; i++) {
            if (b[i] <= splitChar) ops++;
        }
        if (ops < minOps) minOps = ops;
    }
    
    // Condition 2: All chars in b < all chars in a
    for (int splitChar = 'a'; splitChar < 'z'; splitChar++) {
        int ops = 0;
        for (int i = 0; i < m; i++) {
            if (b[i] > splitChar) ops++;
        }
        for (int i = 0; i < n; i++) {
            if (a[i] <= splitChar) ops++;
        }
        if (ops < minOps) minOps = ops;
    }
    
    // Condition 3: Both strings have same character
    for (int targetChar = 'a'; targetChar <= 'z'; targetChar++) {
        int ops = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] != targetChar) ops++;
        }
        for (int i = 0; i < m; i++) {
            if (b[i] != targetChar) ops++;
        }
        if (ops < minOps) minOps = ops;
    }
    
    return minOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(26 * (n + m))

We try 26 possible characters as split points, and for each we scan both strings of length n and m

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

Constraints

1 ≤ a.length, b.length ≤ 10⁵
a and b consist only of lowercase English letters
The strings are guaranteed to be non-empty

52.0K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Try All Split Points) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler