Change Minimum Characters to Satisfy One of Three Conditions solution and explanation

def min_operations(a: str, b: str) -> int:
    freq_a = [0] * 26
    freq_b = [0] * 26

    for char in a:
        freq_a[ord(char) - ord('a')] += 1
    for char in b:
        freq_b[ord(char) - ord('a')] += 1

    # Prefix sums
    for i in range(1, 26):
        freq_a[i] += freq_a[i - 1]
        freq_b[i] += freq_b[i - 1]

    # Calculating minimum operations
    n, m = len(a), len(b)
    best = float('inf')

    # Make every letter in a strictly less than every letter in b
    for i in range(25):
        best = min(best, (n - freq_a[i]) + (freq_b[i]))

    # Make every letter in b strictly less than every letter in a
    for i in range(25):
        best = min(best, (m - freq_b[i]) + (freq_a[i]))

    # Make a and b consist of only one distinct letter
    best = min(best, n + m - max(freq_a), n + m - max(freq_b))

    return best

function minOperations(a, b) {
    const freqA = Array(26).fill(0);
    const freqB = Array(26).fill(0);

    for (let char of a) {
        freqA[char.charCodeAt(0) - 97] += 1;
    }
    for (let char of b) {
        freqB[char.charCodeAt(0) - 97] += 1;
    }

    let n = a.length, m = b.length;
    for (let i = 1; i < 26; i++) {
        freqA[i] += freqA[i-1];
        freqB[i] += freqB[i-1];
    }

    let best = Infinity;
    // Condition 1 and 2
    for (let i = 0; i < 25; i++) {
        best = Math.min(best, n - freqA[i] + freqB[i], m - freqB[i] + freqA[i]);
    }
    // Condition 3
    best = Math.min(best, n + m - Math.max(...freqA), n + m - Math.max(...freqB));

    return best;
}

#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int minOperations(string a, string b) {
    vector<int> freqA(26, 0), freqB(26, 0);
    for (char c : a) ++freqA[c - 'a'];
    for (char c : b) ++freqB[c - 'a'];

    int operations = INT_MAX, n = a.size(), m = b.size();

    for (int i = 0; i < 26; ++i) {
        if (i > 0) {
            freqA[i] += freqA[i - 1];
            freqB[i] += freqB[i - 1];
        }
        if (i < 25) {
            operations = min(operations, n - freqA[i] + freqB[i]);
            operations = min(operations, m - freqB[i] + freqA[i]);
        }
    }
    operations = min(operations, n + m - *max_element(freqA.begin(), freqA.end()));
    operations = min(operations, n + m - *max_element(freqB.begin(), freqB.end()));

    return operations;
}

using System;
using System.Linq;

class Solution {
    public int MinOperations(string a, string b) {
        int[] freqA = new int[26];
        int[] freqB = new int[26];
        foreach (char c in a) freqA[c - 'a']++;
        foreach (char c in b) freqB[c - 'a']++;

        int n = a.Length, m = b.Length, best = int.MaxValue;
        for (int i = 0; i < 26; i++) {
            if (i > 0) {
                freqA[i] += freqA[i - 1];
                freqB[i] += freqB[i - 1];
            }
            if (i < 25) {
                best = Math.Min(best, n - freqA[i] + freqB[i]);
                best = Math.Min(best, m - freqB[i] + freqA[i]);
            }
        }

        best = Math.Min(best, n + m - freqA.Max());
        best = Math.Min(best, n + m - freqB.Max());
        return best;
    }
}

class Solution {
    private int ans;

    public int minCharacters(String a, String b) {
        int m = a.length(), n = b.length();
        int[] cnt1 = new int[26];
        int[] cnt2 = new int[26];
        for (int i = 0; i < m; ++i) {
            ++cnt1[a.charAt(i) - 'a'];
        }
        for (int i = 0; i < n; ++i) {
            ++cnt2[b.charAt(i) - 'a'];
        }
        ans = m + n;
        for (int i = 0; i < 26; ++i) {
            ans = Math.min(ans, m + n - cnt1[i] - cnt2[i]);
        }
        f(cnt1, cnt2);
        f(cnt2, cnt1);
        return ans;
    }

    private void f(int[] cnt1, int[] cnt2) {
        for (int i = 1; i < 26; ++i) {
            int t = 0;
            for (int j = i; j < 26; ++j) {
                t += cnt1[j];
            }
            for (int j = 0; j < i; ++j) {
                t += cnt2[j];
            }
            ans = Math.min(ans, t);
        }
    }
}

function minCharacters(a: string, b: string): number {
    const m = a.length,
        n = b.length;
    let count1 = new Array(26).fill(0);
    let count2 = new Array(26).fill(0);
    const base = 'a'.charCodeAt(0);

    for (let char of a) {
        count1[char.charCodeAt(0) - base]++;
    }
    for (let char of b) {
        count2[char.charCodeAt(0) - base]++;
    }

    let pre1 = 0,
        pre2 = 0;
    let ans = m + n;
    for (let i = 0; i < 25; i++) {
        pre1 += count1[i];
        pre2 += count2[i];
        // case1， case2， case3
        ans = Math.min(ans, m - pre1 + pre2, pre1 + n - pre2, m + n - count1[i] - count2[i]);
    }
    ans = Math.min(ans, m + n - count1[25] - count2[25]);

    return ans;
}

func minCharacters(a string, b string) int {
	cnt1 := [26]int{}
	cnt2 := [26]int{}
	for _, c := range a {
		cnt1[c-'a']++
	}
	for _, c := range b {
		cnt2[c-'a']++
	}
	m, n := len(a), len(b)
	ans := m + n
	for i := 0; i < 26; i++ {
		ans = min(ans, m+n-cnt1[i]-cnt2[i])
	}
	f := func(cnt1, cnt2 [26]int) {
		for i := 1; i < 26; i++ {
			t := 0
			for j := i; j < 26; j++ {
				t += cnt1[j]
			}
			for j := 0; j < i; j++ {
				t += cnt2[j]
			}
			ans = min(ans, t)
		}
	}
	f(cnt1, cnt2)
	f(cnt2, cnt1)
	return ans
}