CareerCup

This is basically swapping odd and even bits, which is done using bitmasks. Implementation provided below:

unsigned char swap_bits(unsigned char ch)
{
    return ((ch & 0xAA)>>1 ) | ( (ch & 0x55) << 1);
}

#include<stdio.h>

int main()
{

int n=10;
int m;
m=n;
int count=0;
while(m)
{
 count++;
m=m>>1;
}
printf("Value before swapping:%d\n",n);
printf("No of Bits:%d",count);
int i=0;
int k=1;
while(k<=count/2)
{
int a=1;
int b=1;

a=((a<<i)&n)>>i;
b=((b<<(i+1))&n)>>(i+1);
//a=a&n;
//b=b&n;

//a=a>>i;
//b=b>>(i+1);


int c=a^b;
int d=(c<<i)|(c<<(i+1));

n=n^d;
i=i+2;
k++;
}
printf("\nValue after Swapping Bits:%d",n);

return 0;
}

Output:

Value before swapping:10(1010)
No of Bits:4
Value after Swapping Bits:5(0101)

----------------------------------
Value before swapping:21(10101
No of Bits:5
Value after Swapping Bits:26(11010)
---------------------------------
Value before swapping:15(1111)
No of Bits:4
Value after Swapping Bits:15(1111)

Done for integer
May be this can be true for integer also.
Replacing char n='b';and int m with char m;gives following output.
Value before swapping:98 b
No of Bits:7
Value after Swapping Bits:81 Q

A little long, but works generically for larger sizes. Mask is constructed dynamically.

flip_adj (int value)
{
    int i, mask, temp;

    for (i = 0; i < (sizeof(int)*8); i = i+2) {
        mask = 0;
        mask|= (1<<i) | (1<<(i+1));

        temp = value;
        temp = temp & mask;

        if (((temp >> i) & 1) != ((temp >> (i+1)) & 1)) {
            temp = ~temp;
        }

        temp = temp & mask;
        value = value & (~mask);
        value = value | temp;
   }

   printf("\nAfter flip = %#x", value);
}

main ()
{
    int value = 0xaa; // 1010 1010

    printf("\nValue = %#x", value);

    flip_adj(value);
}

Running program:

# Value = 0xaa (1010 1010)

# After flip = 0x55 (0101 0101)

void showbits(char);
void swapbits(char,int,int);
void main()
{
int i,j;
char ch='A';
printf("\n input the character\n");
scanf("%c",&ch);
printf("character is %c and its binary equivalent is \n",ch);
showbits(ch);
printf("\n After swaping..");
for(j=7;j>=0;)
{
swapbits(ch,j,j-1);
j=j-2;
}
printf("\n");
getch();
}

void showbits(char ch )
{
int i,k,andmask;
for(i=7;i>=0;i--)
{
andmask=1<<i;
k=ch&andmask;
k==0?printf("0"):printf("1");
}
}

void swapbits(char ch,int j,int l )
{
int i,k,andmask;
andmask=1<<l;
k=ch&andmask;
k==0?printf("0"):printf("1");
andmask=1<<j;
k=ch&andmask;
k==0?printf("0"):printf("1");
}

#include<stdio.h>
#include<conio.h>
int binary(int);
int swap(int);
int in[100];
int main()
{
unsigned char c;
printf("enter any character=");
scanf("%c",&c);
int d,i,count;
d = (int)c;
printf("%d\n",d);
count = binary(d);
for(i = count;i>=0;i--)
printf("%d",in[i]);
swap(count);
printf("\n\n");
for(i = count;i>=0;i--)
printf("%d",in[i]);
getch();
return 0;
}

int binary(int num)
{
int j=0;
while(num!=1)
{

in[j] = num%2;
num = num/2;
j++;
}
in[j] = 1;
return j;
}
int swap(int a)
{
int i,j;
for(i=a;i>=0;i--)
{
if(i==0)
{}
else{
j = in[i];
in[i] = in[i-1];
in[i-1] = j;
i--;
}}

return 0;
}

let the number be A = 10101111
A1 = A & 10101010 = 10101010
A2 = A & 01010101 = 00000101
A1 = A1 >> 1 = 01010101
A2 = A2 << 1 = 00001010
result= A1 | A2 = 01011111

unsigned char swap_tbl[3] = {0, 2, 1, 3};

unsigned char swap(unsigned char c)
{
return swap_tbl[(c & 0xc0)>>6] << 6 | swap_tbl[(c & 0x30) >> 4] << 4 | swap_tbl[(c & 0xc) >> 2] << 2 | swap_tbl[c & 0x3];
}

mask1=0XFF;
             mask2=0XFF00;
             int byte1 = (number & mask1)<<8;
             int byte2 = (number & mask2)>>8;
             int newumber = byte1 + byte2;

* You can extend the above logic to extend to the whole unsigned number .
* Just generate the masks accordingly