Codestin Search App

Convert a Number to Hexadecimal - Problem

Given a 32-bit signed integer num, your task is to convert it into its hexadecimal representation as a string.

🎯 Key Requirements:

For negative integers, use the two's complement method
All letters in the result must be lowercase (a-f)
No leading zeros except when the number itself is zero
No built-in conversion functions allowed!

Examples:

26 → "1a" (26 = 1×16¹ + 10×16⁰)
-1 → "ffffffff" (32-bit two's complement)
0 → "0" (special case)

This problem tests your understanding of number systems, bit manipulation, and two's complement representation.

Input & Output

example_1.py — Basic Positive Number

$ Input: num = 26

› Output: "1a"

💡 Note: 26 in binary is 11010. Grouping 4 bits from right: 1010 (10 → 'a'), 0001 (1 → '1'). Reading left to right gives '1a'.

example_2.py — Negative Number

$ Input: num = -1

› Output: "ffffffff"

💡 Note: -1 in 32-bit two's complement is all 1s (11111111111111111111111111111111). Each group of 4 ones (1111) converts to 'f', giving 8 'f's total.

example_3.py — Zero Edge Case

$ Input: num = 0

› Output: "0"

💡 Note: Zero is a special case that should return '0' directly, not an empty string.

Visualization

Tap to expand

Understanding the Visualization

Understand the mapping

Each hex digit represents exactly 4 bits (0000-1111 maps to 0-f)

Extract bit groups

Use bitwise AND with 0xf to extract the rightmost 4 bits

Convert to hex

Map the 4-bit value (0-15) to corresponding hex character

Shift and repeat

Right-shift by 4 bits and repeat until no significant bits remain

Handle two's complement

Negative numbers naturally work due to their bit representation

Key Takeaway

🎯 Key Insight: Each hexadecimal digit represents exactly 4 bits, allowing direct conversion through bitwise operations without division.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed number of iterations (at most 8) regardless of input size, since we're dealing with 32-bit integers

✓ Linear Growth

Space Complexity

O(1)

Result string length is bounded by 8 characters for 32-bit integers, so space is constant

✓ Linear Space

Constraints

-2³¹ ≤ num ≤ 2³¹ - 1
No built-in conversion functions allowed
Result must use lowercase letters (a-f)
No leading zeros except for the number 0 itself

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 Apple 6

The optimal solution uses bit manipulation to extract 4 bits at a time using num & 0xf, convert each group directly to a hex character, then right-shift by 4 bits. This approach runs in O(1) time and naturally handles two's complement representation for negative numbers without special cases.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation (Optimal)	O(1)	O(1)	Extract 4 bits at a time using bitwise operations

Bit Manipulation (Optimal) — Algorithm Steps

Handle special case: if num is 0, return '0'
Use a loop to process 4 bits at a time (up to 8 iterations for 32-bit)
Extract lowest 4 bits using bitwise AND with 0xf (15)
Convert the 4-bit value to corresponding hex character
Right shift by 4 bits to process next group
Stop when no more significant bits remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with binary

View the number in its 32-bit binary representation

Extract 4 bits

Use bitwise AND with 0xf (1111) to get lowest 4 bits

Convert to hex

Map the 4-bit value (0-15) to hex character (0-9, a-f)

Shift right

Right shift by 4 bits to process next group

Reverse result

Reverse the collected characters for final answer

Code -

solution.c — C

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

char* toHex(int num) {
    if (num == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char hexChars[] = "0123456789abcdef";
    char temp[9] = {0};  // Max 8 hex digits + null terminator
    int index = 0;
    
    unsigned int unsignedNum = (unsigned int)num;
    
    // Process 4 bits at a time
    for (int i = 0; i < 8 && unsignedNum != 0; i++) {
        // Extract lowest 4 bits and convert to hex
        int digit = unsignedNum & 0xf;
        temp[index++] = hexChars[digit];
        unsignedNum >>= 4;
    }
    
    // Reverse the string
    char* result = malloc(index + 1);
    for (int i = 0; i < index; i++) {
        result[i] = temp[index - 1 - i];
    }
    result[index] = '\0';
    
    return result;
}

int main() {
    printf("%s\n", toHex(26));  // "1a"
    printf("%s\n", toHex(-1));  // "ffffffff"
    printf("%s\n", toHex(0));   // "0"
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed number of iterations (at most 8) regardless of input size, since we're dealing with 32-bit integers

✓ Linear Growth

Space Complexity

O(1)

Result string length is bounded by 8 characters for 32-bit integers, so space is constant

✓ Linear Space

Constraints

-2³¹ ≤ num ≤ 2³¹ - 1
No built-in conversion functions allowed
Result must use lowercase letters (a-f)
No leading zeros except for the number 0 itself

32.0K Views

Medium Frequency

~15 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler