Consecutive Characters

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

Generate all possible substrings and check if each contains only one unique character. Track the maximum length found.

Single Pass with Counter

⏱️ Time: O(n) Space: O(1)

Iterate through the string once, maintaining a counter for consecutive identical characters. When the character changes, reset the counter and update the maximum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct Node {
    bool val;
    bool isLeaf;
    struct Node* topLeft;
    struct Node* topRight;
    struct Node* bottomLeft;
    struct Node* bottomRight;
};

struct Queue {
    struct Node** items;
    int front;
    int rear;
    int capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->items = (struct Node**)malloc(capacity * sizeof(struct Node*));
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
    return q;
}

void enqueue(struct Queue* q, struct Node* node) {
    q->rear++;
    q->items[q->rear] = node;
}

struct Node* dequeue(struct Queue* q) {
    struct Node* node = q->items[q->front];
    q->front++;
    return node;
}

bool isEmpty(struct Queue* q) {
    return q->front > q->rear;
}

struct Node* build(int** grid, int n, int r1, int c1, int r2, int c2) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    
    if (r2 - r1 == 1) {
        node->val = (grid[r1][c1] == 1);
        node->isLeaf = true;
        node->topLeft = node->topRight = node->bottomLeft = node->bottomRight = NULL;
        return node;
    }
    
    int midR = (r1 + r2) / 2;
    int midC = (c1 + c2) / 2;
    
    struct Node* topLeft = build(grid, n, r1, c1, midR, midC);
    struct Node* topRight = build(grid, n, r1, midC, midR, c2);
    struct Node* bottomLeft = build(grid, n, midR, c1, r2, midC);
    struct Node* bottomRight = build(grid, n, midR, midC, r2, c2);
    
    if (topLeft->isLeaf && topRight->isLeaf && 
        bottomLeft->isLeaf && bottomRight->isLeaf &&
        topLeft->val == topRight->val && 
        topLeft->val == bottomLeft->val && 
        topLeft->val == bottomRight->val) {
        node->val = topLeft->val;
        node->isLeaf = true;
        node->topLeft = node->topRight = node->bottomLeft = node->bottomRight = NULL;
        return node;
    }
    
    node->val = true;
    node->isLeaf = false;
    node->topLeft = topLeft;
    node->topRight = topRight;
    node->bottomLeft = bottomLeft;
    node->bottomRight = bottomRight;
    
    return node;
}

void serialize(struct Node* root) {
    if (root == NULL) {
        printf("[]");
        return;
    }
    
    struct Queue* q = createQueue(1000);
    enqueue(q, root);
    
    printf("[");
    bool first = true;
    
    while (!isEmpty(q)) {
        struct Node* node = dequeue(q);
        
        if (!first) printf(",");
        first = false;
        
        printf("[%d,%d]", node->isLeaf ? 1 : 0, node->val ? 1 : 0);
        
        if (!node->isLeaf) {
            enqueue(q, node->topLeft);
            enqueue(q, node->topRight);
            enqueue(q, node->bottomLeft);
            enqueue(q, node->bottomRight);
        }
    }
    
    printf("]");
}

struct Node* solution(int** grid, int n) {
    return build(grid, n, 0, 0, n, n);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid = (int**)malloc(4 * sizeof(int*));
    for (int i = 0; i < 4; i++) {
        grid[i] = (int*)malloc(4 * sizeof(int));
    }
    
    sscanf(line, "[[%d,%d],[%d,%d]]", &grid[0][0], &grid[0][1], &grid[1][0], &grid[1][1]);
    
    struct Node* result = solution(grid, 2);
    serialize(result);
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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