Question

You have an ASCII string representing a 128-bit unsigned integer number n, i.e. 0 <= n < 2^128.

Give an algorithm to extract the most significant 32 bits of the binary representation of n and return them as the unsigned 32 bit integer they encode.

What is a fast way to do this, i.e. something better than implementing your own big number division and modulo 2 operations.
Assume a 32bit machine, i. e. you don’t have 64-bit built-in types.

Examples:
For brevity, let’s take 4 bit integers and extract the leading 2 bits:

2(0010) –> 0(00)
7(0111) –> 1(01)
8(1000) –> 2(10)
13(1101) –> 3(11)

This is NOT a homework question. Updating my algo skills for an interview.

Answer 1

I don’t see a more efficient way than to simply emulate (a limited form of) 128 bit arithmetic.

Let’s say we have a function mul10add(a, b) which calculates 10*a + b and returns the lower 32 bits of the answer together with a carry value. If we have 64-bit arithmetic it can be implemented as (in pseudo-code):

(word32, word32) mul10add(word32 a, word32 b):
    word64 result = 10*a + b
    word32 carry  = result >> 32
    return (result, carry)

Now, we take the normal decimal-to-binary algorithm and represent the 128-bit number n with four 32-bit words x, y, z and w such that n = x*2^96 + y*2^64 + z*2^32 + w. We can then chain calls to mul10add together to perform the equivalent of n = 10*n + digitToInt(decimal[i]).

word32 high32bits(string decimal):
    word32 x = 0, y = 0, z = 0, w = 0

    # carry
    word32 c = 0

    for i in 0..length(decimal)-1
       (w, c) = mul10add(w, digitToInt(decimal[i]))
       (z, c) = mul10add(z, c)
       (y, c) = mul10add(y, c)
       (x, _) = mul10add(x, c)

    return x

We don’t actually need a 64-bit architecture to implement mul10add, however. On x86 we have the mul instruction which multiplies two 32-bit numbers to get a 64-bit number with the upper 32 bits stored in edx and the lower ones in eax. There’s also the adc instruction, which adds two numbers but includes the carry from a previous add. So, in pseudo-assembly:

(word32, word32) mul10add(word32 a, word32 b):
    word32 result, carry
    asm:
        mov a, %eax
        mul 10
        add b, %eax
        adc 0, %edx
        mov %eax, result
        mov %edx, carry
    return (result, carry)