thảo luận Leetcode mỗi ngày

class Solution {
    public int maximumLength(String s) {
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            String string = "";
            for (int j = i; j < s.length(); j++) {
                if (string.isEmpty() || string.charAt(string.length() - 1) == s.charAt(j)) {
                    string += s.charAt(j);
                    int count = map.getOrDefault(string, 0);
                    map.put(string, count + 1);
                } else break;
            }
        }
        int ans = -1;
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            if (entry.getValue() >= 3) ans = Math.max(ans, entry.getKey().length());
        }
        return ans;
    }
}

var maximumLength = function (s) {
    let ans = -1;
    const map = {};
    for (let i = 0, l = 0; i < s.length; i++) {
        const ch = s[i];
        l = i > 0 && s[i] === s[i - 1] ? l + 1 : 1;
        map[ch] ??= [];
        map[ch][l] ??= 0;
        map[ch][l]++;
    }
    for (const arr of Object.values(map)) {
        for (let i = arr.length - 1, c = 0; i >= 0; i--) {
            c += arr[i];
            if (c >= 3) {
                ans = Math.max(ans, i);
                break;
            }
        }
    }
    return ans;
};

class Solution:
    def maximumLength(self, s: str) -> int:
        freq = defaultdict(list)
        def push(c, f):
            if len(freq[c]) < 3:
                freq[c].append(f)
            elif freq[c][2] < f:
                freq[c][2] = f
            freq[c] = sorted(freq[c], reverse=True)

        l = 1
        prev = s[0]
        for i in range(1, len(s)):
            if s[i] != prev:
                push(prev, l)
                l = 1
                prev = s[i]
            else:
                l += 1
        push(prev, l)
        
        res = 0
        for arr in freq.values():
            res = max(res, arr[0] - 2)
            if len(arr) > 1:
                res = max(res, arr[1] - (1 if arr[1] == arr[0] else 0))
            if len(arr) > 2:
                res = max(res, arr[2])
        return res if res > 0 else -1

var maximumLength = function(s) {
    const sMap = new Map()
    for(let i=0; i<s.length; i++) {
        if(!sMap.has(s[i])) {
            sMap.set(s[i], 1)
        } else {
            const count = sMap.get(s[i])
            sMap.set(s[i], count+1)
        }
        let j = i
        let st = s[j]
        while(s[j] === s[j+1]) {
            st+=s[j+1]
            if(!sMap.has(st)) {
                sMap.set(st, 1)
            } else {
                const count = sMap.get(st)
                sMap.set(st, count+1)
            }
            j++
        }
    }
    let result = -1
    sMap.forEach((value, key)=> {
        if(value >=3) {
            result = Math.max(result, key.length)
        }
    })

    return result
};

class Solution {
    public int maximumLength(String s) {
        int l =1;
        int r = s.length()-2;
        int ans =-1;
        while(l<=r){
            int mid = l+(r-l)/2;
            if(condition(mid, s)){
                ans =mid;
                l=mid+1;
            }
            else r =mid-1;
        }
        return ans;
    }
    public boolean condition(int len, String s){
        char last= '0';
        int cnt=1;
        HashMap<String, Integer> freq = new HashMap();
        for(int i =0 ;i < s.length();i++){
            if(s.charAt(i)==last){
                cnt++;
            }
            else{
                cnt=1;
                last = s.charAt(i);
            }
            if(cnt>=len){
                    cnt--;
                    String sub = s.substring(i-cnt, i+1);
                    freq.put(sub,freq.getOrDefault(sub,0)+1 );
                    if(freq.get(sub)>=3) return true;
                }
        }
        return false;
    }
}

class Solution:
    def maximumLength(self, s: str) -> int:
        chars_map = defaultdict(list)
        l = 0
        n = len(s)
        count = 0
        for r in range(n):
            if s[r] == s[l]:
                count += 1
            else:
                chars_map[s[l]].append((count))
                count = 1
                l = r
        chars_map[s[l]].append((count))
        res = -1
        for c in chars_map:
            sorted_size = sorted(chars_map[c], reverse = True)
            if sum(sorted_size) <= 2:
                continue
            k = len(sorted_size)
            res = max(res, sorted_size[0] - 2)
            if k > 1:
                res = max(res, min(sorted_size[0] - 1, sorted_size[1]))
            if k > 2:
                res = max(res, sorted_size[2])
        return res

class Solution {
    func maximumLength(_ s: String) -> Int {
        var result = -1
        var count = 0
        var char = Character(" ")
        var dict:[Character:[Int]] = [:]
        for c in s {
            if c == char {
                count += 1
            } else {
                count = 1
                char = c
            }
            
            for idx in 0..<count {
                if idx < dict[c, default:[]].count {
                    let newValue = dict[c]![idx] + 1
                    dict[c]![idx] = newValue
                    //
                    if newValue >= 3 {
                        result = max(result, idx+1)
                    }
                } else {
                    dict[c, default:[]].append(1)
                }
            }
        }
        return result
    }
}

class Solution {
public:
  int maximumLength(string s) {
    s += "#";
    unordered_map<string, int> d;
    string current = string(1, s[0]);

    for (int i = 1; i < s.length(); i++) {
      if (s[i] == current.back()) {
        current += s[i];
      } else {
        d[current]++;
        if (current.size() > 1) d[current.substr(1)] += 2;
        if (current.size() > 2) d[current.substr(2)] += 3;

        current = string(1, s[i]);
      }
    }

    int res = -1;
    for (auto& [key, value] : d) {
      if (value > 2) {
        res = max(res, (int)key.size());
      }
    }

    return res;
  }
};

class Solution:
    def maximumLength(self, s):
        d = defaultdict(int)
        for sub in [''.join(sub) for _, sub in groupby(s)]:
            d[sub] += 1
            if sub[1:]: d[sub[1:]] += 2
            if sub[2:]: d[sub[2:]] += 3
        return max(map(len,filter(lambda x: d[x] > 2, d.keys())), default = -1)

class Solution {
    public int maximumLength(String s) {
        Map<String,Integer> hm = new HashMap<>();

        for(int i = 0;i<s.length();i++){
            String temp = String.valueOf(s.charAt(i));
            hm.put(temp, hm.getOrDefault(temp, 0 ) + 1);

            StringBuilder sb = new StringBuilder(temp);
            for(int j = i;j<s.length() - 1;j++){
                if(sb.charAt(sb.length() - 1) == s.charAt(j + 1)){
                    sb.append(s.charAt(j + 1));
                    hm.put(sb.toString(), hm.getOrDefault(sb.toString(), 0) + 1);
                }else{
                    break;
                }
            }
            sb.setLength(0);
        }

        int result = -1;

        for(Map.Entry<String,Integer> entry : hm.entrySet()){
            if(entry.getValue() >= 3) result = Math.max(result, entry.getKey().length());
        }

        return result;
    }
}

class Solution {
public:
    int maximumLength(string s) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        map<char, vector<int>> hash;
        int n=s.size();
        vector<int> count(n, 0);
        for (int i=0; i<n; i++) {
            if (i>0 && s[i]==s[i-1]) {
                count[i]=count[i-1]+1;
            } else {
                count[i]=1;
            }
            hash[s[i]].push_back(count[i]);
        }
        for (char c='a'; c<='z'; c++) {
            sort(hash[c].begin(), hash[c].end());
        }
        int res=-1;
        for (char c='a'; c<='z'; c++) {
            int tempSize=hash[c].size();
            if (tempSize<3) continue;
            else {
                res=max(res, min(hash[c][tempSize-1], min(hash[c][tempSize-2], hash[c][tempSize-3])));
            }
        }
        return res;
    }
};

public class Solution {
    public bool IsSpecial(string s, int start, int end)
    {
        for (int i = start; i < end; i++)
        {
            if (s[i] != s[i+1])
                return false;
        }
        return true;
    }

    public bool IsValid(string s, int length)
    {
        var dict = new Dictionary<string, int>();
        string temp;

        for (int j = 0; j <= s.Length - length; j++)
        {
            temp = s.Substring(j, length);
            if (IsSpecial(s, j, j + length - 1))
            {
                if (!dict.ContainsKey(temp))
                    dict.Add(temp, 0);
                dict[temp]++;
            }
        }

        return dict.Any(kv => kv.Value >= 3);
    }

    public int MaximumLength(string s) {
        int left = 0;
        int right = s.Length - 1;
        int mid = 0;
        while (left < right - 1)
        {
            mid = left + (right - left) / 2;
            if (IsValid(s, mid))
                left = mid;
            else
                right = mid;
        }
        if (left == 0)
            return -1;
        return left;
    }
}