C Bit Manipulation

#include <stdio.h>

void printBinary(unsigned int n) {
    for (int i = 7; i >= 0; i--) {
        printf("%d", (n >> i) & 1);
    }
}

int main() {
    unsigned int a = 5;  // 0000 0101
    unsigned int b = 3;  // 0000 0011

    printf("a = %u (", a); printBinary(a); printf(")\n");
    printf("b = %u (", b); printBinary(b); printf(")\n\n");

    printf("a & b = %u  (AND)\n",  a & b);   // 1
    printf("a | b = %u  (OR)\n",   a | b);   // 7
    printf("a ^ b = %u  (XOR)\n",  a ^ b);   // 6
    printf("~a    = %d  (NOT)\n",  ~a);       // -6 (signed)
    printf("a << 1 = %u (LEFT SHIFT  = a*2)\n", a << 1);  // 10
    printf("a >> 1 = %u (RIGHT SHIFT = a/2)\n", a >> 1);  // 2

    return 0;
}

/*
a = 5 (00000101)
b = 3 (00000011)

a & b = 1  (AND)
a | b = 7  (OR)
a ^ b = 6  (XOR)
~a    = -6 (NOT)
a << 1 = 10 (LEFT SHIFT  = a*2)
a >> 1 = 2  (RIGHT SHIFT = a/2)
*/

#include <stdio.h>

int main() {
    unsigned int n = 0b00001010;  // 10 in binary

    int pos = 2;  // bit position (0 = rightmost)

    // SET bit at position pos (force it to 1)
    n = n | (1 << pos);
    printf("After SET   bit %d: %u\n", pos, n);  // 14 (00001110)

    // CLEAR bit at position pos (force it to 0)
    n = n & ~(1 << pos);
    printf("After CLEAR bit %d: %u\n", pos, n);  // 10 (00001010)

    // TOGGLE bit at position pos (flip it)
    n = n ^ (1 << pos);
    printf("After TOGGLE bit %d: %u\n", pos, n); // 14 (00001110)

    // CHECK if bit at position pos is set
    int isSet = (n >> pos) & 1;
    printf("Bit %d is %s\n", pos, isSet ? "SET" : "CLEAR");

    // Check if number is even or odd using bit 0
    int x = 17;
    printf("\n%d is %s\n", x, (x & 1) ? "odd" : "even");

    // Check if power of 2: n & (n-1) == 0
    int vals[] = {1, 2, 3, 4, 8, 12, 16};
    for (int i = 0; i < 7; i++) {
        int v = vals[i];
        printf("%2d is %s power of 2\n", v,
               (v > 0 && (v & (v-1)) == 0) ? "a" : "NOT a");
    }

    return 0;
}

#include <stdio.h>

// Permissions struct using bit fields
// Each field uses only the specified number of bits
struct Permissions {
    unsigned int read    : 1;  // 1 bit
    unsigned int write   : 1;  // 1 bit
    unsigned int execute : 1;  // 1 bit
    unsigned int admin   : 1;  // 1 bit
};  // Total: 4 bits packed into one int

int main() {
    struct Permissions user = {1, 1, 0, 0};  // read+write, no exec, no admin

    printf("Read:    %d\n", user.read);     // 1
    printf("Write:   %d\n", user.write);    // 1
    printf("Execute: %d\n", user.execute);  // 0
    printf("Admin:   %d\n", user.admin);    // 0

    // Grant execute permission
    user.execute = 1;
    printf("\nAfter granting execute:\n");
    printf("Execute: %d\n", user.execute);  // 1

    printf("\nSize of Permissions struct: %zu bytes\n",
           sizeof(struct Permissions));  // 4 bytes (one int)

    return 0;
}

#include <stdio.h>

int main() {
    int a = 15, b = 27;
    printf("Before: a=%d, b=%d\n", a, b);

    // XOR swap — works because a^b^b = a and a^a^b = b
    a = a ^ b;  // a = 15^27
    b = a ^ b;  // b = (15^27)^27 = 15
    a = a ^ b;  // a = (15^27)^15 = 27

    printf("After:  a=%d, b=%d\n", a, b);  // a=27, b=15

    // Note: only works when a and b are different variables
    // XOR swap with same variable: a ^= a → a becomes 0!

    return 0;
}