Consecutive Characters - Practice Coding Problems

Consecutive Characters - Problem

String Easy

The power of a string is defined as the maximum length of a non-empty substring that contains only one unique character.

Given a string s, return the power of s.

For example, if s = "leetcode", the power is 2 because the substring "ee" has length 2 and contains only the character 'e'.

Input & Output

Example 1 — Basic Case

$ Input: s = "leetcode"

› Output: 2

💡 Note: The substring "ee" has length 2 with all characters identical. This is the longest such substring.

Example 2 — Single Character

$ Input: s = "abbcccddddeeeeedcba"

› Output: 5

💡 Note: The substring "eeeee" has length 5 with all characters identical.

Example 3 — All Same

$ Input: s = "aaaa"

› Output: 4

💡 Note: The entire string consists of identical characters, so the power is the length of the string.

Constraints

1 ≤ s.length ≤ 500
s consists of only lowercase English letters.

Visualization

Tap to expand

Understanding the Visualization

Input

String with various characters

Process

Find longest substring of identical characters

Output

Return the maximum length found

Key Takeaway

🎯 Key Insight: Use a single pass with running counter - reset when character changes, track maximum seen

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is to use a single pass approach, tracking consecutive identical characters. Best approach is the sliding window technique with O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass with Counter	O(n)	O(1)	Track current consecutive count while scanning the string once
Brute Force - Check All Substrings	O(n³)	O(1)	Check every possible substring to find the longest with identical characters

Single Pass with Counter — Algorithm Steps

Initialize current count and maximum count
Iterate through string, comparing each character with previous
Reset counter when character changes, update maximum when needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with count=1, max=1

Compare Adjacent

If same character, increment count; if different, reset to 1

Update Maximum

Track the highest count seen so far

Code -

solution.c — C

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

int solution(char* s) {
    int len = strlen(s);
    if (len == 0) {
        return 0;
    }
    
    int maxPower = 1;
    int currentCount = 1;
    
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i - 1]) {
            currentCount++;
            if (currentCount > maxPower) {
                maxPower = currentCount;
            }
        } else {
            currentCount = 1;
        }
    }
    
    return maxPower;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

980 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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass with Counter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler