Powerful Integers - Practice Coding Problems

Powerful Integers - Problem

Given three integers x, y, and bound, return a list of all the powerful integers that have a value less than or equal to bound.

An integer is powerful if it can be represented as xⁱ + y^j for some integers i >= 0 and j >= 0.

You may return the answer in any order. In your answer, each value should occur at most once.

Input & Output

Example 1 — Basic Case

$ Input: x = 2, y = 3, bound = 10

› Output: [2,3,4,5,10]

💡 Note: Powers of 2: [1,2,4,8], Powers of 3: [1,3,9]. Valid sums ≤ 10: 1+1=2, 2+1=3, 1+3=4, 2+3=5, 1+9=10

Example 2 — Edge Case x=1

$ Input: x = 1, y = 2, bound = 5

› Output: [2,3,5]

💡 Note: x=1 means x^i=1 for all i. Powers of 2: [1,2,4]. Valid sums: 1+1=2, 1+2=3, 1+4=5

Example 3 — Small Bound

$ Input: x = 3, y = 5, bound = 15

› Output: [2,4,6,8,14]

💡 Note: Powers of 3: [1,3,9], Powers of 5: [1,5]. Valid sums ≤ 15: 1+1=2, 3+1=4, 1+5=6, 3+5=8, 9+5=14

Constraints

1 ≤ x, y ≤ 100
0 ≤ bound ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Given x=2, y=3, bound=10

Generate Powers

x powers: [1,2,4,8], y powers: [1,3,9]

Find Valid Sums

All combinations ≤ 10: [2,3,4,5,10]

Key Takeaway

🎯 Key Insight: Powers grow exponentially, limiting the search space to at most log(bound) values for each base

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is that powers grow exponentially, so we only need to check a limited range of exponents. The optimal approach uses nested loops with early termination and handles edge cases (x=1 or y=1) to avoid infinite loops. Time: O(log²(bound)), Space: O(log²(bound))

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Nested Loops	O(log²(bound))	O(log²(bound))	Generate all possible combinations of x^i + y^j until bound is exceeded
Optimized with Early Termination	O(log²(bound))	O(log²(bound))	Use hash set for uniqueness and optimize loop termination conditions

Brute Force with Nested Loops — Algorithm Steps

Initialize hash set for unique results
Outer loop: generate powers of x (x^i)
Inner loop: generate powers of y (y^j)
If x^i + y^j <= bound, add to set
Continue until sum exceeds bound

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty set for unique results

Nested Loops

Try all i,j combinations until sum > bound

Collect Results

Add valid sums to set and return sorted list

Code -

solution.c — C

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

#define MAX_RESULT 1000

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int x, int y, int bound, int* returnSize) {
    static int result[MAX_RESULT];
    bool seen[MAX_RESULT + 1] = {false};
    *returnSize = 0;
    
    // Handle edge case where x = 1
    if (x == 1) {
        int powerY = 1;
        while (powerY <= bound) {
            int sum = 1 + powerY;
            if (sum <= bound && sum <= MAX_RESULT && !seen[sum]) {
                seen[sum] = true;
                result[(*returnSize)++] = sum;
            }
            if (y == 1) break;
            powerY *= y;
        }
    }
    // Handle edge case where y = 1
    else if (y == 1) {
        int powerX = 1;
        while (powerX <= bound) {
            int sum = powerX + 1;
            if (sum <= bound && sum <= MAX_RESULT && !seen[sum]) {
                seen[sum] = true;
                result[(*returnSize)++] = sum;
            }
            powerX *= x;
        }
    }
    // General case where both x > 1 and y > 1
    else {
        int powerX = 1;
        while (powerX <= bound) {
            int powerY = 1;
            while (powerX + powerY <= bound) {
                int sum = powerX + powerY;
                if (sum <= MAX_RESULT && !seen[sum]) {
                    seen[sum] = true;
                    result[(*returnSize)++] = sum;
                }
                powerY *= y;
            }
            powerX *= x;
        }
    }
    
    qsort(result, *returnSize, sizeof(int), compare);
    return result;
}

int main() {
    int x, y, bound;
    scanf("%d", &x);
    scanf("%d", &y);
    scanf("%d", &bound);
    
    int returnSize;
    int* result = solution(x, y, bound, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log²(bound))

Nested loops run at most log_x(bound) × log_y(bound) times since powers grow exponentially

⚡ Linearithmic

Space Complexity

O(log²(bound))

Hash set stores at most O(log²(bound)) unique powerful integers

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

485 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 with Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler