public static int makingAnagrams(String s1, String s2) {
    Map<String, Long> s1map = Arrays.stream(s1.split("")).collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    Map<String, Long> s2map = Arrays.stream(s2.split("")).collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    long delcount = 0;

    Set<Entry<String, Long>> s1entryset = s1map.entrySet();
    Iterator<Entry<String, Long>> s1iterator = s1entryset.iterator();
    while(s1iterator.hasNext()) {
        Entry<String, Long> entry = s1iterator.next();

        String s1key = entry.getKey();
        Long s1val = entry.getValue();
        if(s2map.get(s1key) != null) {
            if(s1val > s2map.get(s1key)) delcount += s1val - s2map.get(s1key);
            else if(s2map.get(s1key) > s1val) delcount += s2map.get(s1key) - s1val;
        }
        else if(s2map.get(s1key) == null) {
            delcount += s1val;
        }
    }

    Set<Entry<String, Long>> s2entryset = s2map.entrySet();
    Iterator<Entry<String, Long>> s2iterator = s2entryset.iterator();
    while(s2iterator.hasNext()) {
        Entry<String, Long> entry = s2iterator.next();
        String s2key = entry.getKey();
        Long s2val = entry.getValue();
        if(s1map.get(s2key) == null) {
            delcount += s2val;
        }
    }
    return (int)delcount;
}

This python solution is O(n + m) time and O(k) space.

O(k) because in the worse case all keys will will be unique and it will result in a space of O(n + m)

def makingAnagrams(s1, s2):
    w1 = {}
    w2 = {}
    n = max(len(s1), len(s2))
    
    for i in range(n):
        if i < len(s1):
            if s1[i] not in w1:
                w1[s1[i]] = 0
            w1[s1[i]] += 1

        if i < len(s2):
            if s2[i] not in w2:
                w2[s2[i]] = 0
            w2[s2[i]] += 1
            
    all_keys = set(w1.keys()) | set(w2.keys())
    res = {}
    for key in all_keys:
        if key in w1 and key in w2:
            res[key] = abs(w1[key] - w2[key])
        elif key in w1:
            res[key] = w1[key]
        else:
            res[key] = w2[key]
            
    return sum(res.values())

My Python solution-

def makingAnagrams(s1, s2):
    s1 = dict(Counter(s1))
    s2 = dict(Counter(s2))
    result = {}
    all_keys = set(s1) | set(s2)

    for key in all_keys:
        print(key)
        if key in s1 and key in s2:
            result[key] = abs(s1[key] - s2[key])
        elif key in s1:
            result[key] = s1[key]
        else:
            result[key] = s2[key]

    return sum(result.values())
    

My C++ Solution:

int makingAnagrams(string s1, string s2) {
    unordered_map<char, int> mp;
    int deletions = 0;
    for(auto c: s1){
        mp[c]++;
    }
    for(auto c: s2){
        if(mp[c]) mp[c]--;
        else{
            deletions++;
        }
    }
    for(auto item : mp){
        if(item.second > 0){
            deletions += item.second;
        }
    }
    return deletions;
}

Java:

public static int makingAnagrams(String s1, String s2) {
    Map<Character, Integer> s1Map = new HashMap<>();
    Map<Character, Integer> s2Map = new HashMap<>();
    int delCount = 0;
    for (char c : s1.toCharArray()) {
        s1Map.merge(c, 1, (a,b) -> a + b);
    }
    for (char c : s2.toCharArray()) {
        s2Map.merge(c, 1, (a,b) -> a + b);
    }
    for (Map.Entry<Character, Integer> e : s1Map.entrySet()) {
        if (e.getValue() > s2Map.getOrDefault(e.getKey(),0)) {
            delCount += e.getValue() - s2Map.getOrDefault(e.getKey(),0);
        }
    }
    for (Map.Entry<Character, Integer> e : s2Map.entrySet()) {
        if (e.getValue() > s1Map.getOrDefault(e.getKey(),0)) {
            delCount += e.getValue() - s1Map.getOrDefault(e.getKey(),0);
        }
    }
    return delCount;
}