Count and Say - Practice Coding Problems

Count and Say - Problem

String Medium

The Count and Say sequence is a fascinating mathematical sequence that generates strings through a process called run-length encoding. Think of it as a game where you describe what you see in the previous term!

How it works:

countAndSay(1) = "1" (base case)
For any n > 1, countAndSay(n) is created by "reading aloud" the previous term countAndSay(n-1)

The Reading Process: Look at consecutive identical digits and say "count of digit"

Example walkthrough:

n=1: "1"
n=2: Read "1" → "one 1" → "11"
n=3: Read "11" → "two 1s" → "21"
n=4: Read "21" → "one 2, one 1" → "1211"
n=5: Read "1211" → "one 1, one 2, two 1s" → "111221"

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

Input & Output

example_1.py — Basic Case

$ Input: n = 4

› Output: "1211"

💡 Note: Sequence progression: 1 → 11 → 21 → 1211. The 4th term reads the 3rd term "21" as "one 2, one 1" which becomes "1211".

example_2.py — Base Case

$ Input: n = 1

› Output: "1"

💡 Note: The base case of the count-and-say sequence is always "1".

example_3.py — Extended Case

$ Input: n = 5

› Output: "111221"

💡 Note: The 5th term reads "1211" as "one 1, one 2, two 1s" which becomes "111221".

Constraints

1 ≤ n ≤ 30
String length grows exponentially - be mindful of memory usage
Only digits 1, 2, and 3 appear in the sequence (can be proven mathematically)

Visualization

Tap to expand

Understanding the Visualization

Start with "1"

The sequence always begins with the string "1"

Count Groups

Identify consecutive identical digits and count how many there are

Say What You See

For each group, say the count followed by the digit

Build Next Term

Concatenate all the count-digit pairs to form the next term

Key Takeaway

🎯 Key Insight: The Count and Say sequence is a perfect example of how simple rules can create complex patterns. Each term only depends on the previous one, making it an ideal iterative problem.

Asked in

f Meta 45 G Google 35 a Amazon 28 Apple 20

The Count and Say problem is solved by iteratively building each term from the previous one. Start with "1" and for each subsequent term, count consecutive identical digits and encode them as "count + digit". The key insight is that we only need the previous term to generate the next one, making this an iterative string processing problem with O(n × m) time complexity where m is the average string length.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative String Building	O(n * m²)	O(m)	Build each term by processing the previous term character by character

Iterative String Building — Algorithm Steps

Start with base case: countAndSay(1) = "1"
For each iteration from 2 to n, process the current string
Scan through each character and count consecutive identical characters
Build the next string by appending count + character for each group
Continue until we reach the nth term

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Start with n=1: "1"

First Transform

Read "1" as "one 1" → "11"

Second Transform

Read "11" as "two 1s" → "21"

Third Transform

Read "21" as "one 2, one 1" → "1211"

Code -

solution.c — C

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

char* countAndSay(int n) {
    if (n == 1) {
        char* result = malloc(2);
        strcpy(result, "1");
        return result;
    }
    
    char* current = malloc(2);
    strcpy(current, "1");
    
    for (int i = 2; i <= n; i++) {
        char* nextStr = malloc(10000); // Sufficient for the constraints
        int nextIdx = 0;
        int j = 0;
        int currentLen = strlen(current);
        
        while (j < currentLen) {
            int count = 1;
            char digit = current[j];
            
            // Count consecutive identical characters
            while (j + 1 < currentLen && current[j + 1] == digit) {
                count++;
                j++;
            }
            
            // Append count and digit
            nextStr[nextIdx++] = '0' + count;
            nextStr[nextIdx++] = digit;
            j++;
        }
        
        nextStr[nextIdx] = '\0';
        free(current);
        current = nextStr;
    }
    
    return current;
}

int main() {
    int n;
    scanf("%d", &n);
    char* result = countAndSay(n);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m²)

Where n is the input and m is the average length of strings. We iterate n times, and each iteration processes a string of length m with potentially costly string operations

✓ Linear Growth

Space Complexity

O(m)

Space for storing the current and next string, where m is the length of the current term

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.6K 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

Iterative String Building — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler