K-th Symbol in Grammar - Practice Coding Problems

K-th Symbol in Grammar - Problem

The K-th Symbol in Grammar is a fascinating recursive pattern problem that explores how simple rules can generate complex sequences.

Imagine a magical grammar system that starts with a single 0 in the first row. Each subsequent row is generated by applying these transformation rules to the previous row:
• Replace every 0 with 01
• Replace every 1 with 10

This creates an expanding pattern:
• Row 1: 0
• Row 2: 01
• Row 3: 0110
• Row 4: 01101001

Your task: Given integers n and k, find the k-th symbol (1-indexed) in the n-th row without generating the entire string. Can you discover the mathematical pattern hidden within this seemingly chaotic expansion?

Input & Output

example_1.py — Simple Case

$ Input: n = 1, k = 1

› Output: 0

💡 Note: Row 1 contains only '0', so the 1st symbol is 0

example_2.py — Second Row

$ Input: n = 2, k = 1

› Output: 0

💡 Note: Row 2 is '01', so the 1st symbol is 0

example_3.py — Larger Example

$ Input: n = 4, k = 5

› Output: 1

💡 Note: Row 4 is '01101001', so the 5th symbol is 1

Constraints

1 ≤ n ≤ 30
1 ≤ k ≤ 2^n-1
Note: The n-th row has exactly 2^n-1 symbols

Visualization

Tap to expand

Understanding the Visualization

Root Level

Start with '0' at the root (Row 1)

First Expansion

0 becomes 01 (Row 2)

Pattern Recognition

Each level doubles and shows the complement pattern

Path Tracing

Find the k-th position by tracing the tree path

Key Takeaway

🎯 Key Insight: The grammar follows a recursive binary tree structure where each level doubles in size, and the right half is always the complement of the left half. This allows us to solve the problem in O(n) time without generating the exponentially large strings.

Asked in

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

The optimal solution uses recursive pattern recognition to solve this problem in O(n) time and space. The key insight is that each row consists of the previous row followed by its bitwise complement. By determining which half contains our target position, we can recursively solve smaller subproblems without generating the entire sequence.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Build Each Row)	O(2^n)	O(2^n)	Generate each row by applying the transformation rules until we reach row n
Recursive Mathematical Pattern	O(n)	O(n)	Use recursive relationships to find the k-th symbol without building the entire row

Brute Force (Build Each Row) — Algorithm Steps

Start with row 1 containing just '0'
For each subsequent row, scan the previous row character by character
Replace each '0' with '01' and each '1' with '10' to build the new row
Repeat until we reach row n
Return the k-th character (1-indexed) from row n

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Row 1

Begin with '0' as the first row

Apply Transformations

Replace each '0' with '01' and each '1' with '10'

Build Row 2

'0' becomes '01'

Continue Building

Repeat the process for each subsequent row

Extract Result

Find the k-th character in the n-th row

Code -

solution.c — C

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

int kthGrammar(int n, int k) {
    if (n == 1) return 0;
    
    char* currentRow = malloc(2);
    strcpy(currentRow, "0");
    
    for (int i = 2; i <= n; i++) {
        int len = strlen(currentRow);
        char* nextRow = malloc(len * 2 + 1);
        nextRow[0] = '\0';
        
        for (int j = 0; j < len; j++) {
            if (currentRow[j] == '0') {
                strcat(nextRow, "01");
            } else {
                strcat(nextRow, "10");
            }
        }
        
        free(currentRow);
        currentRow = nextRow;
    }
    
    int result = currentRow[k - 1] - '0';
    free(currentRow);
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d\n", kthGrammar(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each row doubles in size, so we process 2^0 + 2^1 + ... + 2^(n-1) = 2^n - 1 characters total

⚠ Quadratic Growth

Space Complexity

O(2^n)

The n-th row contains 2^(n-1) characters, requiring exponential space

⚠ Quadratic Space

73.9K Views

Medium Frequency

~15 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Build Each Row) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler