Convert a Number to Hexadecimal

Convert a Number to Hexadecimal - Problem

Given a 32-bit integer num, return a string representing its hexadecimal representation. For negative integers, two's complement method is used.

All the letters in the answer string should be lowercase characters, and there should not be any leading zeros in the answer except for the zero itself.

Note: You are not allowed to use any built-in library method to directly solve this problem.

Input & Output

Example 1 — Positive Number

$ Input: num = 26

› Output: 1a

💡 Note: 26 in binary is 11010. Extract 4 bits: 1010 (10 in decimal) = 'a', then 0001 (1 in decimal) = '1'. Result: '1a'

Example 2 — Negative Number

$ Input: num = -1

› Output: ffffffff

💡 Note: -1 in two's complement (32-bit) is all 1s: 11111111111111111111111111111111. Each group of 4 ones = 15 = 'f'. Result: 'ffffffff'

Example 3 — Zero

$ Input: num = 0

› Output: 0

💡 Note: Special case: 0 should return '0' directly, not an empty string

Constraints

-2³¹ ≤ num ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

M Microsoft 15 A Apple 8

The key insight is that each hexadecimal digit represents exactly 4 bits. Best approach uses bit manipulation to extract 4-bit chunks using AND mask (15) and right-shift operations. Time: O(1), Space: O(1)

Common Approaches

✓ Bit Manipulation

⏱️ Time: O(1) Space: O(1)

Use bitwise operations to extract 4 bits at a time from the number, since each hex digit represents exactly 4 bits. Apply a mask of 15 (0xF) to get the last 4 bits, then right-shift by 4 to process the next chunk.

Division Method

⏱️ Time: O(log n) Space: O(log n)

Convert the number to hex by repeatedly dividing by 16 and mapping remainders (0-15) to hex characters (0-9, a-f). Handle negative numbers by adding 2³² to get the two's complement representation.

Bit Manipulation — Algorithm Steps

Handle special case of 0
Extract last 4 bits using bitwise AND with 15
Convert 4-bit value to hex character
Right-shift by 4 bits to process next chunk
Continue until all bits are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Input

Number in 32-bit binary representation

Extract 4 Bits

Use AND mask (1111) to get last 4 bits

Convert & Shift

Convert to hex digit, shift right by 4 bits

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(int num) {
    if (num == 0) {
        char* result = (char*)malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char hexChars[] = "0123456789abcdef";
    char temp[9] = {0};
    int idx = 0;
    
    unsigned int unum = (unsigned int)num;
    
    while (unum > 0) {
        // Extract last 4 bits
        int digit = unum & 15; // 15 = 0xF = 1111 in binary
        temp[idx++] = hexChars[digit];
        unum >>= 4; // Right shift by 4 bits
    }
    
    // Reverse the string
    char* result = (char*)malloc(idx + 1);
    for (int i = 0; i < idx; i++) {
        result[i] = temp[idx - 1 - i];
    }
    result[idx] = '\0';
    
    return result;
}

int main() {
    int num;
    scanf("%d", &num);
    
    char* result = solution(num);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 8 iterations for 32-bit integer (8 × 4 bits = 32 bits)

⚡ Linearithmic

Space Complexity

O(1)

Result string has at most 8 characters for 32-bit number

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler