Convert A Number To Hexadecimal

                                            
class Solution {
public:
    string toHex(int num) {
        if (num == 0) return "0";
        
        unsigned int n = num;
        string hex = "";
        string hexChars = "0123456789abcdef";
        
        while (n != 0) {
            hex = hexChars[n & 15] + hex;
            n = n >> 4;
        }
        
        return hex;
    }
};

                                            
class Solution {
    public String toHex(int num) {
        if (num == 0) {
            return "0";
        }
        
        char[] hexDigits = "0123456789abcdef".toCharArray();
        StringBuilder sb = new StringBuilder();
        
        while (num != 0) {
            sb.insert(0, hexDigits[num & 15]);
            num >>>= 4;
        }
        
        return sb.toString();
    }
}

                                            
class Solution(object):
    def toHex(self, num):
        """
        :type num: int
        :rtype: str
        """
        if num == 0:
            return "0"
        
        if num < 0:
            num += 2**32
        
        hex_chars = "0123456789abcdef"
        result = ""
        while num > 0:
            digit = num % 16
            result = hex_chars[digit] + result
            num = num // 16
        
        return result

                                            
public class Solution {
    public string ToHex(int num) {
        if(num == 0) return "0";
        
        char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
        StringBuilder result = new StringBuilder();
        
        while(num != 0){
            result.Insert(0, hexDigits[num & 15]);
            num = (int)((uint)num >> 4);
        }
        
        return result.ToString();
    }
}

                                            
/**
 * @param {number} num
 * @return {string}
 */
const toHex = (num) => {
    if (num === 0) return '0';
    const hexChars = '0123456789abcdef';
    let result = '';
    while (num !== 0) {
        result = hexChars[num & 15] + result;
        num >>>= 4;
    }
    return result;
};

                                            
function toHex(num: number): string {
    if (num === 0) return "0";
    
    let hex = "0123456789abcdef";
    let result = "";
    
    while (num !== 0) {
        result = hex[num & 15] + result;
        num >>>= 4;
    }
    
    return result;
};

                                            
class Solution {
    func toHex(_ num: Int) -> String {
        if num == 0 {
            return "0"
        }
        
        let hexChars = Array("0123456789abcdef")
        var num = num
        var result = ""
        
        for _ in 0..<8 {
            let digit = num & 15
            result = String(hexChars[digit]) + result
            num >>= 4
            if num == 0 {
                break
            }
        }
        
        return result
    }
}

                                            
class Solution {
    fun toHex(num: Int): String {
        if (num == 0) return "0"
        
        val hexChars = "0123456789abcdef"
        var ans = ""
        var n = num.toLong()
        
        if (n < 0) {
            n += (1L shl 32)
        }
        
        while (n > 0) {
            val remainder = (n % 16).toInt()
            ans = hexChars[remainder] + ans
            n /= 16
        }
        
        return ans
    }
}

                                            
class Solution {
  String toHex(int num) {
    if (num == 0) return "0";
    
    String hexChars = "0123456789abcdef";
    String result = "";
    
    for (int i = 7; i >= 0; i--) {
      int val = (num >> (i * 4)) & 15;
      if (val != 0 || result.isNotEmpty) {
        result += hexChars[val];
      }
    }
    
    return result;
  }
}

                                            
func toHex(num int) string {
    if num == 0 {
        return "0"
    }
    
    hexMap := []byte("0123456789abcdef")

    result := ""
    for i := 0; i < 8 && num != 0; i++ {
        index := num & 15
        result = string(hexMap[index]) + result
        num = num >> 4
    }
    
    return result
}

                                            
# @param {Integer} num
# @return {String}
def to_hex(num)
    return "0" if num == 0
    hex_chars = "0123456789abcdef"
    result = ""
    mask = 0xf
    8.times do
        result = hex_chars[num & mask] + result
        num = num >> 4
    end
    result.gsub(/^0+/, "")
end

                                            
object Solution {
    def toHex(num: Int): String = {
        if (num == 0) return "0"
        
        val hexChars = "0123456789abcdef"
        var result = ""
        var number = num.toLong
        
        if (number < 0) number = (BigInt(2).pow(32) + number).toLong
        
        while (number > 0) {
            val remainder = (number % 16).toInt
            result = s"${hexChars.charAt(remainder)}$result"
            number = number / 16
        }
        
        result
    }
}

                                            
impl Solution {
    pub fn to_hex(num: i32) -> String {
        if num == 0 {
            return String::from("0");
        }
        
        let mut result = String::new();
        let hex_chars: Vec<char> = vec!['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
        let mut num = num as u32;
        
        while num != 0 {
            let rem = (num % 16) as usize;
            result.insert(0, hex_chars[rem]);
            num /= 16;
        }
        
        result
    }
}

To solve this coding challenge, you'll need to convert both positive and negative integers into their hexadecimal string representations. This must be done without using any built-in library functions dedicated to hexadecimal conversion.

Explanation

We begin by understanding how hexadecimal numbers are structured. Hexadecimal (or hex) is a base-16 number system, which means it has sixteen symbols: 0-9 to represent values zero to nine, and a-f to represent values ten to fifteen.

For positive integers:

We repeatedly divide the number by 16 and track the remainders.
The remainders correspond to the hexadecimal digits, with the least significant remainder becoming the rightmost digit.
Build the hex string by converting these remainders into their hex equivalent characters and concatenating in reverse order of their discovery.

For negative integers:

Use the two’s complement method because negative numbers in binary use this representation.
For an
n

bit integer, the two's complement is found by adding
2^n

to the number. Here
n

is 32 since we are dealing with 32-bit signed integers (-2^31 to 2^31-1).
Once the two’s complement is calculated, proceed as with positive numbers to convert to hex.

Handling edge cases:

Directly return "0" if the input number is zero.
For negative numbers converted to 32-bit two’s complements, ensure there are no leading zeros unless the number is zero itself.

Pseudocode:

The pseudocode below will demonstrate the detailed steps and operations performed including comments to ensure a comprehensive understanding.

                                            
# Converts an integer to its hexadecimal string representation
FUNCTION convertToHexadecimal(input_number):
# Base case: if input_number is zero, return "0"
IF input_number IS 0:
RETURN "0"

# If input_number is negative, adjust by adding 2^32 for two's complement representation
IF input_number < 0:
input_number = input_number + 2^32

# Initialize a string with hexadecimal characters
hex_characters = "0123456789abcdef"

# Initialize an empty result string
hex_result = ""

# Process the input number until it becomes zero
WHILE input_number > 0:
# Find the remainder when input_number is divided by 16
hex_digit_index = input_number % 16

# Append the corresponding hex character to the result (in reverse order)
hex_result = hex_characters[hex_digit_index] + hex_result

# Update input_number by floor division with 16
input_number = input_number // 16

# Return the final constructed hex string
RETURN hex_result

Detailed Steps in Pseudocode:

Start with checking if the input number is zero.

If it is zero, directly return "0".

Handle negative numbers:

For negative numbers, add \(2^{32}\) (which is
4294967296

) to transform the number into a positive equivalent via two’s complement method.

Initialize helper variables:

hex_characters

is a string containing '0123456789abcdef', which will help in mapping remainders to their hex equivalents.
hex_result

is initialized as an empty string, which will store the accumulated hexadecimal result.

Loop to construct the hexadecimal string:

Continue to process the input number until the value becomes zero.
In each loop iteration:

Calculate the current hexadecimal digit by getting the remainder of the input number modulo 16 (
input_number % 16

).
Lookup the corresponding character from
hex_characters

and prepend it to
hex_result

.
Reduce the input number by performing integer division by 16 (
input_number // 16

).

Return the constructed hex string after the loop exits.

By following these steps and understanding the intricacy of binary and hexadecimal representations, you can tackle converting a number to its hex representation without relying on built-in functions.