Question

I’m completely stuck on how to do this homework problem and looking for a hint or two to keep me going. I’m limited to 20 operations (= doesn’t count in this 20).

I’m supposed to fill in a function that looks like this:

    /* Supposed to do x%(2^n).
       For example: for x = 15 and n = 2, the result would be 3.

       Additionally, if positive overflow occurs, the result should be the
       maximum positive number, and if negative overflow occurs, the result
       should be the most negative number.
     */
    int remainder_power_of_2(int x, int n){

      int twoToN = 1 << n;

      /* Magic...? How can I do this without looping? We are assuming it is a
         32 bit machine, and we can't use constants bigger than 8 bits
         (0xFF is valid for example).
         However, I can make a 32 bit number by ORing together a bunch of stuff.
         Valid operations are: << >> + ~ ! | & ^
       */

      return theAnswer;
    }

I was thinking maybe I could shift the twoToN over left… until I somehow check (without if/else) that it is bigger than x, and then shift back to the right once… then xor it with x… and repeat? But I only have 20 operations!

Answer 1

Since binary is base 2, remainders mod 2^N are exactly represented by the rightmost bits of a value. For example, consider the following 32 bit integer:

00000000001101001101000110010101

This has the two’s compliment value of 3461525. The remainder mod 2 is exactly the last bit (1). The remainder mod 4 (2^2) is exactly the last 2 bits (01). The remainder mod 8 (2^3) is exactly the last 3 bits (101). Generally, the remainder mod 2^N is exactly the last N bits.

In short, you need to be able to take your input number, and mask it somehow to get only the last few bits.

A tip: say you’re using mod 64. The value of 64 in binary is:

00000000000000000000000001000000

The modulus you’re interested in is the last 6 bits. I’ll provide you a sequence of operations that can transform that number into a mask (but I’m not going to tell you what they are, you can figure them out yourself :D)

00000000000000000000000001000000 // starting value
11111111111111111111111110111111 // ???
11111111111111111111111111000000 // ???
00000000000000000000000000111111 // the mask you need

Each of those steps equates to exactly one operation that can be performed on an int type. Can you figure them out? Can you see how to simplify my steps? 😀

Another hint:

00000000000000000000000001000000 //  64
11111111111111111111111111000000 // -64