Convert Decimal To Hexa-Decimal including negative numbers

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: 88

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 + 8 = 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.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to convert decimal
// to hexadecimal covering negative numbers
  
#include <bits/stdc++.h>
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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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<Integer, Character> m = new HashMap<Integer, Character>(); 


  


    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 


        int n = 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 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none











Output:


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







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.





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
Coding_Grounds
Check out this Author's contributed articles.
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 Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.


Improved By :  AnkitRai01, chitranayal