Dado un número N en formato decimal, la tarea es convertirlo a la representación hexadecimal de N como una string. Los números negativos se almacenan en forma de complemento a 2.
Ejemplos:
Entrada: N = 134
Salida: 86
Explicación:
134 = 00000000000000000000000010001000 en representación de 32 bits. Agrupando en fragmentos de cuatro tamaños y convirtiendo cada fragmento a rendimientos hexadecimales equivalentes, 88. Además, podemos ver 8*16 + 6 = 134. También obtendremos el mismo resultado mediante la técnica del resto discutida en otra publicación .
Entrada: N = -1
Salida: ffffffff
Enfoque:
El idus es almacenar números negativos en un tamaño más grande para engañar al compilador para que lo lea como positivo en lugar de negativo y luego use la técnica de resto normal. Guarde num en u_int, el tamaño de u_it es mayor, será positivo ya que MSB es 0.
Para Java no hay ningún tipo de datos int sin firmar. Entonces, en el caso de Java, convierta el número en largo y haga que los 32 bits más altos sean todos ceros. La idea sigue siendo la misma que la anterior.
num = (largo)Math.pow(2, 32) + num ;
A continuación se muestra la implementación del enfoque anterior:
C++
// 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;
}
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<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
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
<script>
// JavaScript program to convert decimal
// to hexadecimal covering negative numbers
// Function to convert decimal no.
// to hexadecimal number
function Hex(num)
{
// map for decimal to hexa, 0-9 are
// straightforward, alphabets a-f used
// for 10 to 15.
let m = new Map();
let digit = '0'.charCodeAt(0);
let c = 'a'.charCodeAt(0);
for (let i = 0; i <= 15; i++) {
if (i < 10) {
m.set(i, String.fromCharCode(digit));
digit++;
}
else {
m.set(i, String.fromCharCode(c));
c++;
}
}
// string to be returned
let 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 =Math.floor(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
let n = num+Math.pow(2,32);
// use the same remainder technique.
while (n != 0) {
res = m.get(n % 16) + res;
n = Math.floor(n/16);
}
}
return res;
}
// Driver Code
let x = 134, y = -1, z = -234;
document.write("Hexa representation for<br>" );
document.write(x +" is " + Hex(x)+"<br>");
document.write( y +" is " + Hex(y)+"<br>");
document.write( z + " is " + Hex(z)+"<br>");
// This code is contributed by rag2127
</script>
Producción:
Hexa representation for 134 is 86 -1 is ffffffff -234 is ffffff16
Complejidad de tiempo: O (log 16 num)
Espacio Auxiliar: O(15)
Publicación traducida automáticamente
Artículo escrito por Coding_Grounds y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA