Count K-Reducible Numbers Less Than N - Practice Coding Problems

Count K-Reducible Numbers Less Than N - Problem

You are given a binary string s representing a positive integer n in binary form, and an integer k.

A positive integer x is called k-reducible if you can reduce it to 1 by performing the following operation at most k times:

Replace x with the count of set bits (1s) in its binary representation.

Example walkthrough: Consider the number 6 with binary representation "110":

Operation 1: 6 → 2 (since "110" has 2 set bits)
Operation 2: 2 → 1 (since "10" has 1 set bit)

So 6 is 2-reducible because it takes exactly 2 operations to reach 1.

Your task is to count how many positive integers less than n are k-reducible. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: s = "111", k = 1

› Output: 3

💡 Note: Numbers less than 7 ("111"): 1,2,3,4,5,6. Check each: 1→0 steps (✓), 2→1 step (✓), 3→2 steps (✗), 4→2 steps (✗), 5→3 steps (✗), 6→2 steps (✗). Only 1,2,3 are 1-reducible, so answer is 3.

example_2.py — Higher k

$ Input: s = "1000", k = 2

› Output: 6

💡 Note: Numbers less than 8: 1,2,3,4,5,6,7. With k=2: 1→0 steps (✓), 2→1 step (✓), 3→2 steps (✓), 4→2 steps (✓), 5→3 steps (✗), 6→2 steps (✓), 7→3 steps (✗). So 1,2,3,4,6 are 2-reducible, answer is 6.

example_3.py — Edge Case

$ Input: s = "1", k = 1

› Output: 0

💡 Note: Numbers less than 1: none. Answer is 0.

Constraints

1 ≤ |s| ≤ 10⁵
s consists only of the digits '0' and '1'
s does not have leading zeros
1 ≤ k ≤ 10⁵
The binary string can represent numbers up to 2¹⁰⁰⁰⁰⁰

Asked in

The optimal solution uses digit dynamic programming combined with precomputed reduction steps. First, we calculate how many steps each possible bit count (1 to |s|) needs to reduce to 1. Then we use digit DP to count numbers less than n that have k-reducible bit counts, avoiding the need to check each number individually. This approach handles massive inputs efficiently with O(|s|² × 2) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DP with Combinatorics	O(\|s\|² × 2)	O(\|s\|²)	Combine bit count precomputation with optimized digit DP and combinatorial counting
Precomputation + Digit DP	O(\|s\| * \|s\| * 2)	O(\|s\| * \|s\|)	Precompute reduction steps for all possible bit counts, then use digit DP to count valid numbers

Optimized DP with Combinatorics — Algorithm Steps

Precompute reduction steps for bit counts 1 to |s|
Create a set of k-reducible bit counts
Initialize DP with states (position, current_bits, tight_constraint, started_flag)
For each position and digit choice, update bit count and constraints
Use memoization to avoid recomputing same states
Sum results for all k-reducible ending states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start at position 0 with 0 bits, tight=true

For Each Position

Choose digit 0 or 1 (constrained by tight flag)

Update State

Increment bit count if digit=1, update tight flag

Check End State

Count if final bit count is k-reducible

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 1005

char s[MAXN];
int n, k;
int reductionSteps[MAXN];
int kReducible[MAXN];
long long memo[MAXN][MAXN][2][2];
int memoSet[MAXN][MAXN][2][2];

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

long long solve(int pos, int bitCount, int isTight, int hasStarted) {
    // Base case: reached end of string
    if (pos == n) {
        return (hasStarted && kReducible[bitCount]) ? 1 : 0;
    }
    
    // Check memoization
    if (memoSet[pos][bitCount][isTight][hasStarted]) {
        return memo[pos][bitCount][isTight][hasStarted];
    }
    
    // Determine the maximum digit we can place
    int maxDigit = isTight ? (s[pos] - '0') : 1;
    long long result = 0;
    
    // Try placing each possible digit (0 or 1)
    for (int digit = 0; digit <= maxDigit; digit++) {
        int newBitCount = (hasStarted || digit == 1) ? bitCount + digit : 0;
        int newTight = isTight && (digit == maxDigit);
        int newStarted = hasStarted || (digit == 1);
        
        result = (result + solve(pos + 1, newBitCount, newTight, newStarted)) % MOD;
    }
    
    memoSet[pos][bitCount][isTight][hasStarted] = 1;
    return memo[pos][bitCount][isTight][hasStarted] = result;
}

long long countKReducible(char* binary, int maxK) {
    strcpy(s, binary);
    n = strlen(s);
    k = maxK;
    
    memset(kReducible, 0, sizeof(kReducible));
    memset(memoSet, 0, sizeof(memoSet));
    
    // Precompute reduction steps for each possible bit count
    for (int bits = 1; bits <= n; bits++) {
        int current = bits;
        int steps = 0;
        while (current > 1) {
            current = popcount(current);
            steps++;
        }
        reductionSteps[bits] = steps;
        
        // Add to k-reducible set if applicable
        if (steps <= k) {
            kReducible[bits] = 1;
        }
    }
    
    return solve(0, 0, 1, 0);
}

int main() {
    char s[MAXN];
    int k;
    scanf("%s %d", s, &k);
    
    // Remove quotes if present
    char* cleanS = s;
    if (s[0] == '"') cleanS++;
    int len = strlen(cleanS);
    if (cleanS[len-1] == '"') cleanS[len-1] = '\0';
    
    printf("%lld\n", countKReducible(cleanS, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(|s|² × 2)

Digit DP with O(|s|) positions, O(|s|) possible bit counts, and 2 boolean flags

✓ Linear Growth

Space Complexity

O(|s|²)

Memoization table for DP states plus precomputed reduction steps

✓ Linear Space

25.0K Views

Medium Frequency

~15 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