Count and Say

Count and Say - Problem

String Medium

The count-and-say sequence is a sequence of digit strings defined by the recursive formula:

countAndSay(1) = "1"
countAndSay(n) is the run-length encoding of countAndSay(n - 1)

Run-length encoding (RLE) is a string compression method that works by replacing consecutive identical characters with the concatenation of the count and the character.

For example, to compress the string "3322251":

"33" becomes "23" (two 3's)
"222" becomes "32" (three 2's)
"5" becomes "15" (one 5)
"1" becomes "11" (one 1)

Thus the compressed string becomes "23321511".

Given a positive integer n, return the nth element of the count-and-say sequence.

Input & Output

Example 1 — Basic Case

$ Input: n = 1

› Output: "1"

💡 Note: Base case: countAndSay(1) is defined as "1"

Example 2 — Second Term

$ Input: n = 4

› Output: "1211"

💡 Note: countAndSay(1) = "1", countAndSay(2) = "11" (one 1), countAndSay(3) = "21" (two 1s), countAndSay(4) = "1211" (one 2, one 1)

Example 3 — Longer Sequence

$ Input: n = 5

› Output: "111221"

💡 Note: countAndSay(4) = "1211", so countAndSay(5) describes "1211" as "111221" (one 1, one 2, two 1s)

Constraints

1 ≤ n ≤ 30

Visualization

Tap to expand

Asked in

F Facebook 45 G Google 35

The key insight is to iteratively apply run-length encoding, counting consecutive identical characters and building the description string. The optimal approach uses StringBuilder for efficient string construction. Time: O(n×m), Space: O(m) where m is the result string length.

Common Approaches

✓ Stack

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

Iterative String Building

⏱️ Time: O(n × m) Space: O(m)

Start with "1" and iteratively apply run-length encoding n-1 times. For each step, scan the current string and count consecutive identical characters, then build the next string by concatenating count + character.

StringBuilder Approach

⏱️ Time: O(n × m) Space: O(m)

Same logic as brute force but uses StringBuilder (Java) or equivalent efficient string building methods to avoid the overhead of string concatenation. This reduces the constant factor in time complexity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(char* directions) {
    int n = strlen(directions);
    
    // Find leftmost R and rightmost L
    int leftmostR = -1;
    int rightmostL = -1;
    
    for (int i = 0; i < n; i++) {
        if (directions[i] == 'R' && leftmostR == -1) {
            leftmostR = i;
        }
        if (directions[i] == 'L') {
            rightmostL = i;
        }
    }
    
    // If no collision zone exists, return 0
    if (leftmostR == -1 || rightmostL == -1 || leftmostR >= rightmostL) {
        return 0;
    }
    
    // Count collisions in the collision zone
    int collisions = 0;
    for (int i = leftmostR; i <= rightmostL; i++) {
        if (directions[i] != 'S') {
            collisions++;
        }
    }
    
    return collisions;
}

int main() {
    char directions[100001];
    fgets(directions, sizeof(directions), stdin);
    directions[strcspn(directions, "\n")] = 0;
    
    int result = solution(directions);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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