Find Kth Bit in Nth Binary String - Practice Coding Problems

Find Kth Bit in Nth Binary String - Problem

Find Kth Bit in Nth Binary String

You're given two positive integers n and k, and need to find the kth bit in a special binary string sequence.

The sequence follows a fascinating recursive pattern:
• S₁ = "0" (base case)
• Sᵢ = Sᵢ₋₁ + "1" + reverse(invert(Sᵢ₋₁)) for i > 1

Where:
• + denotes string concatenation
• invert(x) flips all bits (0→1, 1→0)
• reverse(x) reverses the string

Example sequence:
• S₁ = "0"
• S₂ = "0" + "1" + reverse(invert("0")) = "0" + "1" + "1" = "011"
• S₃ = "011" + "1" + reverse(invert("011")) = "011" + "1" + "001" = "0111001"
• S₄ = "0111001" + "1" + "0110001" = "011100110110001"

Goal: Return the kth bit (1-indexed) in Sₙ efficiently without building the entire string.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 1

› Output: "0"

💡 Note: S₃ = "0111001". The 1st bit is '0'.

example_2.py — Middle Position

$ Input: n = 4, k = 11

› Output: "1"

💡 Note: S₄ = "011100110110001". The 11th bit is '1'. This demonstrates finding a bit in the right (inverted-reversed) section.

example_3.py — Edge Case

$ Input: n = 1, k = 1

› Output: "0"

💡 Note: S₁ = "0". The only bit is '0'. This is the base case.

Visualization

Tap to expand

Understanding the Visualization

Base Pattern

Start with S₁ = '0' as the foundation

Growth Rule

Each new generation: Previous + '1' + InvertedReversedPrevious

Structure Recognition

Every string has predictable left-middle-right sections

Smart Navigation

Find target without building entire string using recursive position mapping

Key Takeaway

🎯 Key Insight: The binary string follows a fractal pattern where each generation has a predictable three-part structure. By recognizing this pattern, we can navigate directly to any position using recursive divide-and-conquer without the exponential space and time costs of string building.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make at most n recursive calls, each doing constant work

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is n, or O(1) if implemented iteratively

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
1 ≤ k ≤ 2ⁿ - 1
k is guaranteed to be valid for the given n

Asked in

G Google 12 ⊞ Microsoft 8 a Amazon 6 f Meta 4

The optimal solution uses divide and conquer recursion to navigate the string structure without building it. Key insight: each string has three parts - left (previous generation), middle ('1'), and right (inverted-reversed previous). We determine which section contains our target and recursively solve with O(n) time and O(1) space (iterative version).

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer (Optimal)	O(n)	O(n)	Use recursion to navigate the string structure without building it
Brute Force (Build Complete String)	O(2ⁿ)	O(2ⁿ)	Build the complete string Sₙ iteratively and return the kth character

Divide and Conquer (Optimal) — Algorithm Steps

Calculate the length of Sₙ: length = 2ⁿ - 1
Find the middle position: mid = length / 2 + 1
If k == mid, return '1' (middle character)
If k < mid, recursively find bit in left part (Sₙ₋₁)
If k > mid, find corresponding position in right part:
- Map k to position in Sₙ₋₁: pos = length - k + 1
- Recursively get bit from Sₙ₋₁ at pos
- Return inverted bit ('0' → '1', '1' → '0')

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Structure

Each Sₙ has three parts: Sₙ₋₁ + '1' + reverse(invert(Sₙ₋₁))

Calculate Middle

Find middle position: (2ⁿ - 1) / 2 + 1

Route Decision

Determine if k is in left, middle, or right section

Recursive Call

Navigate to appropriate section with position mapping

Code -

solution.c — C

#include <stdio.h>

char helper(int n, int k) {
    // Base case
    if (n == 1) {
        return '0';
    }
    
    // Calculate length of Sn: 2^n - 1
    int length = (1 << n) - 1;
    int mid = length / 2 + 1;
    
    if (k == mid) {
        return '1';  // Middle character is always '1'
    } else if (k < mid) {
        // Left part: same as S(n-1)
        return helper(n - 1, k);
    } else {
        // Right part: inverted and reversed S(n-1)
        // Map k to corresponding position in S(n-1)
        int pos = length - k + 1;
        char bit = helper(n - 1, pos);
        // Return inverted bit
        return (bit == '1') ? '0' : '1';
    }
}

char findKthBit(int n, int k) {
    return helper(n, k);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make at most n recursive calls, each doing constant work

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is n, or O(1) if implemented iteratively

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
1 ≤ k ≤ 2ⁿ - 1
k is guaranteed to be valid for the given n

29.0K Views

Medium Frequency

~15 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Divide and Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler