LeetCode 405: Convert a Number to Hexadecimal Solution in Python – A Step-by-Step Guide

What Is LeetCode 405: Convert a Number to Hexadecimal?

In LeetCode 405: Convert a Number to Hexadecimal, you’re given a 32-bit signed integer num (e.g., 26 or -1), and you need to convert it to its hexadecimal representation as a lowercase string (e.g., "1a" or "ffffffff"). Hex uses base 16, with digits 0-9 and a-f (10-15), and for negatives, we use the two’s complement form, meaning -1 becomes all 1s in 32 bits. No leading zeros are allowed unless the number is 0, which is just "0". For example, 26 in hex is "1a", and -1, as a 32-bit unsigned value, is "ffffffff".

Problem Statement

• Input: A 32-bit signed integer num.
• Output: A string—lowercase hexadecimal representation.
• Rules:
• Use two’s complement for negatives.
• No leading zeros (except "0" for zero).
• Use a-f for 10-15.

Constraints

• -2³¹ <= num <= 2³¹ - 1 (32-bit signed integer range).

Examples

• Input: num = 26
• Output: "1a" (1×16 + 10 = 26).
• Input: num = -1
• Output: "ffffffff" (32 bits of 1s).
• Input: num = 0
• Output: "0".

Understanding the Problem: Hexing the Number

To solve LeetCode 405: Convert a Number to Hexadecimal in Python, we need to turn a 32-bit integer into a hex string, handling both positives and negatives. A naive idea might be to just divide by 16—but negatives throw a wrench in that! We’ll use:

• Best Solution (Bit Manipulation): O(1) time (fixed 32 bits), O(1) space—uses bits directly.
• Alternative Solution (Division Method): O(1) time (32 bits), O(1) space—classic base conversion.

Let’s dive into the bit manipulation solution with a clear, step-by-step explanation.

Best Solution: Bit Manipulation

Why This Is the Best Solution

The bit manipulation approach is the top pick because it’s fast—O(1) time for a fixed 32 bits—and handles negatives seamlessly. It treats the number as a 32-bit unsigned integer (thanks to two’s complement) and grabs 4 bits at a time to build the hex string, skipping the math of division. It’s like reading the number’s binary DNA and translating it straight to hex!

How It Works

Think of the number as a row of 32 light switches (bits):

• Step 1: Understand the Bits:
• Positive: 26 = 000...11010 (32 bits, mostly 0s).
• Negative: -1 = 111...11111 (all 1s in 32-bit two’s complement).
• Step 2: Group by 4:
• Hex digits are 4 bits each (0-15 maps to 0-f).
• 26 = 0000 ... 0001 1010 → 0000 (0), 0001 (1), 1010 (a).
• -1 = 1111 1111 ... 1111 → eight groups of 1111 (f).
• Step 3: Extract Bits:
• Use bitwise AND (& 15) to grab the last 4 bits.
• Shift right (>> 4) to move to the next group.
• Repeat 8 times (32 bits / 4 = 8 hex digits).
• Step 4: Map to Hex:
• 0-9 stay as is, 10-15 become a-f (use a lookup string).
• Step 5: Build and Clean:
• Start from the right, skip leading zeros unless it’s all 0.
• Step 6: Why This Works:
• Two’s complement means negatives are just bit patterns—no special handling needed.
• 4-bit chunks match hex perfectly, and shifting reads them in order.
• It’s like decoding a secret message from bits to hex!

Step-by-Step Example

Example: num = 26

• Binary: 000...11010 (32 bits).
• Loop (right to left):
• 11010 & 15 = 1010 (10 → "a"), shift → 1.
• 1 & 15 = 0001 (1 → "1"), shift → 0.
• 0 & 15 = 0 ("0"), repeat 6 more times → "0".
• String: "0000001a".
• Clean: Strip leading zeros → "1a".
• Result: "1a".

Example: num = -1

• Binary: 111...11111 (32 1s).
• Loop:
• 1111 & 15 = 1111 (15 → "f"), shift → 111...1111.
• Repeat 7 more times: all 1111 → "f".
• String: "ffffffff".
• Clean: No leading zeros, all f’s → "ffffffff".
• Result: "ffffffff".

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down so you can follow every step:

class Solution:
    def toHex(self, num: int) -> str:
        # Step 1: Handle zero
        if num == 0:
            return "0"

        # Step 2: Hex lookup for 0-15
        hex_chars = "0123456789abcdef"

        # Step 3: Process 32 bits, 4 at a time
        result = ""
        for _ in range(8):  # 32 bits / 4 = 8 hex digits
            # Get last 4 bits
            digit = num & 15
            # Add corresponding hex char
            result = hex_chars[digit] + result
            # Shift right by 4 bits
            num >>= 4

        # Step 4: Remove leading zeros
        return result.lstrip("0") or "0"

• Line 4-5: If num is 0, return "0"—quick base case.
• Line 8: Define hex_chars string: 0-9, then a-f for 10-15.
• Line 11-16: Loop 8 times (32 bits / 4):
• Line 13: num & 15 grabs last 4 bits (e.g., 26 & 15 = 10).
• Line 14: Add hex char to front (e.g., "a" + "" = "a").
• Line 15: Shift right 4 bits (e.g., 26 >> 4 = 1).
• Line 18: Strip leading zeros (e.g., "0000001a" → "1a"), return "0" if empty.
• Time Complexity: O(1)—fixed 8 iterations for 32 bits.
• Space Complexity: O(1)—fixed-size string (max 8 chars).

This is like flipping bits into hex with a magic wand!

Alternative Solution: Division Method

Why an Alternative Approach?

The division method uses classic base conversion—dividing by 16 and taking remainders. It’s O(1) time (32 bits) and O(1) space too, but needs a tweak for negatives. It’s like counting out piles of 16 candies to see what’s left!

How It Works

Picture it as breaking down the number:

• Step 1: For negatives, convert to 32-bit unsigned (add 2³²).
• Step 2: Divide by 16, take remainder (0-15), map to hex.
• Step 3: Repeat until number is 0 or 8 digits.
• Step 4: Reverse and clean up zeros.

Step-by-Step Example

Example: num = 26

• 26 ÷ 16 = 1, remainder 10 → "a".
• 1 ÷ 16 = 0, remainder 1 → "1".
• String: "a1" → "1a".
• Result: "1a".

Example: num = -1

• Convert: -1 + 2³² = 4294967295.
• 4294967295 ÷ 16 = 268435455, rem 15 → "f".
• Repeat 7 times: All 15s → "ffffffff".
• Result: "ffffffff".

Code for Division Approach

class Solution:
    def toHex(self, num: int) -> str:
        if num == 0:
            return "0"

        # Handle negative by converting to 32-bit unsigned
        if num < 0:
            num += 2**32

        hex_chars = "0123456789abcdef"
        result = ""

        while num > 0:
            digit = num % 16
            result = hex_chars[digit] + result
            num //= 16

        return result

• Time Complexity: O(1)—up to 8 iterations.
• Space Complexity: O(1)—small string.

It’s a candy-pile counter!

Comparing the Two Solutions

• Bit Manipulation (Best):
• Pros: O(1), O(1), no negative conversion.
• Cons: Bitwise ops to learn.
• Division Method (Alternative):
• Pros: O(1), O(1), intuitive math.
• Cons: Negative handling.

Bits win for elegance.

Additional Examples and Edge Cases

• 16: "10".
• -16: "fffffff0".
• 2³¹ - 1: "7fffffff".

Bits handle all.

Complexity Breakdown

• Bit Manipulation: Time O(1), Space O(1).
• Division Method: Time O(1), Space O(1).

Bits are sleek.

Key Takeaways

• Bit Manipulation: Flip to hex!
• Division Method: Divide it out!
• Hex: Bases are fun.
• Python Tip: Strings are key—see [Python Basics](/python/basics).

Final Thoughts: Hex It Up

LeetCode 405: Convert a Number to Hexadecimal in Python is a number-twisting adventure. Bit manipulation zaps to the answer, while division counts it out. Want more number fun? Try LeetCode 168: Excel Sheet Column Title or LeetCode 171: Excel Sheet Column Number. Ready to convert? Head to Solve LeetCode 405 on LeetCode and hex that number today!