Count number of matching strings after replacing a character and all its occurrence

First of all, it seems the explanation you provided is based on a slightly misunderstood formulation of the problem. The problem consists of checking whether all occurrences of a character can be replaced with a different character in the string s, not the string in the array.

So for example, with s = "aabbcdbb", and array string "aabbbdbb", you can replace the c character in s with a b to obtain the array string. It's not the other way around. That explains the inconsistency of the expected outputs for the two input samples (as raised in the comments).

Your implementation is generally correct but fails on a special case. The way you're solving it is by basically generating a "diff" array containing the difference in occurrence for each character. You then expect that in the diff, you have only two different occurrences that negate each other. To illustrate with the previous example, you map the characters of s:

a -> 2
b -> 4
c -> 1
d -> 1

similarly with the current array element:

a -> 2
b -> 5
d -> 1

the difference will be:

b -> 1
c -> -1

This fails when you have s = "aabb" and a string "abbb", where the diff is:

a -> -1
b -> 1

The problem here is that both characters a and b occur in the string "abbb". This should fail the match check. The reason is: if we want to go from "abbb" to "aabb", we would need to replace a b with an a. But "abbb" already has an a character, which would not have been there if the opposite side replaced a with b.

The code can be modified to handle this case (the part that uses diffInS1):

for(String s1 : arr) {
    // get array element
    char[] c1 = s1.toCharArray();
    // check if array element length matches with input string length
    if(c1.length == c.length) {
        // count each occurrence of char into array of alphabets
        int[] chars = new int[26];
        int[] diff = new int[26];
        for(char k1: c1) {
            chars[k1-'a']++;
            diff[k1-'a']++;
        }
        
        // decrement count by checking with map
        for(char k : m.keySet()) {
            diff[k-'a'] = chars[k-'a'] - m.get(k);
        }
        
        boolean valid = true;
        int mismatch = 0;
        int notzeros = 0;
        int diffInS1 = 0;
        // get each element from array of chars
        for(int i=0; i<26; i++) {
            int ch = diff[i];
            // value not zero
            if(ch != 0) {
                // count number of non zeros
                notzeros++;
                // second occurrence of non zero element
                if(notzeros > 1) {
                    // check if values do not match
                    if(mismatch*-1 != ch) {
                        valid = false;
                        break;
                    }
                }
                if(chars[i] > 0) {
                    diffInS1++;
                }
                // get the mismatch count
                mismatch = ch;
            }
            // if non zero elements more than 2 then we can ignore this array element
            if(notzeros > 2 || diffInS1 == 2) {
                valid = false;
                break;
            }
        }
        //  check for possible solution.
        if(valid && notzeros > 0) {
            matches++;
        }
    }
}

I will offer a similar approach. Let's analyze when two string are "matching strings after replacing a character and all its occurrence". Let's assume we have 2 maps of char count. Now we need to calculate their differences. The two strings are matching when the two left maps, have one entry, and the counter is equal.

Let's do an example. aabbbbcd will create map:

a -> 2
b -> 4
c -> 1
d -> 1

aabbxdbb will create:

a -> 2
b -> 4
x -> 1
d -> 1

The difference will be:

First map will remain:

c -> 1

Second map:

x -> 1

Therefore those two match. Let's see how to write this.

First, this is the method to get this map:

private static Map<Character, Integer> getMap(String s) {
    Map<Character, Integer> result = new HashMap<>();
    for (char c : s.toCharArray()) {
        if (result.containsKey(c)) {
            result.put(c, result.get(c) + 1);
        } else {
            result.put(c, 1);
        }
    }
    return result;
}

Now we can define a method that will create a predicate:

private static Predicate<String> getPredicate(String s) {
    Map<Character, Integer> sMap = getMap(s);
    Predicate<String> p = s1 -> {
        Map<Character, Integer> s1Map = getMap(s1);
        Map<Character, Integer> sMapCopy = getMap(s);

        for (Map.Entry<Character, Integer> kvp : sMap.entrySet()) {
            if (s1Map.containsKey(kvp.getKey())) {
                if (s1Map.get(kvp.getKey()) < kvp.getValue()) {
                    sMapCopy.put(kvp.getKey(), kvp.getValue() - s1Map.get(kvp.getKey()));
                    s1Map.remove(kvp.getKey());
                } else if (kvp.getValue() < s1Map.get(kvp.getKey())) {
                    s1Map.put(kvp.getKey(), s1Map.get(kvp.getKey()) - kvp.getValue());
                    sMapCopy.remove(kvp.getKey());
                } else {
                    sMapCopy.remove(kvp.getKey());
                    s1Map.remove(kvp.getKey());
                }
            }
        }

        boolean result = sMapCopy.size() == 1 && s1Map.size() == 1;
        if (result) {
            for (Map.Entry<Character, Integer> kvp : sMapCopy.entrySet()) {
                for (Map.Entry<Character, Integer> kvp1 : s1Map.entrySet()) {
                    System.out.println(s + " and " + s1 + " can be replaced. Replace " + kvp.getValue() + " instances of " + kvp.getKey() + " with " + kvp1.getValue() + " instances of " + kvp1.getKey());
                }
            }
        } else {
            System.out.println(s + " and " + s1 + " cannot be replaced.");
        }
        return result;
    };

    return p;
}

Then we run the following:

String[] strings = {"aabbcdbbb", "aabbcdb", "aabbxdbb", "aabbbdbb", "aacccdcc", "ddbbcdbb", "eebbcdbb"};
long result = Arrays.stream(strings).filter(getPredicate("aabbcdbb")).count();
System.out.println("Replacables count: " + result);

and we get the output:

aabbcdbb and aabbcdbbb cannot be replaced.
aabbcdbb and aabbcdb cannot be replaced.
aabbcdbb and aabbxdbb can be replaced. Replace 1 instances of c with 1 instances of x
aabbcdbb and aabbbdbb can be replaced. Replace 1 instances of c with 1 instances of b
aabbcdbb and aacccdcc can be replaced. Replace 4 instances of b with 4 instances of c
aabbcdbb and ddbbcdbb can be replaced. Replace 2 instances of a with 2 instances of d
aabbcdbb and eebbcdbb can be replaced. Replace 2 instances of a with 2 instances of e
Replacables count: 5