Take the 2-minute tour ×

Pass a integer 2 to this function and then return a integer which is 4

x = 2;
x = rotateInt('L', x, 1); 

(left shift the bits by 1)

Example: 00000010 -> rotate left by 1 -> 00000100

but if I pass this:

x = rotateInt('R', x, 3); 

it will return 64, 01000000

Here is the code, can someone correct the error... thanks

int rotateInt(char direction, unsigned int x, int y)

unsigned int mask = 0;
int num = 0, result = 0;
int i;

if(direction == 'R')
if((x & 1) == 1)     
x = (x ^ 129);
x = x >> 1;
else if(direction == 'L')
if((x & 128) == 1)  
x = (x ^ 129);   
x = x << 1;

result = (result ^ x);

return result;   

share|improve this question
Consider >> and <<, perhaps. Now write the function :-) –  user166390 Oct 13 '10 at 22:47
And your question is? You want to know bitwise operations? en.wikipedia.org/wiki/… –  birryree Oct 13 '10 at 22:47
You really need to learn to indent your code. It makes your code much more readable. Plus you'll work faster and make less mistakes. –  Cam Oct 14 '10 at 0:51
add comment

6 Answers

up vote 3 down vote accepted

So, I'll assume you know what right and left shifts are. And that you know the difference between arithmetic and logical shifts.

C only has arithmetic shifts. It doesn't do logical shifts, nor does it do rotates. okay I lied, C does logical shifts on unsigned ints.

A rotate does, well, exactly that: it's the same as a logical shift, except when you shift past the end of the number, the digits "wrap around" to the other side. For example

0010 right-rotated is 0001. If you right-rotate again, you get 1000. See, the 1 wrapped around, or rotated, to the other side of the integer.

The left rotate is similar: 0100 left rotate 1000 left rotate 0001 left rotate 0010 etc.

Note that rotates don't keep the sign bit as an arithmetic right-shift would.

So, C only has arithmetic shifts. So you have to implement the "rotate" part manually. So, take a left-rotate. You would want to:

  1. Capture the value of the left-most bit. (is it a 0 or 1?)
  2. Do a left-shift
  3. Set the right-most bit - which is the bit we talked about in step 1 (which needs to be rotated around) to the correct value, based on what we captured from step 1.

You should be able to figure out a similar method for right rotates.

good luck!

share|improve this answer
ok, I will try the steps, thanks :) –  Tim Oct 13 '10 at 23:22
can you check the code for me? –  Tim Oct 13 '10 at 23:53
Sorry to be contrary; whether a right shift on a signed quantity is arithmetic or logical is up to the individual C compiler — the ISO standard explicitly leaves it undefined. That's just being pedantic though, just stick to unsigned values. –  Tommy Oct 14 '10 at 1:14
@poundifdef That's great for rotating by 1, but how about rotating by n? –  krb686 Feb 19 at 23:43
add comment

The accepted answer is very nice and straight-forward.

However, I was doing some K&R exercises to refresh my C, and wanted to share this rotate-to-the-right function which may come in handy for people trying to learn bit-wise operations.

unsigned int rightRotateBits(unsigned int inputWord, int bitAmount) {
    // Rotating 32 bits on a 32-bit integer is the same as rotating 0 bits; 33 bits -> 1 bit; etc.
    if (bitAmount >= 32 || bitAmount <= -32) {
        bitAmount = bitAmount % 32;

    unsigned int tempWord = inputWord;

    // Rotate input to the right
    inputWord = inputWord >> bitAmount;

    // Build mask for carried over bits
    tempWord = tempWord << 32 - bitAmount;

    return inputWord | tempWord;

For left-rotations just pass values between -1 and -31 to the bitAmount argument.

Do note that this function favors teachability/legibility/simplicity over efficiency/portability/compactness.

share|improve this answer
Also, if you want to visualize your results, you can use this nice function that prints the bit components of a word to the console: stackoverflow.com/a/1024414/269753 –  Ricardo Sánchez-Sáez Feb 17 '13 at 1:03
add comment

It seems like your rotate to the right is RIGHT. 1 fell of the side and returned back again from the left?

Anyway, here are your ingredients:

http://tigcc.ticalc.org/doc/keywords.html#if - for determining if it is 'L' or 'R'

http://tigcc.ticalc.org/doc/keywords.html#for - for counting number of times to shift


http://msdn.microsoft.com/en-us/library/f96c63ed(VS.80).aspx - to actually shift it

Go, play with it. It WILL work eventually!

share|improve this answer
add comment

Since no one told you how to implement this, you can use intrinsics, for visual studio they are _rotl, _rotl64, _rotr, _rotr64.

Oh, but rotation and shifts are 2 different things!

share|improve this answer
add comment

I recommend using an unsigned int.

#define DIR_LEFT 0
#define DIR_RIGHT 1

unsigned int rotateInt(unsigned int in, int amount, byte dir)
    return(dir == DIR_RIGHT ? (in >> amount) | ((in & ((0x01 << amount) - 1)) << (sizeof(unsigned int)*8 - amount)) : (in << amount)  | ((in & ~((sizeof(unsigned int)*8*8 - 1) >> amount)));
share|improve this answer
This shifts rather than rotates. –  Olathe Jan 5 '11 at 0:29
@Olathe This better? There may be optimizations, but that's all I can come up with for now. –  muntoo Jan 5 '11 at 0:51
@Olathe ...Hello? –  muntoo Jan 17 '11 at 0:24
@Olathe Hello, yet again. :) –  muntoo Mar 1 '11 at 2:56
Sorry it took so long to get back to you. Yes, that looks right, but you don't need the & masking: shifting will automatically throw away bits that fall off the end. return dir == DIR_RIGHT ? (in >> amount) | (in << (8*sizeof(unsigned int) - amount)) : (in << amount) | (in >> (8*sizeof(unsigned int) - amount)); –  Olathe Apr 19 '11 at 22:19
add comment

Your Answer


