# Balance pans using given weights that are powers of a number

Given a simple weighting scale with two pans, we are given a weight T and some other weights which are the powers of a specific number a, our goal is to balance these pans using the given weights. More formally we need to satisfy this equation,
T + (some power of a) = (some other powers of a)
Remember that we are given exactly one weight corresponding to one power.
Examples:

```T = 11    and  a = 4
Then scale can be balanced as,
11 + 4 + 1 = 16
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We can see that in this problem our first goal is to represent T in terms of powers of a so when we write T with the base of a, if representation has only 1s and 0s then we know that weight corresponding to 1s can make the T. For example,

```If T is 10 and a is 3 then representing 10 on
base of 3 we get 101 i.e. using 0th power of 3
and 2nd power of 3 (1 + 9)  we can get 10
```

Now if all digits of base representation are not 1 or 0, then we can’t balance the scale, except the case when in base representation some digit is (a – 1) because in that case, we can transfer corresponding power to T’s side and increase the left number in base representation by 1. For example,

```If T is 7 and a is 3 then representing 7 on base
3 we get 021.
Now while looping over representation from right
to left we get 2 (which is 3 - 1), in this case,
we can transfer corresponding power(3^1) to T’s
side and increase the left number by 1 i.e.,
T’s side 7 + 3 = 10    and representation 101 (9 + 1)
which has only 1s and 0s now, so scale can be balanced.
```

So now algorithm for solving this problem can be represented as follows, represent the T in base of a, if all digits of base representation are 1s or 0s, scale can be balanced otherwise loop from right side of the representation if any number is (a – 1) then increase left side number by 1, keep doing this and ignore 1, 0, (a – 1) and a cases in representation. If complete base representation is processed scale can be balanced otherwise not.

## C++

 `// C++ code to check whether scale can be balanced or not ` `#include ` `using` `namespace` `std; ` ` `  `// method returns true if balancing of scale is possible ` `bool` `isBalancePossible(``int` `T, ``int` `a) ` `{ ` `    ``// baseForm vector will store T's representation on ` `    ``// base a in reverse order ` `    ``vector<``int``> baseForm; ` ` `  `    ``// convert T to representation on base a ` `    ``while` `(T) { ` `        ``baseForm.push_back(T % a); ` `        ``T /= a; ` `    ``} ` ` `  `    ``// make first digit of representation as 0 ` `    ``baseForm.push_back(0); ` ` `  `    ``// loop over base representation of T ` `    ``for` `(``int` `i = 0; i < baseForm.size(); i++) { ` ` `  `        ``// if any digit is not 0, 1, (a - 1) or a  ` `        ``// then balancing is not possible ` `        ``if` `(baseForm[i] != 0 && baseForm[i] != 1 &&  ` `            ``baseForm[i] != (a - 1) && baseForm[i] != a)  ` `            ``return` `false``;         ` ` `  `        ``// if digit is a or (a - 1) then increase left ` `        ``// index's count/ (case, when this weight is  ` `        ``// transferred to T's side) ` `        ``if` `(baseForm[i] == a || baseForm[i] == (a - 1))  ` `            ``baseForm[i + 1] += 1;         ` `    ``} ` ` `  `    ``// if representation is processed then balancing  ` `    ``// is possible ` `    ``return` `true``; ` `} ` ` `  `// Driver code to test above methods ` `int` `main() ` `{ ` `    ``int` `T = 11; ` `    ``int` `a = 4; ` ` `  `    ``bool` `balancePossible = isBalancePossible(T, a); ` `    ``if` `(balancePossible)  ` `        ``cout << ``"Balance is possible"` `<< endl; ` `    ``else`  `        ``cout << ``"Balance is not possible"` `<< endl; ` `    ``return` `0; ` `} `

## Java

 `// Java code to check whether  ` `// scale can be balanced or not  ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// method returns true if balancing  ` `    ``// of scale is possible  ` `    ``static` `boolean` `isBalancePossible(``int` `T, ``int` `a)  ` `    ``{ ` `        ``// baseForm vector will store T's  ` `        ``// representation on base a ` `        ``// in reverse order  ` `        ``Vector baseForm = ``new` `Vector<>(); ` `        ``int` `s = ``0``; ` `         `  `        ``// convert T to representation on base a  ` `        ``while` `(T > ``0``)  ` `        ``{ ` `            ``baseForm.add(T % a); ` `            ``T /= a; ` `            ``s++; ` `        ``} ` ` `  `        ``// make first digit of representation as 0  ` `        ``baseForm.add(``0``); ` ` `  `        ``// loop over base representation of T  ` `        ``for` `(``int` `i = ``0``; i < s; i++)  ` `        ``{ ` `            ``// if any digit is not 0, 1, (a - 1) or a  ` `            ``// then balancing is not possible  ` `            ``if` `(baseForm.get(i) != ``0` `&&  ` `                ``baseForm.get(i) != ``1` `&&  ` `                ``baseForm.get(i) != (a - ``1``) &&  ` `                ``baseForm.get(i) != a)  ` `            ``{ ` `                ``return` `false``; ` `            ``} ` ` `  `            ``// if digit is a or (a - 1) then increase left  ` `            ``// index's count/ (case, when this weight is  ` `            ``// transferred to T's side)  ` `            ``if` `(baseForm.get(i) == a || baseForm.get(i) == (a - ``1``))  ` `            ``{ ` `                ``baseForm.add(i + ``1``, baseForm.get(i + ``1``) + ``1``); ` `            ``} ` `        ``} ` ` `  `        ``// if representation is processed   ` `        ``// then balancing is possible  ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `T = ``11``; ` `        ``int` `a = ``4``; ` ` `  `        ``boolean` `balancePossible = isBalancePossible(T, a); ` `        ``if` `(balancePossible)  ` `        ``{ ` `            ``System.out.println(``"Balance is possible"``); ` `        ``}  ` `        ``else` `        ``{ ` `            ``System.out.println(``"Balance is not possible"``); ` `        ``} ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## C#

 `// C# code to check whether  ` `// scale can be balanced or not ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG ` `{ ` ` `  `    ``// method returns true if balancing  ` `    ``// of scale is possible  ` `    ``static` `bool` `isBalancePossible(``int` `T, ``int` `a)  ` `    ``{ ` `        ``// baseForm vector will store T's  ` `        ``// representation on base a ` `        ``// in reverse order  ` `        ``List<``int``> baseForm = ``new` `List<``int``>(); ` `        ``int` `s = 0; ` `         `  `        ``// convert T to representation on base a  ` `        ``while` `(T > 0)  ` `        ``{ ` `            ``baseForm.Add(T % a); ` `            ``T /= a; ` `            ``s++; ` `        ``} ` ` `  `        ``// make first digit of representation as 0  ` `        ``baseForm.Add(0); ` ` `  `        ``// loop over base representation of T  ` `        ``for` `(``int` `i = 0; i < s; i++)  ` `        ``{ ` `            ``// if any digit is not 0, 1, (a - 1) or a  ` `            ``// then balancing is not possible  ` `            ``if` `(baseForm[i] != 0 &&  ` `                ``baseForm[i] != 1 &&  ` `                ``baseForm[i] != (a - 1) &&  ` `                ``baseForm[i] != a)  ` `            ``{ ` `                ``return` `false``; ` `            ``} ` ` `  `            ``// if digit is a or (a - 1) then increase left  ` `            ``// index's count/ (case, when this weight is  ` `            ``// transferred to T's side)  ` `            ``if` `(baseForm[i] == a || baseForm[i] == (a - 1))  ` `            ``{ ` `                ``baseForm.Insert(i + 1, baseForm[i+1] + 1); ` `            ``} ` `        ``} ` ` `  `        ``// if representation is processed  ` `        ``// then balancing is possible  ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `T = 11; ` `        ``int` `a = 4; ` ` `  `        ``bool` `balancePossible = isBalancePossible(T, a); ` `        ``if` `(balancePossible)  ` `        ``{ ` `            ``Console.WriteLine(``"Balance is possible"``); ` `        ``}  ` `        ``else` `        ``{ ` `            ``Console.WriteLine(``"Balance is not possible"``); ` `        ``} ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

## PHP

 ` `

Output:

```Balance is possible
```

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.