Skip to content
Related Articles
Convert a number into negative base representation
• Difficulty Level : Medium
• Last Updated : 01 Jun, 2020

A number n and a negative base negBase is given to us, we need to represent n in that negative base. Negative base works similar to positive base. For example in base 2 we multiply bits to 1, 2, 4, 8 and so on to get actual number in decimal. In case of base -2 we need to multiply bits with 1, -2, 4, -8 and so on to get number in decimal.

Examples:

```Input  : n = 13, negBase = -2
Output : 11101
1*(16) + 1*(-8) + 1*(4) + 0*(-2) + 1*(1)  = 13
```

It is possible to represent a number into any negative base with same procedure (Refer Wiki for details). For simplicity (to get rid of A, B etc characters in output), we are allowing our base to be in between -2 and -10 only.

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

We can solve this problem similar to solving problem with positive bases but one important thing to remember is, remainder will always be positive whether we work with positive base or negative base but in most compilers, the result of dividing a negative number by a negative number is rounded towards 0, usually leaving a negative remainder.
So whenever we get a negative remainder, we can convert it to positive as below,

```Let
n = (?negBase) * quotient + remainder
= (?negBase) * quotient + negBase ? negBase + negBase
= (?negBase) * (quotient + 1) + (remainder + negBase).

So if after doing "remainder = n % negBase" and
"n = n/negBase", we get negative remainder, we do
following.
remainder = remainder + (-negBase)
n = n + 1

Example : n = -4, negBase = -3
In C++, we get
remainder = n % negBase = -4/-3 = -1
n = n/negBase [Next step for base conversion]
= -4/-3
= 1
To avoid negative remainder, we do,
remainder = -1 + (-negBase) = -1 - (-3) = 2
n = n + 1 = 1  + 1 = 2.
```

So when we will get negative remainder, we will make it positive by adding absolute value of base to it and adding 1 to our quotient.

Above explained approach is implemented in below code,

## C++

 `//  C/C++ program to convert n into negative base form``#include ``using` `namespace` `std;`` ` `//  Utility method to convert integer into string``string toString(``int` `n)``{``    ``string str;``    ``stringstream ss;``    ``ss << n;``    ``ss >> str;``    ``return` `str;``}`` ` `// Method to convert n to base negBase``string toNegativeBase(``int` `n, ``int` `negBase)``{``    ``//  If n is zero then in any base it will be 0 only``    ``if` `(n == 0)``        ``return` `"0"``;`` ` `    ``string converted = ``""``;``    ``while` `(n != 0)``    ``{``        ``// Get remainder by negative base, it can be``        ``// negative also``        ``int` `remainder = n % negBase;``        ``n /= negBase;`` ` `        ``// if remainder is negative, add abs(base) to``        ``// it and add 1 to n``        ``if` `(remainder < 0)``        ``{``            ``remainder += (-negBase);``            ``n += 1;``        ``}`` ` `        ``// convert remainder to string add into the result``        ``converted = toString(remainder) + converted;``    ``}`` ` `    ``return` `converted;``}`` ` `//  Driver code to test above methods``int` `main()``{``    ``int` `n = 13;``    ``int` `negBase = -2;`` ` `    ``cout << toNegativeBase(n, negBase);`` ` `    ``return` `0;``}`

## Java

 `// Java program to convert n into ``// negative base form``class` `GFG``{`` ` `// Method to convert n to base negBase``static` `String toNegativeBase(``int` `n, ``int` `negBase)``{``    ``// If n is zero then in any base``    ``// it will be 0 only``    ``if` `(n == ``0``)``        ``return` `"0"``;`` ` `    ``String converted = ``""``;``    ``while` `(n != ``0``)``    ``{``        ``// Get remainder by negative base, ``        ``// it can be negative also``        ``int` `remainder = n % negBase;``        ``n /= negBase;`` ` `        ``// if remainder is negative, ``        ``// add Math.abs(base) to it ``        ``// and add 1 to n``        ``if` `(remainder < ``0``)``        ``{``            ``remainder += (-negBase);``            ``n += ``1``;``        ``}`` ` `        ``// convert remainder to String add into the result``        ``converted = String.valueOf(remainder) + converted;``    ``}``    ``return` `converted;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``13``;``    ``int` `negBase = -``2``;`` ` `    ``System.out.print(toNegativeBase(n, negBase));``}``}`` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program to convert n into ``# negative base form`` ` `# Method to convert n to base negBase``def` `toNegativeBase(n, negBase):``     ` `    ``# If n is zero then in any base it ``    ``# will be 0 only``    ``if` `(n ``=``=` `0``):``        ``return` `"0"`` ` `    ``converted ``=` `"01"``    ``while` `(n !``=` `0``):``         ` `        ``# Get remainder by negative base, ``        ``# it can be negative also``        ``remainder ``=` `n ``%` `(negBase)``        ``n ``=` `int``(n``/``negBase)`` ` `        ``# if remainder is negative, add ``        ``# abs(base) to it and add 1 to n``        ``if` `(remainder < ``0``):``            ``remainder ``+``=` `((``-``1``) ``*` `negBase)``            ``n ``+``=` `1`` ` `        ``# convert remainder to string add``        ``# into the result``        ``converted ``=` `str``(remainder) ``+` `converted``         ` `    ``return` `converted`` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `13``    ``negBase ``=` `-``2`` ` `    ``print``(toNegativeBase(n, negBase))`` ` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# program to convert n into ``// negative base form``using` `System;`` ` `class` `GFG``{`` ` `// Method to convert n to base negBase``static` `String toNegativeBase(``int` `n, ``int` `negBase)``{``    ``// If n is zero then in any base``    ``// it will be 0 only``    ``if` `(n == 0)``        ``return` `"0"``;`` ` `    ``String converted = ``""``;``    ``while` `(n != 0)``    ``{``        ``// Get remainder by negative base, ``        ``// it can be negative also``        ``int` `remainder = n % negBase;``        ``n /= negBase;`` ` `        ``// if remainder is negative, ``        ``// add Math.Abs(base) to it ``        ``// and add 1 to n``        ``if` `(remainder < 0)``        ``{``            ``remainder += (-negBase);``            ``n += 1;``        ``}`` ` `        ``// convert remainder to String add into the result``        ``converted = String.Join(``""``, remainder) + converted;``    ``}``    ``return` `converted;``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 13;``    ``int` `negBase = -2;`` ` `    ``Console.Write(toNegativeBase(n, negBase));``}``}`` ` `// This code is contributed by Rajput-Ji`

Output:

```11101
```

Reference :
https://en.wikipedia.org/wiki/Negative_base

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.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up