def steadyGene(chars: list[str]) -> int:
    from collections import defaultdict, deque

    char_to_cnt = defaultdict(lambda: 0)
    for char in chars:
        char_to_cnt[char] += 1
    
    char_to_surplus = defaultdict(lambda: 0)
    for char in ['A', 'C', 'T', 'G']:
        surplus = char_to_cnt[char] - len(chars) // 4
        if surplus > 0:
            char_to_surplus[char] = surplus

    if not char_to_surplus:
        return 0
    
    lo = hi = 0
    lohi_to_cnt = defaultdict(lambda: 0)
    lohi_to_cnt[chars[lo]] = 1
    
    def is_satisfying() -> bool:
        for char, surplus in char_to_surplus.items():
            if lohi_to_cnt[char] < surplus:
                return False
        return True
    
    candidates = []
    while True:
        if is_satisfying():
            candidates.append(hi - lo + 1)
        hi += 1
        if hi == len(chars):
            break
        lohi_to_cnt[chars[hi]] += 1
        while lohi_to_cnt[chars[lo]] > char_to_surplus[chars[lo]]:
            lohi_to_cnt[chars[lo]] -= 1
            lo += 1
    return min(candidates)

if sys.version_info[:2] >= (3,10): # Counter supports comparision
    from collections import Counter
else:  # add operator ">=" to class Counter
    from collections import Counter as Counter_orig
    class Counter(Counter_orig):
        def __ge__(self,other):
            return all(self[k]>=other[k] for k in other.keys())

            
def steadyGene(gene):
    baddies = Counter(
        {k:v-len(gene)//4 for k,v in Counter(gene).items() 
				if v > len(gene)//4} )
    if not baddies: return 0
    genecount_win,cur_winsize,min_winsize = Counter(),0,len(gene)
    left_it = iter(gene)
    cl = next(left_it) # cl: char at window's left margin
    for cr in gene:
        cur_winsize += 1
        genecount_win[cr] += 1
        if cr not in baddies: continue
        while cl not in baddies or genecount_win[cl] > baddies[cl]:
            cur_winsize -= 1
            genecount_win[cl] -=1
            cl = next(left_it)
        if genecount_win >= baddies and cur_winsize < min_winsize:
            min_winsize = cur_winsize
    return min_winsize

def steadyGene(gene):
    n = len(gene)
    gene_map = collections.Counter(gene)
    
    extra = ""
    for key, val in gene_map.items():
        if val > n//4:
            extra += key*(val-n//4)
    m = len(extra)
    if m == 0:
        return 0

    extra_map = collections.Counter(extra)
    i, j, count, ans, temp_map = 0, 0, 0, n, {}
    
    def add_to_temp(count):
        temp_map[gene[j]] = temp_map.get(gene[j], 0) + 1
        if temp_map.get(gene[j]) <= extra_map.get(gene[j], 0):
            count += 1
        return temp_map, count, j+1
    
    while j < n:
        if count < m: 
            temp_map, count, j = add_to_temp(count)
        else:
            ans = min(ans, j-i)
            if temp_map.get(gene[i], 0)-1 >= extra_map.get(gene[i], -1):
                temp_map[gene[i]] -= 1
                i += 1
            else:
                temp_map, count, j = add_to_temp(count)
    return ans

bool isvalid(map<char,int> a, int l){
    if(a['A'] <= l && a['G'] <= l && a['T'] <= l && a['C'] <= l) return true;
    
    return false;
}

int steadyGene(string gene) {
    int n = gene.size(), mini = n;
    map<char,int> am;
    for(char c: gene){
        am[c]++;
    }
    if(isvalid(am, gene.size()/4)){
        return 0;
    }
    
    int i = 0, j = 0;
    while(j < n){
        
        if(isvalid(am, gene.size()/4)){
            am[gene[i]]++;
            i++;
            mini = min(mini, (j - i + 1));
        }
        else{
            am[gene[j]]--;
            j++;
        }
        
    }
    return mini;
}

int steadyGene(string gene) {
    unordered_map<char, int> freq;
    for (char c : gene) {
        ++freq[c];
    }
    unordered_map<char, int> numChg;
    for (const auto& item : freq) {
        int chg = item.second - (int) gene.length() / 4;
        if (chg <= 0) {continue;}
        numChg[item.first] = chg;
    }
    if (numChg.empty()) {return 0;}
    int minLen = numeric_limits<int>::max();
    freq.clear();
    int l = 0;
    int r = 0;
    ++freq[gene[l]];
    auto isOK = [&numChg, &freq]() {
        for (const auto& item : numChg) {
            if (item.second > freq[item.first]) {return false;}
        }
        return true;
    };
    auto moveLeft = [&numChg, &freq, &gene, &l]() {
        if (!numChg.count(gene[l])) {return true;}
        if (freq[gene[l]] > numChg[gene[l]]) {return true;}
        return false;
    };
    auto moveRight = [&numChg, &freq, &gene, &r, &moveLeft, &isOK]() {
        if (r >= gene.length() - 1) {return false;}
        if (!isOK()) {return true;}
        return !moveLeft() && r < gene.length() - 1;
    };
    while (moveLeft() || moveRight()) {
        if (moveLeft ()) {
            --freq[gene[l++]];
        }
        if (isOK()) {minLen = min(minLen, r - l + 1);}
        if (moveRight()) {
            ++freq[gene[++r]];
        }
    }
    return minLen;
}