Given a string s, return the length of the longest substring between two equal characters, excluding the two characters. If there is no such substring return -1.

A substring is a contiguous sequence of characters within a string.

&nbsp;
Example 1:

Input: s = "aa"
Output: 0
Explanation: The optimal substring here is an empty substring between the two 'a's.

Example 2:

Input: s = "abca"
Output: 2
Explanation: The optimal substring here is "bc".


Example 3:

Input: s = "cbzxy"
Output: -1
Explanation: There are no characters that appear twice in s.


&nbsp;
Constraints:


	1 &lt;= s.length &lt;= 300
	s contains only lowercase English letters.


class Solution:
    def maxLengthBetweenEqualCharacters(self, s: str) -> int:
        last, ans = {}, -1 
        for i, c in enumerate(s):
            if c not in last:
                last[c] = i
            else:
                ans = max(ans, i - last[c] - 1)
        return ans 
class Solution {
    public int maxLengthBetweenEqualCharacters(String s) {
        int ans = -1;
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char ch  = s.charAt(i);
            if (map.containsKey(ch)) {
                ans = Math.max(ans, i - 1 - map.get(ch));
            }
            else {
                map.put(ch, i);
            }
        }
        return ans;
    }
}
class Solution {
public:
    int maxLengthBetweenEqualCharacters(string s) {
        vector<int> v(26, -1);
        int maxi = -1;
        
        for (int i = 0; i < s.size(); i++) {
            if (v[s[i] - 'a'] == -1) v[s[i] - 'a'] = i;
            else maxi = max(maxi, abs(v[s[i] - 'a'] - i) - 1);      
        }
        
        return maxi;
    }
};
var maxLengthBetweenEqualCharacters = function(s) {
    
    const map = new Map();
    let max=-1;
    for(let i=0;i<s.length;i++){

        if(map.has(s[i])){
            max=Math.max(max,i-(map.get(s[i])+1))
        }else{
            map.set(s[i],i)    
        }
        
    }
    return max;
};
Largest Substring Between Two Equal Characters