Convert a Number to Hexadecimal - Practice Coding Problems

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

Understanding the Visualization

Input

32-bit integer (positive or negative)

Process

Convert to hex using division or bit manipulation

Output

Hexadecimal string with lowercase letters

Key Takeaway

🎯 Key Insight: Each hex digit represents exactly 4 bits, making bit manipulation the most efficient approach

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

Approach	Time	Space	Notes
✓ Division Method	O(log n)	O(log n)	Repeatedly divide by 16 and collect remainders to build hex digits
Bit Manipulation	O(1)	O(1)	Extract 4-bit chunks using bitwise AND and shift operations

Division Method — Algorithm Steps

Handle special case of 0
For negative numbers, add 2³² to get two's complement
Repeatedly divide by 16, collect remainders
Map remainders to hex characters (0-9, a-f)
Reverse the result since we build it backwards

Visualization

Tap to expand

Step-by-Step Walkthrough

Handle Negative

Convert -1 to two's complement: -1 + 2³² = 4294967295

Divide by 16

Repeatedly divide and collect remainders

Map to Hex

Convert remainders to hex digits: f, f, f, f, f, f, f, f

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;
    }
    
    // Handle negative numbers with two's complement
    unsigned int unum = (unsigned int)num;
    
    char hexChars[] = "0123456789abcdef";
    char temp[9] = {0};
    int idx = 0;
    
    while (unum > 0) {
        int remainder = unum % 16;
        temp[idx++] = hexChars[remainder];
        unum /= 16;
    }
    
    // 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(log n)

We divide by 16 up to 8 times for a 32-bit number

⚡ Linearithmic

Space Complexity

O(log n)

Result string stores up to 8 hex digits

⚡ 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

Division Method — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler