Convert Decimal To Hexa-Decimal including negative numbers

• Last Updated : 30 May, 2022

Given a number N in decimal format, the task is to convert it to the hexadecimal representation of N as a string. Negative numbers are stored in 2’s complement form.
Examples:

Input: N = 134
Output: 86
Explanation:
134 = 00000000000000000000000010001000 in 32 bit representation. Grouping in four-size chunks and converting each chunk to equivalent hexadecimal yields 88. Also, we can see 8*16 + 6 = 134. We will also get the same result by remainder technique discussed in other post.
Input: N = -1
Output: ffffffff

Approach:
The ides is to store negative numbers in a bigger size to trick the compiler to read it as positive instead of negative and then use the normal remainder technique. Store num in a u_int, size of u_it is greater, it will be positive since MSB is 0.

For Java there is no unsigned int data type. So in case of java, convert number to long and make the 32 higher bits as all zeroes. Idea remains the same as above.

num =  (long)Math.pow(2, 32) + num ;
Below is the implementation of the above approach:

C++

 `// C++ program to convert decimal``// to hexadecimal covering negative numbers` `#include ``using` `namespace` `std;` `// Function to convert decimal no.``// to hexadecimal number``string Hex(``int` `num)``{``    ``// map for decimal to hexa, 0-9 are``    ``// straightforward, alphabets a-f used``    ``// for 10 to 15.``    ``map<``int``, ``char``> m;` `    ``char` `digit = ``'0'``;``    ``char` `c = ``'a'``;` `    ``for` `(``int` `i = 0; i <= 15; i++) {``        ``if` `(i < 10) {``            ``m[i] = digit++;``        ``}``        ``else` `{``            ``m[i] = c++;``        ``}``    ``}` `    ``// string to be returned``    ``string res = ``""``;` `    ``// check if num is 0 and directly return "0"``    ``if` `(!num) {``        ``return` `"0"``;``    ``}``    ``// if num>0, use normal technique as``    ``// discussed in other post``    ``if` `(num > 0) {``        ``while` `(num) {``            ``res = m[num % 16] + res;``            ``num /= 16;``        ``}``    ``}``    ``// if num<0, we need to use the elaborated``    ``// trick above, lets see this``    ``else` `{``        ``// store num in a u_int, size of u_it is greater,``        ``// it will be positive since msb is 0``        ``u_int n = num;` `        ``// use the same remainder technique.``        ``while` `(n) {``            ``res = m[n % 16] + res;``            ``n /= 16;``        ``}``    ``}` `    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``int` `x = 134, y = -1, z = -234;` `    ``cout << ``"Hexa representation for"` `<< endl;``    ``cout << x << ``" is "` `<< Hex(x) << endl;``    ``cout << y << ``" is "` `<< Hex(y) << endl;``    ``cout << z << ``" is "` `<< Hex(z) << endl;` `    ``return` `0;``}`

Java

 `// Java program to convert decimal``// to hexadecimal covering negative numbers``import` `java.util.*;``import` `java.util.HashMap;``import` `java.util.Map;` `class` `GFG``{` `// Function to convert decimal no.``// to hexadecimal number``static` `String Hex(``int` `num)``{``    ``// map for decimal to hexa, 0-9 are``    ``// straightforward, alphabets a-f used``    ``// for 10 to 15.``    ` `    ``HashMap m = ``new` `HashMap();` `    ``char` `digit = ``'0'``;``    ``char` `c = ``'a'``;` `    ``for` `(``int` `i = ``0``; i <= ``15``; i++) {``        ``if` `(i < ``10``) {``            ``m.put(i, digit);``            ``digit++;``        ``}``        ``else` `{``            ``m.put(i, c);``            ``c++;``        ``}``    ``}` `    ``// string to be returned``    ``String res = ``""``;` `    ``// check if num is 0 and directly return "0"``    ``if` `(num == ``0``) {``        ``return` `"0"``;``    ``}``    ``// if num>0, use normal technique as``    ``// discussed in other post``    ``if` `(num > ``0``) {``        ``while` `(num != ``0``) {``            ``res = m.get(num % ``16``) + res;``            ``num /= ``16``;``        ``}``    ``}``    ``// if num<0, we need to use the elaborated``    ``// trick above, lets see this``    ``else` `{``        ``// store num in a u_int, size of u_it is greater,``        ``// it will be positive since msb is 0``        ``long` `n = num;``        ``num =  (``long``)Math.pow(``2``, ``32``) + num ;``        ``// use the same remainder technique.``        ``while` `(n != ``0``) {``            ``res = m.get(n % ``16``) + res;``            ``n /= ``16``;``        ``}``    ``}` `    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String []args)``{``    ``int` `x = ``134``, y = -``1``, z = -``234``;` `    ``System.out.println(``"Hexa representation for"` `);``    ``System.out.println(x +``" is "` `+ Hex(x));``    ``System.out.println( y +``" is "` `+ Hex(y));``    ``System.out.println( z + ``" is "` `+ Hex(z));   ``}``}` `// This code is contributed by chitranayal`

Python3

 `# Python3 program to convert decimal``# to hexadecimal covering negative numbers` `# Function to convert decimal no.``# to hexadecimal number``def` `Hex``(num) :` `    ``# map for decimal to hexa, 0-9 are``    ``# straightforward, alphabets a-f used``    ``# for 10 to 15.``    ``m ``=` `dict``.fromkeys(``range``(``16``), ``0``);` `    ``digit ``=` `ord``(``'0'``);``    ``c ``=` `ord``(``'a'``);` `    ``for` `i ``in` `range``(``16``) :``        ``if` `(i < ``10``) :``            ``m[i] ``=` `chr``(digit);``            ``digit ``+``=` `1``;``        ` `        ``else` `:``            ``m[i] ``=` `chr``(c);``            ``c ``+``=` `1` `    ``# string to be returned``    ``res ``=` `"";` `    ``# check if num is 0 and directly return "0"``    ``if` `(``not` `num) :``        ``return` `"0"``;` `    ``# if num>0, use normal technique as``    ``# discussed in other post``    ``if` `(num > ``0``) :``        ``while` `(num) :``            ``res ``=` `m[num ``%` `16``] ``+` `res;``            ``num ``/``/``=` `16``;``    ` `    ``# if num<0, we need to use the elaborated``    ``# trick above, lets see this``    ``else` `:``        ` `        ``# store num in a u_int, size of u_it is greater,``        ``# it will be positive since msb is 0``        ``n ``=` `num ``+` `2``*``*``32``;` `        ``# use the same remainder technique.``        ``while` `(n) :``            ``res ``=` `m[n ``%` `16``] ``+` `res;``            ``n ``/``/``=` `16``;` `    ``return` `res;` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``x ``=` `134``; y ``=` `-``1``; z ``=` `-``234``;` `    ``print``(``"Hexa representation for"``);``    ``print``(x, ``"is"``, ``Hex``(x));``    ``print``(y, ``"is"``, ``Hex``(y));``    ``print``(z, ``"is"``, ``Hex``(z));` `# This code is contributed by AnkitRai01`

C#

 `// C# program to convert decimal``// to hexadecimal covering negative numbers``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``// Function to convert decimal no.``  ``// to hexadecimal number``  ``static` `string` `Hex(``long` `num)``  ``{` `    ``// map for decimal to hexa, 0-9 are``    ``// straightforward, alphabets a-f used``    ``// for 10 to 15.``    ``IDictionary<``long``, ``char``> m``      ``= ``new` `Dictionary<``long``, ``char``>();` `    ``char` `digit = ``'0'``;``    ``char` `c = ``'a'``;` `    ``for` `(``int` `i = 0; i <= 15; i++) {``      ``if` `(i < 10) {``        ``m[i] = digit;``        ``digit++;``      ``}``      ``else` `{``        ``m[i] = c;``        ``c++;``      ``}``    ``}` `    ``// string to be returned``    ``string` `res = ``""``;` `    ``// check if num is 0 and directly return "0"``    ``if` `(num == 0) {``      ``return` `"0"``;``    ``}``    ``// if num>0, use normal technique as``    ``// discussed in other post``    ``if` `(num > 0) {``      ``while` `(num != 0) {``        ``res = m[num % 16] + res;``        ``num /= 16;``      ``}``    ``}``    ``// if num<0, we need to use the elaborated``    ``// trick above, lets see this``    ``else` `{``      ``// we shall convert num to a 32 bit number``      ``num = (``long``)Math.Pow(2, 32) + num;``      ``long` `n = num;``      ``// use the same remainder technique.``      ``while` `(n != 0) {``        ``res = m[n % 16] + res;``        ``n /= 16;``      ``}``    ``}` `    ``return` `res;``  ``}` `  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``long` `x = 134, y = -1, z = -234;` `    ``Console.WriteLine(``"Hexa representation for"``);``    ``Console.WriteLine(x + ``" is "` `+ Hex(x));``    ``Console.WriteLine(y + ``" is "` `+ Hex(y));``    ``Console.WriteLine(z + ``" is "` `+ Hex(z));``  ``}``}` `// this code is contributed by phasing17`

Javascript

 ``

Output:

```Hexa representation for
134 is 86
-1 is ffffffff
-234 is ffffff16```

Time Complexity: O(log16num)

Auxiliary Space: O(15)

My Personal Notes arrow_drop_up