Consecutive Characters - Practice Coding Problems

Consecutive Characters - Problem

String Easy

Think of a string as a sequence of characters where certain letters might repeat consecutively, like in "aaabbc". The power of a string is defined as the maximum length of any consecutive sequence of identical characters.

For example, in the string "leetcode", the letter 'e' appears consecutively twice, giving it a power of 2. In "abbcccddddeeeeedcba", the letter 'e' appears 5 times in a row, making the power 5.

Your task: Given a string s, find and return its power - the length of the longest substring containing only one unique repeating character.

Input & Output

example_1.py — Basic consecutive characters

$ Input: s = "leetcode"

› Output: 2

💡 Note: The substring "ee" has the power of 2, which is the maximum among all substrings.

example_2.py — Multiple consecutive groups

$ Input: s = "abbcccddddeeeeedcba"

› Output: 5

💡 Note: The substring "eeeee" has the power of 5, which is longer than "dddd" (power 4) or "ccc" (power 3).

example_3.py — Single character

$ Input: s = "a"

› Output: 1

💡 Note: A single character has power 1, as it's the only character forming a consecutive sequence.

Visualization

Tap to expand

Understanding the Visualization

Initialize tracking

Start with maxPower=1 and currentPower=1, since any single character has power 1

Scan left to right

Compare each character with its predecessor. If same, increment currentPower; if different, reset to 1

Update maximum

Whenever currentPower increases, check if it exceeds our recorded maxPower

Return result

After scanning the entire string, maxPower contains the length of the longest consecutive sequence

Key Takeaway

🎯 Key Insight: Consecutive identical characters form natural groups that can be counted efficiently in a single pass, eliminating the need for nested loops or additional data structures.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n, checking each character exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for counters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
The string is non-empty

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a single pass through the string, maintaining a running count of consecutive identical characters. By comparing each character with its predecessor and updating counters accordingly, we achieve O(n) time complexity with O(1) space complexity. The key insight is that consecutive characters naturally form groups that we can count incrementally without needing nested loops.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible substring to find the longest consecutive sequence
Single Pass Optimal Solution	O(n)	O(1)	Scan the string once, tracking current and maximum consecutive character counts

Brute Force (Nested Loops) — Algorithm Steps

Initialize maxPower to 1 (minimum possible length)
For each starting position i in the string
Count consecutive identical characters starting from position i
Update maxPower if current count is larger
Return the maximum power found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check how many consecutive identical characters from position 0

Move to position 1

Repeat the process from position 1

Continue for all positions

Keep track of the maximum consecutive count found

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int maxPower(char* s) {
    if (!s || strlen(s) == 0) return 0;
    
    int maxPower = 1;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        int currentPower = 1;
        int j = i;
        while (j + 1 < n && s[j] == s[j + 1]) {
            currentPower++;
            j++;
        }
        if (currentPower > maxPower) {
            maxPower = currentPower;
        }
    }
    
    return maxPower;
}

int main() {
    char s[100001];
    scanf("%s", s);
    printf("%d\n", maxPower(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we potentially scan up to n characters forward

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and maximum

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
The string is non-empty

67.2K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler