# Print all integers that are sum of powers of two given numbers

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2021

Given three non-negative integers x, y and bound, the task is to print all the powerful integer ? bound in sorted order.
A powerful integer is of the form xi + yj for all i, j ? 0.

Examples:

Input: x = 3, y = 5, bound = 10
Output: 2 4 6 8 10
30 + 50 = 1 + 1 = 2
30 + 51 = 1 + 5 = 6
31 + 50 = 3 + 1 = 4
31 + 51 = 3 + 5 = 8
32 + 50 = 9 + 1 = 10

Input: x = 2, y = 3, bound = 10
Output: 2 3 4 5 7 9 10

Approach: Initialize i = 0 for outer loop and j = 0 for inner loop, if xi = bound then break out of the outer loop (as adding any power of y to it will make it out of the bound). If xi + yj > bound then break out of the inner loop and in every other iteration of the inner loop, save xi + yj in a set to maintain a distinct and sorted list of the powerful integers. Print the contents of the set in the end.
To avoid calculating the powers of y again and again, all the powers of y can be pre-calculated and stored in a vector.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``  ` `// Function to print powerful integers``void` `powerfulIntegers(``int` `x, ``int` `y, ``int` `bound)``{``  ` `    ``// Set is used to store distinct numbers``    ``// in sorted order``    ``set<``int``> s;``    ``vector<``int``> powersOfY;``    ``int` `i;``  ` `    ``// Store all the powers of y < bound in a vector``    ``// to avoid calculating them again and again``    ``powersOfY.push_back(1);``    ``for` `(i = y; i < bound && y!= 1; i = i * y)``        ``powersOfY.push_back(i);``  ` `    ``i = 0;``    ``while` `(``true``) {``  ` `        ``// x^i``        ``int` `xPowI = ``pow``(x, i);``  ` `        ``for` `(``auto` `j = powersOfY.begin(); j != powersOfY.end(); ++j) {``            ``int` `num = xPowI + *j;``  ` `            ``// If num is within limits``            ``// insert it into the set``            ``if` `(num <= bound)``                ``s.insert(num);``  ` `            ``// Break out of the inner loop``            ``else``                ``break``;``        ``}``      ` `          ``// Adding any number to it``        ``// will be out of bounds``        ``if` `(xPowI >= bound || x == 1)``            ``break``;``      ` `        ``// Increment i``        ``i++;``    ``}``  ` `    ``// Print the contents of the set``    ``set<``int``>::iterator itr;``    ``for` `(itr = s.begin(); itr != s.end(); itr++) {``        ``cout << *itr << ``" "``;``    ``}``}``  ` `// Driver code``int` `main()``{``    ``int` `x = 2, y = 3, bound = 10;``  ` `    ``// Print powerful integers``    ``powerfulIntegers(x, y, bound);``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``import` `java.lang.Math;` `class` `GfG``{` `    ``// Function to print powerful integers``    ``static` `void` `powerfulIntegers(``int` `x,``                        ``int` `y, ``int` `bound)``    ``{``    ` `        ``// Set is used to store distinct numbers``        ``// in sorted order``        ``Set s = ``new` `HashSet<>();``        ``ArrayList powersOfY = ``new` `ArrayList<>();``        ``int` `i;``    ` `        ``// Store all the powers of y < bound in a vector``        ``// to avoid calculating them again and again``        ``powersOfY.add(``1``);``        ``for` `(i = y; i < bound && y != ``1``; i = i * y)``            ``powersOfY.add(i);``    ` `        ``i = ``0``;``        ``while` `(``true``)``        ``{``    ` `            ``// x^i``            ``int` `xPowI = (``int``)Math.pow((``double``)x, (``double``)i);``    ` `            ``for` `(``int` `j = ``0``; j < powersOfY.size(); ++j)``            ``{``                ``int` `num = xPowI + powersOfY.get(j);``    ` `                ``// If num is within limits``                ``// insert it into the set``                ``if` `(num <= bound)``                    ``s.add(num);``    ` `                ``// Break out of the inner loop``                ``else``                    ``break``;``            ``}``          ` `            ``// Adding any number to it``            ``// will be out of bounds``            ``if` `(xPowI >= bound || x == ``1``)``                ``break``;``          ` `            ``// Increment i``            ``i++;``        ``}``    ` `        ``// Print the contents of the set``        ``Iterator itr = s.iterator();``        ``while``(itr.hasNext())``        ``{``            ``System.out.print(itr.next() + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String []args)``    ``{``        ``int` `x = ``2``, y = ``1``, bound = ``10``;``    ` `        ``// Print powerful integers``        ``powerfulIntegers(x, y, bound);``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Function to print powerful integers``def` `powerfulIntegers(x, y, bound) :` `    ``# Set is used to store distinct``    ``# numbers in sorted order``    ``s ``=` `set``()``    ``powersOfY ``=` `[]` `    ``# Store all the powers of y < bound``    ``# in a vector to avoid calculating``    ``# them again and again``    ``powersOfY.append(``1``)``    ``i ``=` `y``    ``while` `i < bound ``and` `y!``=``1` `:``        ``powersOfY.append(i)``        ``i ``*``=` `y` `    ``i ``=` `0``    ``while` `(``True``) :` `        ``# x^i``        ``xPowI ``=` `pow``(x, i)``        ` `        ``for` `j ``in` `powersOfY :``            ``num ``=` `xPowI ``+` `j` `            ``# If num is within limits``            ``# insert it into the set``            ``if` `(num <``=` `bound) :``                ``s.add(num)` `            ``# Break out of the inner loop``            ``else` `:``                ``break``                ` `        ``# Adding any number to it``        ``# will be out of bounds``        ``if` `(xPowI >``=` `bound ``or` `x ``=``=` `1``) :``            ``break``            ` `        ``# Increment i``        ``i ``+``=` `1` `    ``# Print the contents of the set``    ``for` `itr ``in` `s :``        ``print``(itr, end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``x ``=` `2``    ``y ``=` `3``    ``bound ``=` `10` `    ``# Print powerful integers``    ``powerfulIntegers(x, y, bound)` `# This code is contributed by Ryuga`

## C#

 `// C# implementation of the approach``using` `System; ``using` `System.Linq;``using` `System.Collections.Generic; ``using` `System.Collections; ``  ` `class` `GFG``{``      ` `// Function to print powerful integers``static` `void` `powerfulIntegers(``int` `x, ``int` `y, ``int` `bound)``{``  ` `    ``// Set is used to store distinct numbers``    ``// in sorted order``    ``HashSet<``int``> s = ``new` `HashSet<``int``>(); ``    ``ArrayList powersOfY = ``new` `ArrayList();``    ``int` `i;``  ` `    ``// Store all the powers of y < bound in a vector``    ``// to avoid calculating them again and again``    ``powersOfY.Add(1);``    ``for` `(i = y; i < bound && y != 1; i = i * y)``        ``powersOfY.Add(i);``  ` `    ``i = 0;``    ``while` `(``true``) ``    ``{``  ` `        ``// x^i``        ``int` `xPowI = (``int``)Math.Pow(x, i);``  ` `        ``for` `(``int` `j = 0; j != powersOfY.Count; ++j) ``        ``{``            ``int` `num = xPowI + (``int``)powersOfY[j];``  ` `            ``// If num is within limits``            ``// insert it into the set``            ``if` `(num <= bound)``                ``s.Add(num);``  ` `            ``// Break out of the inner loop``            ``else``                ``break``;``        ``}``  ` `          ``// Adding any number to it``        ``// will be out of bounds``        ``if` `(xPowI >= bound || x == 1)``            ``break``;``      ` `        ``// Increment i``        ``i++;``    ``}``      ` `    ``int``[] ar = s.ToArray();``    ``Array.Sort(ar);``    ``s.Clear();``    ``s.UnionWith(ar);``          ` `    ``// Print the contents of the set``    ``foreach` `(``int` `t ``in` `s)``    ``{``        ``Console.Write( t + ``" "``);``    ``}``}``  ` `// Driver code``static` `void` `Main()``{``    ``int` `x = 2, y = 3, bound = 10;``  ` `    ``// Print powerful integers``    ``powerfulIntegers(x, y, bound);``}``}``  ` `// This code is contributed by mits`

## PHP

 `= ``\$bound` `|| ``\$x` `== 1)``            ``break``;` `        ``// Increment i``        ``\$i` `+= 1;``    ``}``    ` `    ``\$s` `= ``array_unique``(``\$s``);``    ``sort(``\$s``);``    ` `    ``// Print the contents of the set``    ``foreach` `(``\$s` `as` `&``\$itr``)``        ``print``(``\$itr` `. ``" "``);``}` `// Driver code``\$x` `= 2;``\$y` `= 3;``\$bound` `= 10;` `// Print powerful integers``powerfulIntegers(``\$x``, ``\$y``, ``\$bound``);` `// This code is contributed by chandan_jnu``?>`

## Javascript

 ``
Output:
`2 3 4 5 7 9 10`

My Personal Notes arrow_drop_up