Count K-Reducible Numbers Less Than N

Count K-Reducible Numbers Less Than N - Problem

You are given a binary string s representing a number n in its binary form. You are also given an integer k.

An integer x is called k-reducible if performing the following operation at most k times reduces it to 1:

Replace x with the count of set bits in its binary representation.

For example, the binary representation of 6 is "110". Applying the operation once reduces it to 2 (since "110" has two set bits). Applying the operation again to 2 (binary "10") reduces it to 1 (since "10" has one set bit).

Return an integer denoting the number of positive integers less than n that are k-reducible. Since the answer may be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: n = 7 in decimal. Check numbers 1-6: 1 (already 1, 0 steps ≤ 1), 2 (binary "10", 1 bit → 1, 1 step ≤ 1), 3 (binary "11", 2 bits → 2 → 1, 2 steps > 1), 4 (binary "100", 1 bit → 1, 1 step ≤ 1), 5 (binary "101", 2 bits → 2 → 1, 2 steps > 1), 6 (binary "110", 2 bits → 2 → 1, 2 steps > 1). Numbers 1, 2, and 4 are 1-reducible. Answer is 3.

Example 2 — Larger k

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

› Output: 6

💡 Note: n = 8 in decimal. Check 1-7: All numbers 1-7 can be reduced to 1 in at most 2 steps, except maybe some. Most small numbers are 2-reducible, so answer is 6.

Example 3 — Small Case

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

› Output: 2

💡 Note: n = 3 in decimal. Check 1,2: 1 needs 0 steps, 2 needs 1 step (2→1). Both are 1-reducible.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only '0' and '1'
s does not have leading zeros
1 ≤ k ≤ 5

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12

The key insight is that most numbers reduce to 1 very quickly, so we can precompute reduction steps for all possible bit counts and use digit DP to count efficiently. The memoized approach with digit DP is optimal: Time: O(n × b), Space: O(n × b)

Common Approaches

✓ Brute Force Simulation

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

For each number less than n, convert to binary, count set bits repeatedly until reaching 1, and check if it takes at most k steps.

Memoized Reduction with Digit DP

⏱️ Time: O(n × b) Space: O(n × b)

First precompute how many steps each possible bit count takes to reduce to 1. Then use digit DP to count numbers less than n with specific bit counts.

Brute Force Simulation — Algorithm Steps

Convert binary string s to decimal n
For each number from 1 to n-1, simulate reduction
Count set bits repeatedly until reaching 1
Count numbers that reduce in ≤ k steps

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Input

Convert binary string to decimal

Test Each Number

For each i from 1 to n-1, simulate reduction

Count Valid

Count numbers that reduce in ≤ k steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 100
#define MAXMEMO 100000

static int reduction[MAXN];

typedef struct {
    int pos, bits;
    int tight, started;
    int result;
    int used;
} MemoEntry;

static MemoEntry memo[MAXMEMO];
static int memoSize = 0;

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

int computeReductionSteps(int bits, int k) {
    if (bits == 1) return 0;
    int steps = 1;
    while (bits != 1) {
        bits = countBits(bits);
        steps++;
        if (steps > k + 1) return steps;
    }
    return steps - 1;
}

int findMemo(int pos, int bits, int tight, int started) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].bits == bits && 
            memo[i].tight == tight && memo[i].started == started && memo[i].used) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, int bits, int tight, int started, int result) {
    if (memoSize < MAXMEMO) {
        memo[memoSize].pos = pos;
        memo[memoSize].bits = bits;
        memo[memoSize].tight = tight;
        memo[memoSize].started = started;
        memo[memoSize].result = result;
        memo[memoSize].used = 1;
        memoSize++;
    }
}

int dp(char* s, int pos, int bits, int tight, int started, int k, int n) {
    if (pos == n) {
        if (!started) return 0;
        return reduction[bits] <= k ? 1 : 0;
    }
    
    int cached = findMemo(pos, bits, tight, started);
    if (cached != -1) return cached;
    
    int limit = tight ? (s[pos] - '0') : 1;
    int result = 0;
    
    for (int digit = 0; digit <= limit; digit++) {
        int newBits = bits + digit;
        int newTight = tight && (digit == limit);
        int newStarted = started || (digit == 1);
        
        result = (result + dp(s, pos + 1, newBits, newTight, newStarted, k, n)) % MOD;
    }
    
    addMemo(pos, bits, tight, started, result);
    return result;
}

int solution(char* s, int k) {
    int n = strlen(s);
    
    for (int i = 1; i <= n; i++) {
        reduction[i] = computeReductionSteps(i, k);
    }
    
    memoSize = 0;
    return dp(s, 0, 0, 1, 0, k, n);
}

int main() {
    char s[1000];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log n)

Check n numbers, each takes O(log n) steps to reduce

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for counting

✓ Linear Space

8.5K Views

Medium Frequency

~45 min Avg. Time

245 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler