need to shift bits in number using bitwise operators? - bit-manipulation

Question

#include<stdio.h>
int main()
{
int num,m,n,t,res,i;
printf("Enter number\n");
scanf("%d",&num);
for(i=31;i>=0;i--)
{
printf("%d",((num>>i)&1));
}
printf("\n");
printf("Enter position 1 and position 2\n");
scanf("%d%d",&m,&n);
printf("enter number\n");
scanf("%d",&t);
res=((num&(~(((~(unsigned)0)>>(32-((m-t)+1)))<<t)))&(num&(~(((~(unsigned)0)>>(32-((n-t)+1)))<<t))))|(((((num&((((~(unsigned)0)>>(((m-t))))<<(n))))>>(m-t))))|(((num&((((~(unsigned)0)>>(((32-n))))<<(32-t))))<<(m-t))));
for(i=31;i>=0;i--)
{
printf("%d",(res>>i)&1);
}
printf("\n");
}
I need to swap bits from (m to m-t) and (n to n-t) in number num.I tried the above code but it doesn't work..can someone please help.

Answer 1

As usual with bit swapping problems, you can save a few instructions by using xor.
unsigned f(unsigned num, unsigned n, unsigned m, unsigned t) {
n -= t; m -= t;
unsigned mask = ((unsigned) 1 << t) - 1;
unsigned nm = ((num >> n) ^ (num >> m)) & mask;
return num ^ (nm << n) ^ (nm << m);
}

Answer 2

It's easier if you break it down into smaller steps.
First, make a bit mask t bits wide. You can do this by subtracting 1 from a power of 2, like this:
int mask = (1 << t) - 1;
For example if t is 3 then mask will be 7 (111 in binary).
Then you can make a copy of num and clear the bits in the range of m to m-t and n to n-t by shifting up the mask, NOTing it and ANDing, so that only bits not covered by the mask remain set:
res = num & ~(mask<<(m-t)) & ~(mask<<(n-t));
Then you can shift the bits in the two ranges into their proper locations and OR with the result. You can do this by shifting down by (n-t), masking, and then shifting up by (m-t), then vice versa:
res |= ((num >> (n-t)) & mask) << (m-t);
res |= ((num >> (m-t)) & mask) << (n-t);
The bits are now in the correct place.
You could do this in one line like this:
res = (num & ~(mask<<(m-t)) & ~(mask<<(n-t))) | (((num >> (n-t)) & mask) << (m-t)) | (((num >> (m-t)) & mask) << (n-t));
And it can be simplified by doing the m-t and n-t subtractions beforehand, assuming you don't want to use the values afterwards:
m -= t; n -= t;
res = (num & ~(mask<<m) & ~(mask<<n)) | (((num >> n)) & mask) << m) | (((num >> m) & mask) << n);
This doesn't work if the two ranges overlap. It's not clear what the correct behaviour would be in that case.