int validSize(string s, char first, char second){
    string ans = "";
    for(int i = 0; i < s.size(); i++){
        if(s[i] == first || s[i] == second){
            if(ans.size() > 0 && ans[ans.size() - 1] == s[i]) return 0;
            else ans+=s[i];
        }
    }
    if(ans.size() < 2) return 0;
    return ans.size();
}

int alternate(string s) {
    int ans = 0;
    for(char i = 'a'; i < 'z'; i++){
        for(char j = i + 1; j <= 'z'; j++){
           int r = validSize(s, i, j);
           if(r > ans) ans = r;
        }
    }
    return ans;
}

def alternate(s):
    lens = [0]
    letters = list(set(list(s)))
    for letter1 in range(len(letters)):
        for letter2 in range(letter1 + 1, len(letters)):
            two = []
            for letter in s:
                if letter == letters[letter1]:
                    if two:
                        if two[-1] == letters[letter2]:
                            two.append(letter)
                        else:
                            two = []
                            break
                    else:
                        two.append(letter)
                elif letter == letters[letter2]:
                    if two:
                        if two[-1] == letters[letter1]:
                            two.append(letter)
                        else:
                            two = []
                            break
                    else:
                        two.append(letter)
            lens.append(len(two))
    return max(lens)

function alternate(s: string): number {
    // Write your code here
    // get unique chars in input string
    const availableChars = Array.from(new Set<string>(s.split('')));
    
    // build available pair options
    const availablePairs: [string, string][] = [];
    availableChars.forEach((firstChar) => {
        availableChars.forEach((secondChar) => {
            if (firstChar === secondChar) {
                // same, not an option
                return;
            }
            // add pair combonation to list of available pairs
            availablePairs.push([firstChar, secondChar]);
        });
    });
    
    // build array of lenths for each available pair
    const pairsStrLenValues: number[] = availablePairs.map(([a, b]): number => {
        // regex to find char that are not the current pair
        const findUnavailableCharsRegex = new RegExp(`[^${a}${b}]`, 'gi');
        // regex to find duplicates of char a in string
        const findDuplicateACharRegex = new RegExp(`[${a}]{2}`);
        // regex to find duplicates of char b in string
        const findDuplicateBCharRegex = new RegExp(`[${b}]{2}`);
        
        // remove all char that are not in the current pair
        // @ts-ignore (due to lib version)
        const cleanedString = s.replaceAll(findUnavailableCharsRegex, ``);
        
        // check for duplicates of char a and char b to check if cleaned string is valid
        const doesCleanStringHaveDuplicateAChar = !!findDuplicateACharRegex.exec(cleanedString);
        const doesCleanStringHaveDuplicateBChar = !!findDuplicateBCharRegex.exec(cleanedString);
        
        const isCleanedStringValid: boolean = (
            !doesCleanStringHaveDuplicateAChar
            && !doesCleanStringHaveDuplicateBChar
        );
        if (!isCleanedStringValid) {
            // cleaned string not valid so return length of zero
            return 0;
        }
        // return length of valid string
        return cleanedString.length;
        
    });
    
    return Math.max(0, ...pairsStrLenValues);

}

def lenIfValidResult(s, charA, charB):
    last_matching_char = None
    count = 0
    for char in s:
        if char == charA or char == charB:
            if last_matching_char == char:
                return 0
            count += 1
            last_matching_char = char
    return count

def alternate(s):    
    max_len = 0
    chars_in_str = set(s)
    if len(chars_in_str) <= 1:
        return 0
    for charA in chars_in_str:
        for charB in chars_in_str:
            if charA != charB:
                result_len = lenIfValidResult(s, charA, charB)
                max_len = max(max_len, result_len)
    return max_len