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 xi + yj for some integers i &gt;= 0 and j &gt;= 0.

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

&nbsp;
Example 1:

Input: x = 2, y = 3, bound = 10
Output: [2,3,4,5,7,9,10]
Explanation:
2 = 20 + 30
3 = 21 + 30
4 = 20 + 31
5 = 21 + 31
7 = 22 + 31
9 = 23 + 30
10 = 20 + 32


Example 2:

Input: x = 3, y = 5, bound = 15
Output: [2,4,6,8,10,14]


&nbsp;
Constraints:


	1 &lt;= x, y &lt;= 100
	0 &lt;= bound &lt;= 106


from math import log
class Solution:
    def powerfulIntegers(self, x: int, y: int, bound: int) -> List[int]:
        if bound == 0:
            return []
        maxi = int(log(bound,max(x,2))) +1
        maxj = int(log(bound,max(y,2))) +1
        L = set()
        for i in range(maxi):
            for j in range(maxj):
                if (t:=x**i +y**j) <= bound:
                    L.add(t)
                else:
                    break
        return list(L)
class Solution {
    public List<Integer> powerfulIntegers(int x, int y, int bound) {
        HashSet<Integer> set = new HashSet<>();
        for(int i = 1; i<bound; i*=x){
            for(int j = 1; i+j <= bound; j*=y){
                set.add(i+j);
                if(y==1) break;
            }
            if(x==1) break;
        }
        return new ArrayList<>(set);
    }
}
class Solution {
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        unordered_set<int> s;
       
        for(int i=0; pow(x, i)<=bound; i++) {
            for(int j=0; pow(x, i) + pow(y, j)<=bound; j++) {
                s.insert(pow(x, i) + pow(y, j));
                if(y == 1) break;
            }
            if(x == 1) break;
        }
        return vector<int> (s.begin(), s.end());
    }
};
var powerfulIntegers = function(x, y, bound) {
    let ans = new Set()
    for (let xi = 1; xi < bound; xi *= x) {
        for (let yj = 1; xi + yj <= bound; yj *= y) {
            ans.add(xi + yj)
            if (y === 1) break
        }
        if (x === 1) break
    }
    return Array.from(ans)
}
Powerful Integers