public static String abbreviation(String a, String b) {
        // Write your code here
        int n = a.length(), m = b.length();

        if (n < m) {
            return "NO";
        }

        // "dp" is the Dynamic Programming based 2-D boolean array
        //     dp[i][j]: boolean indicating whether the first 'i 'characters of 'a' 
        //               can be transformed into the first 'j' characters of 'b'.
        boolean[][] dp = new boolean[n + 1][m + 1];

        // Trivial Base Case: First '0' chars of 'a' already same as first '0' chars of 'b'
        dp[0][0] = true;

        // Initialize dp[i][0]: for 1 <= i <= n, as:
        // First 'i' characters of 'a' can be transformed into first '0' characters of 'b'
        // purely via the deletion operation, which is permitted only on Lowercase Chars.
        for (int i = 1; i <= n; i++) {
            dp[i][0] = dp[i-1][0] && Character.isLowerCase(a.charAt(i-1));
        }

        // Fill the rest of dp[i][j]: for 1 <= i < = n, and for: 1 <= j <= m, as:
        //     (1) IF a[i-1] is Lowercase:
        //           dp[i][j] == (a[i-1] == b[j-1] AND dp[i-1][j-1])
        //     (2) ELSE:
        //           dp[i][j] = (UpperCase(a[i-1]) == b[j-1] AND dp[i-1][j-1]) OR dp[i-1][j]

        for (int i = 1; i <= n; i++) {

            char aCh = a.charAt(i - 1);

            for (int j = 1; j <= m; j++) {

                char bCh = b.charAt(j - 1);

                if (Character.isUpperCase(aCh)) {

                    dp[i][j] = ((aCh == bCh) && dp[i-1][j-1]);

                } else {

                    boolean canCapitalize = 
                        ((Character.toUpperCase(aCh) == bCh) && dp[i-1][j-1]);
                    boolean canDelete = dp[i-1][j];
                    dp[i][j] = canCapitalize || canDelete;

                }

            }

        }

        return (dp[n][m] ? "YES" : "NO");
    }

import collections

def _check(a, b):
    if len(a)==1:
        if len(b)==0:
            return a[0].islower()
        else:    
            return a[0].upper()==b[0]
    if a[-1]==b[-1]:
        return _check(a[:-1], b[:-1])
    elif a[-1].upper()==b[-1]:
        return _check(a[:-1], b) or _check(a[:-1], b[:-1]) 
    else:
        return a[-1].islower() and _check(a[:-1], b)
   
def _upper(s, i):
    return s[0:i]+s[i].upper()+s[i+1]


def _remove_unused(a, b):
    _set_b=set(b)
    return "".join(list([x for x in a if x.isupper() or x.upper() in _set_b]))
    

def _build_dp(a):
    _dp = collections.defaultdict(int)
    for _, x in enumerate(a):
       _dp[x.upper()]+=1
    return _dp

def _precheck_check_dp(dp_a, dp_b):
    for x in dp_b:
        if dp_a[x] < dp_b[x]:
            return False
    return True


def abbreviation(a, b):
    a=_remove_unused(a, b)
    if len(a)<len(b):
        return "NO"        
    if not _precheck_check_dp(_build_dp(a),_build_dp(b)):
        return "NO"
    if _check(a, b):
        return "YES"
    else:
        return "NO"

string abbreviation(string a, string b) {
    int j = 0;
    map<char, int> dp1, dp2;
    for(int i = 0;i<a.size();i++)
    {
        dp1[a[i]]++;
    }
    
    for(int i = 0;i<b.size();i++)
    {
        dp2[b[i]]++;
    }
    
    for(int i = 0;i<b.size();i++)
    {
        dp1[b[i]]--;
        if(dp1[b[i]] < 0)
        {
            dp1[char(b[i]+32)]--;
            if(dp1[char(b[i]+32)] < 0)
                return "NO";
        }
    }
    
    for(int i = 0;i<b.size();i++)
    {
        if(dp1[b[i]]>0)
            return "NO";
    }
    
    for(int i = 0;i<a.size();i++)
    {
        if(dp1[a[i]]>0 && a[i]<='Z')
            return "NO";
    }
    
    for(int i = 0;i<a.size();i++)
    {
        if(a[i] <= 'Z' && dp2.find(a[i]) == dp2.end())
            return "NO";
    }
    
    for(int i = 0;i<a.size();i++)
    {
        if(j < b.size())
        {
            if(a[i] == b[j] || char(a[i]-32) == b[j])
            {
                j++;
            }
        }
    }
    
    if(j == b.size())
    {
        return "YES";
    }
    return "NO";
}