Very poor description of a simple problem..I am not sure what are we achieving by complicating the problem description.. what was the significance of length 'a' and 'b'when in example it already calls out it should be equal length in order to be anagram. This is merely making it verbose and adding complexities like |a-b| < 1 .. not contributing to the gut of the problem. My suggestion is to remove this problem or modify signifincantly. only reason I can see to keep it as is if we intent to confuse reader.

Why not just split the input by a space to make it more understandable rather than telling them they have a S1+S2 string...

The core of the problem statement says 'Your challenge is to help him find the minimum number of characters of the first string he needs to change to make it an anagram of the second string'. This does not imply the require reshuffling of the string. For example changing this to: Your challenge is to help him find the minimum number of characters of the first string he needs to change to enable him to make it an anagram of the second string. Would make things clearer without giving away too much.

Fun question: How do you fail TestCase #0 when you have already passed it? Isn't it the same as in the question or the one you use to check your solution(Run code)?

C# code using dictionary

int t = Convert.ToInt32(Console.ReadLine()); //int t = 1;

        for (int a0 = 0; a0 < t; a0++)
        {
            string s = Console.ReadLine();

            if (s.Length % 2 != 0) { Console.WriteLine(-1); continue; }
            Dictionary<char, int> l = new Dictionary<char, int>();

            int half = s.Length / 2;
            for (int i = 0; i < half; i++)
            {
                if (i < half)
                {
                    if (l.ContainsKey(s[i])) l[s[i]]++;
                    else l.Add(s[i], 1);
                }
            }

            int qtyDiff = 0;
            for (int j = half; j < s.Length; j++)
            {
                if (l.ContainsKey(s[j]) && l[s[j]] > 0) l[s[j]]--;
                else qtyDiff++;
            }

            Console.WriteLine(qtyDiff);
        }

My java solution:

import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0){
            String str = sc.next();
            int len = str.length(), count = 0;
            if (len%2!=0){
                System.out.println(-1);
                continue;
            }
            String s1 = str.substring(0,len/2);
            String s2 = str.substring(len/2,len);
            char[] s1Chars = s1.toCharArray();
            for (char c : s1Chars){
                int index = s2.indexOf(c);
                if (index == -1){
                    count++;
                } else {
                    s2 = s2.substring(0,index)+s2.substring(index+1);
                }
            }
            System.out.println(count);
        }
    }
}

Python 3 solution:

from collections import Counter
for _ in range(int(input())):
    s = input()
    l = len(s)
    if l % 2 == 1:
        print(-1)
    else:
        count = 0
        s1, s2 = Counter(s[:l//2]), Counter(s[l//2:])
        for char in s2:
            current = s2[char] - s1.get(char,0)
            if current > 0:
                count += current
        print(count)

My solution in C#, 100% pass.

static int anagram(string s)
{
    if (s.Length % 2 != 0)
        return -1;
    
    string a = s.Substring(0, s.Length / 2);
    string b = s.Substring(s.Length / 2);

    foreach(char c in b)
    {
        if (a.IndexOf(c) > -1)
            a = a.Remove(a.IndexOf(c), 1);
    }

    return a.Length;
}

Easy to understand Java solution. Works for all test cases.

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int t = scan.nextInt();
    scan.nextLine();
    for (int i = 0; i<t; i++){
        String str = scan.nextLine();
        int[] lettersArray = new int[26];
        int changes = 0;
        if (str.length() % 2 == 0){
            for (int j = 0; j<str.length()/2; j++){
                lettersArray[str.charAt(j)-'a']++;
            }
            for (int j = str.length()/2; j<str.length(); j++){
                if(lettersArray[str.charAt(j)-'a'] > 0)
                    lettersArray[str.charAt(j)-'a']--;
            }
            for (int j = 0; j<26; j++){
                changes += lettersArray[j];
            }
            System.out.println(changes);
        } else{
            System.out.println(-1);
        }
    }
}