K-th Symbol in Grammar

K-th Symbol in Grammar - Problem

We build a table of n rows (1-indexed). We start by writing 0 in the 1st row. Now in every subsequent row, we look at the previous row and replace each occurrence of 0 with 01, and each occurrence of 1 with 10.

For example, for n = 3, the 1st row is 0, the 2nd row is 01, and the 3rd row is 0110.

Given two integers n and k, return the k-th (1-indexed) symbol in the n-th row of a table of n rows.

Input & Output

Example 1 — Basic Case

$ Input: n = 1, k = 1

› Output: 0

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

Example 2 — Second Row

$ Input: n = 2, k = 1

› Output: 0

💡 Note: Row 2 is "01" (from "0" → "01"), so the 1st symbol is 0

Example 3 — Fourth Row

$ Input: n = 4, k = 5

› Output: 1

💡 Note: Row 4 is "01101001" (0→01, 1→10, 1→10, 0→01), so the 5th symbol is 1

Constraints

1 ≤ n ≤ 30
1 ≤ k ≤ 2^n-1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is recognizing that the grammar table forms a binary tree structure where each position's value depends on its parent. The most efficient approach uses recursion with parent-child relationships - find the parent position in the previous row and apply the transformation rule based on whether the current position is a left or right child. Time: O(n), Space: O(n) due to recursion depth.

Common Approaches

✓ Bit Manipulation

⏱️ Time: O(log k) Space: O(1)

The key insight is that the k-th symbol in row n depends on the number of 1-bits in the binary representation of (k-1). If the count is even, return 0; if odd, return 1.

Build Complete Rows

⏱️ Time: O(2ⁿ) Space: O(2ⁿ)

Start with row 1 as "0", then build each subsequent row by replacing 0→01 and 1→10. Continue until we have row n, then return the k-th character.

Mathematical Pattern

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

Treat the grammar as a binary tree where each node generates two children. The k-th symbol in row n corresponds to a path in this tree. Use bit manipulation to trace this path efficiently.

Bit Manipulation — Algorithm Steps

Convert (k-1) to binary representation
Count the number of 1-bits in this binary representation
If count is even, return 0; if count is odd, return 1
This works because each 1-bit represents a 'flip' operation in the generation process

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert

Convert (k-1) to binary representation

Count

Count the number of 1-bits

Result

Even count → 0, Odd count → 1

Code -

solution.c — C

#include <stdio.h>

int solution(int n, int k) {
    // Count number of 1s in binary representation of (k-1)
    int count = 0;
    int num = k - 1;
    while (num > 0) {
        count += num & 1;
        num >>= 1;
    }
    // If count is even, return 0; if odd, return 1
    return count % 2;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log k)

We count bits in (k-1), which takes O(log k) time since k-1 has at most log k bits

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to count bits

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Bit Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler