Bitwise Operators Questions and Answers

Q: Predict the output of following program. #include <stdio.h> #define MOBILE 0x01 #define LAPPY 0x02 int main() { unsigned char item=0x00; item |=MOBILE; item |=LAPPY; printf("I have purchased ...:"); if(item & MOBILE){ printf("Mobile, "); } if(item & LAPPY){ printf("Lappy"); } return 1; }

Correct answer: I have purchased ...:Mobile, LappyThis is the flags idiom in full. MOBILE is 0x01 and LAPPY is 0x02 - different bit positions, which is what makes them independently storable in one byte.The two |= operations set both bits, leaving item at 0x03. Each if then tests one bit with AND, and both tests are non-zero, so both strings print. Note that if uses each test as a truth value, so the results 0x01 and 0x02 both count as true despite being different numbers.

Q: On left shifting, the bits from the left are rotated and brought to the right and accommodated where there is empty space on the right?

Correct answer: FalseC's shift operators do not rotate. On a left shift the bits leaving the top are simply discarded, and zeros are brought in at the bottom - nothing wraps around.Rotation exists in most processors as a machine instruction but has no operator in C, and must be written out: (x << k) | (x >> (n-k)) on an unsigned type of \( n \) bits, which reintroduces at the bottom the bits the left shift discarded. Discarding rather than rotating is what makes a left shift a multiplication by two.

Q: Assuming a integer 2-bytes, What will be the output of the program? #include <stdio.h> int main() { printf("%x\n", -1<<3); return 0; }

Correct answer: fff8On a 2-byte int, \( -1 \) is all ones: 0xffff. Shifting left by three discards the top three bits and brings three zeros in at the bottom:\[ 1111\,1111\,1111\,1111_2 \ll 3 = 1111\,1111\,1111\,1000_2 = \mathtt{0xfff8} \]The quick check is that the low three bits become zero and nothing else changes, so only the last hex digit moves, from f to 8. Note that left-shifting a negative value is undefined behaviour in C; the result shown is what implementations produce, not what the standard guarantees.

Q: In which numbering system can the binary number 1011011111000101 be easily converted to?

Correct answer: Hexadecimal systemSixteen is a power of two, so each hexadecimal digit corresponds to exactly four binary digits and the conversion is a matter of grouping rather than of arithmetic.Splitting the number from the right gives 1011 0111 1100 0101, which reads directly as B7C5. Octal shares the property with groups of three bits, but sixteen bits divide evenly into four hexadecimal digits and not into whole octal ones, which is why hex is the convention for byte-oriented data. Decimal is a power of ten and requires repeated division.

Q: Which of the following statements are correct about the program? #include <stdio.h> char *fun(unsigned int num, int base); int main() { char *s; s=fun(128, 2); s=fun(128, 16); printf("%s\n",s); return 0; } char *fun(unsigned int num, int base) { static char buff[33]; char *ptr = &buff[sizeof(buff)-1]; *ptr = '\0'; do { *--ptr = "0123456789abcdef"[num % base]; num /=base; }while(num!=0); return ptr; }

Correct answer: It converts a number to a given base.The function is a general base converter. It builds the string backwards from the end of the buffer, taking num % base as the next digit, looking that digit up in "0123456789abcdef", and dividing num by base until nothing remains.Because both the digit table and the divisor come from the base parameter, it handles any base up to 16 - binary and hexadecimal are merely the two the caller happens to use. The do...while form guarantees at least one digit, so an input of zero yields "0" rather than an empty string.

Q: What will be the output of the following C code? #include <stdio.h> int main() { if (7 & 8) printf("Honesty"); if ((~7 & 0x000f) == 8) printf("is the best policy\n"); }

Correct answer: is the best policyTake the two tests separately. \( 7 = 0111_2 \) and \( 8 = 1000_2 \) have no bits in common, so 7 & 8 is 0 and the first printf does not run.For the second, ~7 inverts every bit, giving ...11111000. Masking with 0x000f keeps only the low four bits, leaving \( 1000_2 = 8 \), so the test is true and is the best policy is printed alone. The mask is what makes the result independent of the width of an int, which is why it is there.

Q: Taking the bitwise OR of a number with 0 leaves the number unchanged.

Correct answer: TrueORing with 0 leaves each bit as it was, so 0 is the identity element for OR. The corresponding identity for AND is a value with all bits set, and for XOR it is again 0.

Q: Which statement is suitable to check 3rd (count from 0) bit is high (set) or not?

Correct answer: Both (1) and (2)The two expressions build the same mask by different routes. 1<<3 shifts a single 1 into position 3, giving \( 1000_2 \); 0x08 is that same value written directly. ANDing with either isolates bit 3.The third option is the trap: 0x03 is \( 0011_2 \), which selects bits 0 and 1 - a mask for two low bits, not for bit 3. The shift form is generally preferred in code because the bit number appears literally, so 1<<k reads as "bit k" without the reader converting hexadecimal in their head.

Q: On left shifting, the bits from the left are rotated and brought to the right and accommodated where there is empty space on the right?

Correct answer: FalseC's shift operators do not rotate. On a left shift the bits leaving the top are simply discarded, and zeros are brought in at the bottom - nothing wraps around.Rotation exists in most processors as a machine instruction but has no operator in C, and must be written out: (x << k) | (x >> (n-k)) on an unsigned type of \( n \) bits, which reintroduces at the bottom the bits the left shift discarded. Discarding rather than rotating is what makes a left shift a multiplication by two.

Q: What will be the output of the following C code? #include <stdio.h> void main() { int x = 4; int *p = &x; int *k = p++; int r = p - k; printf("%d", r); }

Correct answer: 1Pointer arithmetic is in units of the pointed-to type, not in bytes. p++ advances p by one int, and k keeps the address p held beforehand, since ++ is postfix.The difference of two pointers is likewise expressed in elements:\[ p - k = 1 \]The distractor 4 is the difference in bytes on a machine with four-byte ints, which is what a beginner expects; the language deliberately hides that scaling so that pointer arithmetic works the same way for every type.

21.

Predict the output of following program.

#include <stdio.h>

#define MOBILE  0x01
#define LAPPY   0x02

int main()
{
 unsigned char  item=0x00;

 item |=MOBILE;
 item |=LAPPY;

 printf("I have purchased ...:");
 if(item & MOBILE){
  printf("Mobile, ");
 }
 if(item & LAPPY){
  printf("Lappy");
 }

 return 1;
}

A.I have purchased ...:
B.I have purchased ...:Mobile, Lappy
C.I have purchased ...:Mobile,
D.I have purchased ...:Lappy

Answer: B

Correct answer: I have purchased ...:Mobile, Lappy

This is the flags idiom in full. MOBILE is 0x01 and LAPPY is 0x02 - different bit positions, which is what makes them independently storable in one byte.

The two |= operations set both bits, leaving item at 0x03. Each if then tests one bit with AND, and both tests are non-zero, so both strings print. Note that if uses each test as a truth value, so the results 0x01 and 0x02 both count as true despite being different numbers.

Discuss in Forum

22.

On left shifting, the bits from the left are rotated and brought to the right and accommodated where there is empty space on the right?

A.True
B.False

Answer: B

Correct answer: False

C's shift operators do not rotate. On a left shift the bits leaving the top are simply discarded, and zeros are brought in at the bottom - nothing wraps around.

Rotation exists in most processors as a machine instruction but has no operator in C, and must be written out: (x << k) | (x >> (n-k)) on an unsigned type of \( n \) bits, which reintroduces at the bottom the bits the left shift discarded. Discarding rather than rotating is what makes a left shift a multiplication by two.

Discuss in Forum

23.

Assuming a integer 2-bytes, What will be the output of the program?

#include <stdio.h>

int main()
{
    printf("%x\n", -1<<3);
    return 0;
}

A.ffff
B.fff8
C.0
D.-1

Answer: B

Correct answer: fff8

On a 2-byte int, \( -1 \) is all ones: 0xffff. Shifting left by three discards the top three bits and brings three zeros in at the bottom:

\[ 1111\,1111\,1111\,1111_2 \ll 3 = 1111\,1111\,1111\,1000_2 = \mathtt{0xfff8} \]

The quick check is that the low three bits become zero and nothing else changes, so only the last hex digit moves, from f to 8. Note that left-shifting a negative value is undefined behaviour in C; the result shown is what implementations produce, not what the standard guarantees.

Discuss in Forum

24.

In which numbering system can the binary number 1011011111000101 be easily converted to?

A.Decimal system
B.Hexadecimal system
C.Octal system
D.No need to convert

Answer: B

Correct answer: Hexadecimal system

Sixteen is a power of two, so each hexadecimal digit corresponds to exactly four binary digits and the conversion is a matter of grouping rather than of arithmetic.

Splitting the number from the right gives 1011 0111 1100 0101, which reads directly as B7C5. Octal shares the property with groups of three bits, but sixteen bits divide evenly into four hexadecimal digits and not into whole octal ones, which is why hex is the convention for byte-oriented data. Decimal is a power of ten and requires repeated division.

Discuss in Forum

25.

Which of the following statements are correct about the program?

#include <stdio.h>
char *fun(unsigned int num, int base);

int main()
{
    char *s;
    s=fun(128, 2);
    s=fun(128, 16);
    printf("%s\n",s);
    return 0;
}
char *fun(unsigned int num, int base)
{
    static char buff[33];
    char *ptr = &buff[sizeof(buff)-1];
    *ptr = '\0';
    do
    {
        *--ptr = "0123456789abcdef"[num % base];
        num /=base;
    }while(num!=0);
    return ptr;
}

A.It converts a number to a given base.
B.It converts a number to its equivalent binary.
C.It converts a number to its equivalent hexadecimal.
D.It converts a number to its equivalent octal.

Answer: A

Correct answer: It converts a number to a given base.

The function is a general base converter. It builds the string backwards from the end of the buffer, taking num % base as the next digit, looking that digit up in "0123456789abcdef", and dividing num by base until nothing remains.

Because both the digit table and the divisor come from the base parameter, it handles any base up to 16 - binary and hexadecimal are merely the two the caller happens to use. The do...while form guarantees at least one digit, so an input of zero yields "0" rather than an empty string.

Discuss in Forum

26.

What will be the output of the following C code?

#include <stdio.h>
    int main()
    {
        if (7 & 8)
        printf("Honesty");
            if ((~7 & 0x000f) == 8)
                printf("is the best policy\n");
    }

A.Honesty is the best policy
B.Honesty
C.is the best policy
D.No output

Answer: C

Correct answer: is the best policy

Take the two tests separately. \( 7 = 0111_2 \) and \( 8 = 1000_2 \) have no bits in common, so 7 & 8 is 0 and the first printf does not run.

For the second, ~7 inverts every bit, giving ...11111000. Masking with 0x000f keeps only the low four bits, leaving \( 1000_2 = 8 \), so the test is true and is the best policy is printed alone. The mask is what makes the result independent of the width of an int, which is why it is there.

Discuss in Forum

27.

Taking the bitwise OR of a number with 0 leaves the number unchanged.

A.True
B.False

Answer: B

Correct answer: True

ORing with 0 leaves each bit as it was, so 0 is the identity element for OR. The corresponding identity for AND is a value with all bits set, and for XOR it is again 0.

Discuss in Forum

28.

Which statement is suitable to check 3rd (count from 0) bit is high (set) or not?

A.(num & (1<<3))
B.(num & 0x08)
C.(num & 0x03)
D.Both (1) and (2)

Answer: D

Correct answer: Both (1) and (2)

The two expressions build the same mask by different routes. 1<<3 shifts a single 1 into position 3, giving \( 1000_2 \); 0x08 is that same value written directly. ANDing with either isolates bit 3.

The third option is the trap: 0x03 is \( 0011_2 \), which selects bits 0 and 1 - a mask for two low bits, not for bit 3. The shift form is generally preferred in code because the bit number appears literally, so 1<<k reads as "bit k" without the reader converting hexadecimal in their head.

Discuss in Forum

29.

On left shifting, the bits from the left are rotated and brought to the right and accommodated where there is empty space on the right?

A.True
B.False
C.

Answer: B

Correct answer: False

C's shift operators do not rotate. On a left shift the bits leaving the top are simply discarded, and zeros are brought in at the bottom - nothing wraps around.

Discuss in Forum

30.

What will be the output of the following C code?

#include <stdio.h>
    void main()
    {
        int x = 4;
        int *p = &x;
        int *k = p++;
        int r = p - k;
        printf("%d", r);
    }

A.4
B.8
C.1
D.Run time error

Answer: C

Correct answer: 1

Pointer arithmetic is in units of the pointed-to type, not in bytes. p++ advances p by one int, and k keeps the address p held beforehand, since ++ is postfix.

The difference of two pointers is likewise expressed in elements:

\[ p - k = 1 \]

The distractor 4 is the difference in bytes on a machine with four-byte ints, which is what a beginner expects; the language deliberately hides that scaling so that pointer arithmetic works the same way for every type.

Discuss in Forum

Loading…

Topics

Other Subjects

Tags: Bitwise Operators Questions and Answers || Bitwise Operators MCQ Questions and Answers || Bitwise Operators GK Questions and Answers || Bitwise Operators GK MCQ Questions || Bitwise Operators Multiple Choice Questions and Answers || Bitwise Operators GK || GK on Bitwise Operators || C Programming Questions and Answers || C Programming MCQ Questions and Answers || C Programming GK Questions and Answers || GK on C Programming

Bitwise Operators Questions and Answers

Topics

Other Subjects

About Us

Stay informed about all important Dates & Notifications