Convert a number into negative base representation
Last Updated :
22 Jun, 2022
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.
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++
#include <bits/stdc++.h>
using namespace std;
string toString( int n)
{
string str;
stringstream ss;
ss << n;
ss >> str;
return str;
}
string toNegativeBase( int n, int negBase)
{
if (n == 0)
return "0" ;
string converted = "" ;
while (n != 0)
{
int remainder = n % negBase;
n /= negBase;
if (remainder < 0)
{
remainder += (-negBase);
n += 1;
}
converted = toString(remainder) + converted;
}
return converted;
}
int main()
{
int n = 13;
int negBase = -2;
cout << toNegativeBase(n, negBase);
return 0;
}
|
Java
class GFG
{
static String toNegativeBase( int n, int negBase)
{
if (n == 0 )
return "0" ;
String converted = "" ;
while (n != 0 )
{
int remainder = n % negBase;
n /= negBase;
if (remainder < 0 )
{
remainder += (-negBase);
n += 1 ;
}
converted = String.valueOf(remainder) + converted;
}
return converted;
}
public static void main(String[] args)
{
int n = 13 ;
int negBase = - 2 ;
System.out.print(toNegativeBase(n, negBase));
}
}
|
Python3
def toNegativeBase(n, negBase):
if (n = = 0 ):
return "0"
converted = "01"
while (n ! = 0 ):
remainder = n % (negBase)
n = int (n / negBase)
if (remainder < 0 ):
remainder + = (( - 1 ) * negBase)
n + = 1
converted = str (remainder) + converted
return converted
if __name__ = = '__main__' :
n = 13
negBase = - 2
print (toNegativeBase(n, negBase))
|
C#
using System;
class GFG
{
static String toNegativeBase( int n, int negBase)
{
if (n == 0)
return "0" ;
String converted = "" ;
while (n != 0)
{
int remainder = n % negBase;
n /= negBase;
if (remainder < 0)
{
remainder += (-negBase);
n += 1;
}
converted = String.Join( "" , remainder) + converted;
}
return converted;
}
public static void Main(String[] args)
{
int n = 13;
int negBase = -2;
Console.Write(toNegativeBase(n, negBase));
}
}
|
Javascript
<script>
function toNegativeBase(n, negBase)
{
if (n == 0)
return "0" ;
let converted = "01" ;
while (n != 0)
{
let remainder = (-1)*(Math.abs(n) % Math.abs(negBase));
n = parseInt(n/negBase);
if (remainder < 0)
{
remainder += ((-1)*negBase);
n += 1;
}
converted = remainder.toString() + converted;
}
return converted;
}
let n = 13;
let negBase = -2;
document.write(toNegativeBase(n, negBase), "</br>" );
</script>
|
Output:
11101
Time Complexity: O(N)
Auxiliary Space: O(1)
Reference :
https://en.wikipedia.org/wiki/Negative_base
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...