Maximum Number That Sum of the Prices Is Less Than or Equal to K

Maximum Number That Sum of the Prices Is Less Than or Equal to K - Problem

Imagine you're a data analyst working with binary representations of numbers, and each number has a "price" based on specific bit positions!

Given two integers k and x, you need to find the greatest number whose accumulated price doesn't exceed k.

How is the price calculated?

For any number num, its price equals the count of set bits (1s) at positions x, 2x, 3x, etc. in its binary representation
Bit positions are counted from the right, starting at position 1 (least significant bit)

Example: If x = 2 and num = 13 (binary: 1101):
We check positions 2, 4, 6, 8... → bits at positions 2 and 4 are both 1 → price = 2

The accumulated price of a number num is the sum of prices of all numbers from 1 to num. Find the largest number whose accumulated price ≤ k.

Input & Output

example_1.py — Basic Example

$ Input: k = 9, x = 1

› Output: 6

💡 Note: With x=1, we count all set bits. Numbers 1-6 have accumulated price: 1(1)+2(1)+3(2)+4(1)+5(2)+6(2)=9, which equals k. Number 7 would add 3 more (binary 111), exceeding k.

example_2.py — Every Second Position

$ Input: k = 7, x = 2

› Output: 9

💡 Note: With x=2, we only count bits at positions 2,4,6,... The accumulated price up to 9 is exactly 7, but adding number 10 (binary 1010, contributes 1) would make it 8, exceeding k.

example_3.py — Large Gap

$ Input: k = 1, x = 8

› Output: 255

💡 Note: With x=8, only position 8 matters. Numbers 1-255 have no bit at position 8 (need ≥256), so accumulated price is 0. Number 256 (binary 100000000) contributes 1, making total 1.

Visualization

Tap to expand

Understanding the Visualization

Set Up Sensors

Place sensors at positions x, 2x, 3x, ... in the binary representation

Calculate Individual Price

For each number, count how many sensors detect '1' bits

Accumulate Costs

Sum up prices from number 1 to current number

Binary Search

Use binary search to find the maximum number within budget k

Key Takeaway

🎯 Key Insight: Binary search + digit DP transforms an O(n log n) problem into O(log³ n), making it feasible for k up to 10^15!

Time & Space Complexity

Time Complexity

⏱️

O(n × log n)

n iterations where n is the answer, and log n time to count bits for each number

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ k ≤ 10¹⁵
1 ≤ x ≤ 8
k can be very large, making brute force infeasible
x is small, making digit DP manageable

Asked in

B ByteDance 15 G Google 12 ⊞ Microsoft 8 a Amazon 6

The optimal solution uses binary search on the answer combined with digit dynamic programming. Since accumulated prices increase monotonically, we can binary search for the maximum number whose accumulated price ≤ k. The key insight is using digit DP to efficiently calculate accumulated prices in O(log²n) time rather than O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n × log n)	O(1)	Check each number sequentially until accumulated price exceeds k
Binary Search on Answer (Optimal)	O(log²n × log n)	O(log n)	Use binary search to find the maximum number with accumulated price ≤ k

Brute Force (Linear Search) — Algorithm Steps

Initialize accumulated_price = 0 and current_num = 1
For each number, count set bits at positions x, 2x, 3x, ...
Add this price to accumulated_price
If accumulated_price > k, return current_num - 1
Otherwise, increment current_num and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with num=1, accumulated_price=0

Calculate Price

Count set bits at positions x, 2x, 3x for current number

Check Budget

Add price to accumulated total, check if it exceeds k

Continue or Stop

If within budget, move to next number; otherwise return previous

Code -

solution.c — C

#include <stdio.h>

long long getPrice(long long num, int x) {
    long long price = 0;
    int pos = x;
    while (pos <= 64) {
        if (num & (1LL << (pos - 1))) {
            price++;
        }
        pos += x;
    }
    return price;
}

long long findMaximumNumber(long long k, int x) {
    long long accumulatedPrice = 0;
    long long num = 1;
    
    while (1) {
        long long price = getPrice(num, x);
        if (accumulatedPrice + price > k) {
            return num - 1;
        }
        accumulatedPrice += price;
        num++;
    }
}

int main() {
    long long k;
    int x;
    scanf("%lld %d", &k, &x);
    printf("%lld\n", findMaximumNumber(k, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log n)

n iterations where n is the answer, and log n time to count bits for each number

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ k ≤ 10¹⁵
1 ≤ x ≤ 8
k can be very large, making brute force infeasible
x is small, making digit DP manageable

23.4K Views

Medium Frequency

~35 min Avg. Time

487 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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler