1043EasyMathStringBit Manipulation

Writing a Signed Reading in Base Sixteen

Tracked in this browser only

Trains the technique from

LeetCode 405Convert a Number to Hexadecimal

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A reading num is a whole number that fits in thirty-two bits.

Write it in base sixteen, using '0' through '9' and then the lowercase letters 'a' through 'f'. A negative reading is written as its pattern over thirty-two bits taken as an unsigned number, which is the reading plus two raised to the thirty-second. Write no leading zero, except that the reading 0 is written as the single character "0".

Return that spelling.

Examples

Example 1

Input: num = 255
Output: "ff"

Two hundred and fifty-five is fifteen sixteens plus fifteen, and fifteen is written as the letter f.

Example 2

Input: num = 0
Output: "0"

The reading is nothing, which is written as a single zero rather than as no digits at all.

Example 3

Input: num = -2147483648
Output: "80000000"

Adding two raised to the thirty-second turns this reading into two raised to the thirty-first, which in base sixteen is an eight followed by seven zeros.

Constraints

-2^31 <= num <= 2^31 - 1

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def to_hex(num: int) -> str:

Java

public String toHex(int num)

The intended approach

Time O(1), since a thirty-two-bit reading has at most eight digits.Space O(1).

Deal with the sign first. Adding two raised to the thirty-second to a negative reading gives exactly the whole number its thirty-two-bit pattern stands for when the sign is ignored, so after that step the job is the same whichever side of nothing the reading started on. Then peel base-sixteen digits off the low end: the remainder on dividing by sixteen names the digit, and dividing by sixteen drops it. Look the digit up in the sixteen-character alphabet. The digits come off least significant first, so reverse them at the end. A reading of nothing yields no digits at all, so answer that case before the loop. Otherwise the loop runs only while something is left, which is what leaves no leading zero.

Pythonentry point: to_hex

def to_hex(num):
    if num == 0:
        return "0"
    value = num
    if value < 0:
        value += 1 << 32
    digits = "0123456789abcdef"
    out = []
    while value:
        out.append(digits[value % 16])
        value //= 16
    out.reverse()
    return "".join(out)

The obvious version

Go through the bits instead. Read the reading's thirty-two bits off one at a time, low end first, which for a negative reading gives its pattern directly. Then gather the bits into eight groups of four, turn each group into one base-sixteen digit, and strip the leading zeros from the eight characters, keeping one when everything was zero. Costs the bits rather than a division per digit.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_to_hex(num):
    digits = "0123456789abcdef"
    bits = []
    value = num
    for _ in range(32):
        bits.append(value & 1)
        value >>= 1
    out = []
    for group in range(7, -1, -1):
        piece = 0
        for offset in range(3, -1, -1):
            piece = piece * 2 + bits[group * 4 + offset]
        out.append(digits[piece])
    text = "".join(out)
    at = 0
    while at < len(text) - 1 and text[at] == '0':
        at += 1
    return text[at:]

How this problem was checked

Reference solution executed against 15 test cases — 15 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in