Powerful Integers - Practice Coding Problems

Powerful Integers - Problem

Imagine you're a mathematician exploring the fascinating world of powerful integers! 🔢

Given three integers x, y, and bound, your mission is to find all the powerful integers that don't exceed the given boundary. A number is considered powerful if it can be expressed as xⁱ + y^j where both i and j are non-negative integers (≥ 0).

Your Goal: Return a list of all unique powerful integers ≤ bound. The order doesn't matter, but each value should appear only once in your result.

Example: If x=2, y=3, and bound=10, then:

2⁰ + 3⁰ = 1 + 1 = 2
2¹ + 3⁰ = 2 + 1 = 3
2⁰ + 3¹ = 1 + 3 = 4
And so on...

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Powerful integers: 2^0+3^0=2, 2^1+3^0=3, 2^0+3^1=4, 2^2+3^0=5, 2^1+3^1=7, 2^0+3^2=9, 2^1+3^2=10. Note that 2^2+3^1=7 is duplicate.

example_2.py — Edge Case with 1

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

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

💡 Note: Valid combinations: 3^0+5^0=2, 3^1+5^0=4, 3^0+5^1=6, 3^2+5^0=10, 3^1+5^1=8, 3^0+5^2=26 (too big), but we get [2,4,6,8,10,14] after removing duplicates.

example_3.py — Small Bound

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

› Output: [2, 3, 5, 9]

💡 Note: Since y=1, all y^j=1. So we get: 1+1=2, 2+1=3, 4+1=5, 8+1=9, 16+1=17 (exceeds bound).

Visualization

Tap to expand

Understanding the Visualization

Generate X Powers

Create all powers x^i that don't exceed the bound

Generate Y Powers

Create all powers y^j that don't exceed the bound

Combine Powers

Try all combinations of x^i + y^j within the bound

Collect Unique Results

Use a set to automatically handle duplicates

Key Takeaway

🎯 Key Insight: Since powers grow exponentially, there are only logarithmically many combinations to check, making this algorithm very efficient even for large bounds!

Time & Space Complexity

Time Complexity

⏱️

O(log(bound)²)

We generate at most log(bound) powers for both x and y, then combine them in O(log²(bound)) operations

⚡ Linearithmic

Space Complexity

O(log(bound)²)

We store the powers lists and result set, each containing at most O(log(bound)) elements

⚡ Linearithmic Space

Constraints

1 ≤ x, y ≤ 100
0 ≤ bound ≤ 10⁶
Important: Handle cases where x = 1 or y = 1 to avoid infinite loops
Each powerful integer should appear at most once in the result

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a hash set approach with pre-computed powers. Key insights: (1) Powers grow exponentially, so there are at most log(bound) valid exponents, (2) Handle x=1 or y=1 cases to avoid infinite loops, (3) Use a set to automatically eliminate duplicates. Time complexity is O(log²(bound)).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Set (Optimal)	O(log(bound)²)	O(log(bound)²)	Generate powers efficiently with early termination and duplicate handling
Brute Force (Nested Loops)	O(log(bound)²)	O(log(bound)²)	Generate all possible combinations of x^i + y^j until they exceed bound

Optimized Hash Set (Optimal) — Algorithm Steps

Generate all powers of x that are ≤ bound and store in a list
Generate all powers of y that are ≤ bound and store in a list
Use nested loops to combine each x^i with each y^j
Check if their sum is ≤ bound before adding to result
Use a set to automatically handle duplicates
Return the list of unique powerful integers

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate X Powers

Create list of all x^i ≤ bound

Generate Y Powers

Create list of all y^j ≤ bound

Combine Efficiently

Try all combinations from pre-computed lists

Collect Results

Use set to store unique powerful integers

Code -

solution.c — C

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

int* powerfulIntegers(int x, int y, int bound, int* returnSize) {
    // Generate powers of x
    int xPowers[50], xCount = 0;
    for (int power = 1; power <= bound; power *= x) {
        xPowers[xCount++] = power;
        if (x == 1) break;
    }
    
    // Generate powers of y
    int yPowers[50], yCount = 0;
    for (int power = 1; power <= bound; power *= y) {
        yPowers[yCount++] = power;
        if (y == 1) break;
    }
    
    // Combine and collect unique results
    int* temp = (int*)malloc(1000 * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < xCount; i++) {
        for (int j = 0; j < yCount; j++) {
            int sum = xPowers[i] + yPowers[j];
            if (sum <= bound) {
                // Check for duplicates
                int found = 0;
                for (int k = 0; k < count; k++) {
                    if (temp[k] == sum) {
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    temp[count++] = sum;
                }
            }
        }
    }
    
    *returnSize = count;
    return temp;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(bound)²)

We generate at most log(bound) powers for both x and y, then combine them in O(log²(bound)) operations

⚡ Linearithmic

Space Complexity

O(log(bound)²)

We store the powers lists and result set, each containing at most O(log(bound)) elements

⚡ Linearithmic Space

Constraints

1 ≤ x, y ≤ 100
0 ≤ bound ≤ 10⁶
Important: Handle cases where x = 1 or y = 1 to avoid infinite loops
Each powerful integer should appear at most once in the result

21.5K Views

Medium Frequency

~18 min Avg. Time

890 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

Optimized Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler