1class Solution {
2    /**
3     * Finds the maximum number of consecutive-character runs that share the
4     * same length within the given string.
5     *
6     * Approach:
7     *   1. Scan the string and split it into maximal "runs" of identical
8     *      characters (e.g. "aaabb" -> runs "aaa" and "bb").
9     *   2. For each run, record its length in a frequency map.
10     *   3. Track the highest frequency seen for any single length, which is
11     *      the answer.
12     *
13     * @param s the input string
14     * @return the maximum count of runs having the same length
15     */
16    public int maxSameLengthRuns(String s) {
17        // Maps a run length -> how many runs of that length have appeared.
18        Map<Integer, Integer> lengthCount = new HashMap<>();
19        int maxRuns = 0;
20        int length = s.length();
21
22        // Iterate over the string, advancing run by run.
23        for (int start = 0; start < length; ) {
24            // Extend 'end' while the characters stay the same as s[start].
25            int end = start + 1;
26            while (end < length && s.charAt(end) == s.charAt(start)) {
27                ++end;
28            }
29
30            // Compute the current run's length.
31            int runLength = end - start;
32
33            // Increment the count for this run length and update the maximum.
34            int updatedCount = lengthCount.merge(runLength, 1, Integer::sum);
35            maxRuns = Math.max(maxRuns, updatedCount);
36
37            // Move to the start of the next run.
38            start = end;
39        }
40
41        return maxRuns;
42    }
43}
44

1class Solution {
2public:
3    int maxSameLengthRuns(string s) {
4        // Map from run length -> number of runs that have exactly this length
5        unordered_map<int, int> lengthCount;
6
7        // Tracks the maximum number of runs sharing the same length
8        int maxRuns = 0;
9
10        int n = s.size();
11
12        // Iterate over the string, processing one consecutive run at a time
13        for (int start = 0; start < n;) {
14            // Advance 'end' until the character differs from s[start]
15            int end = start + 1;
16            while (end < n && s[end] == s[start]) {
17                ++end;
18            }
19
20            // Length of the current run of identical characters
21            int runLength = end - start;
22
23            // Increment the count for this run length and update the answer
24            maxRuns = max(maxRuns, ++lengthCount[runLength]);
25
26            // Move to the start of the next run
27            start = end;
28        }
29
30        return maxRuns;
31    }
32};
33

1/**
2 * Finds the maximum number of consecutive-character "runs" that share
3 * the same length within the string.
4 *
5 * A "run" is a maximal block of identical consecutive characters.
6 * For example, in "aabbb" there are two runs: "aa" (length 2) and "bbb" (length 3).
7 *
8 * @param s - The input string to scan.
9 * @returns The highest frequency among all run lengths.
10 */
11function maxSameLengthRuns(s: string): number {
12    // Maps a run length to how many runs have that exact length.
13    const lengthCount: Record<number, number> = {};
14    const length = s.length;
15    let answer = 0;
16
17    // Iterate over the string; `start` marks the beginning of each run.
18    for (let start = 0; start < length; ) {
19        // Advance `end` until the character differs, capturing the full run.
20        let end = start + 1;
21        while (end < length && s[end] === s[start]) {
22            ++end;
23        }
24
25        // Compute the current run's length.
26        const runLength = end - start;
27
28        // Record this run length and update its frequency.
29        lengthCount[runLength] = (lengthCount[runLength] || 0) + 1;
30
31        // Track the maximum frequency seen so far.
32        answer = Math.max(answer, lengthCount[runLength]);
33
34        // Jump to the start of the next run.
35        start = end;
36    }
37
38    return answer;
39}
40