int a = 15, b = 4;

int sum = a + b;        // 19
int difference = a - b; // 11
int product = a * b;    // 60
int quotient = a / b;   // 3 (integer division)
int remainder = a % b;  // 3 (15 = 4*3 + 3)

// Check if number is even or odd
public static boolean isEven(int n) {
    return n % 2 == 0;
}

// Find GCD using Euclidean algorithm
public static int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// Generate multiplication table
public static void multiplicationTable(int n) {
    System.out.println("Table of " + n + ":");
    for (int i = 1; i <= 10; i++) {
        System.out.println(n + " x " + i + " = " + (n * i));
    }
}

// Simple Interest Calculator
public class SimpleInterest {
    public static void main(String[] args) {
        double principal = 10000;  // Principal amount
        double rate = 8.5;         // Rate per annum
        int time = 3;              // Time in years
        
        // SI = (P * R * T) / 100
        double simpleInterest = (principal * rate * time) / 100;
        double amount = principal + simpleInterest;
        
        System.out.println("Principal: ₹" + principal);
        System.out.println("Rate: " + rate + "% per annum");
        System.out.println("Time: " + time + " years");
        System.out.println("Simple Interest: ₹" + simpleInterest);
        System.out.println("Total Amount: ₹" + amount);
    }
}

int a = 12;  // Binary: 1100
int b = 10;  // Binary: 1010

System.out.println(a & b);   // 8  (1000)
System.out.println(a | b);   // 14 (1110)
System.out.println(a ^ b);   // 6  (0110)
System.out.println(~a);      // -13 (inverted)

// Age verification system
int age = 20;
boolean canVote = age >= 18;
boolean canDrive = age >= 16;
boolean isMinor = age < 18;

System.out.println("Can vote: " + canVote);    // true
System.out.println("Can drive: " + canDrive);  // true
System.out.println("Is minor: " + isMinor);    // false

// Grade comparison
int marks = 85;
boolean passed = marks >= 40;
boolean distinction = marks >= 75;
boolean firstClass = marks >= 60;

// Character comparison
char grade = 'B';
boolean isGoodGrade = grade <= 'B';  // true

// Temperature check
double temp = 36.5;
boolean fever = temp > 37.0;
boolean normal = temp >= 36.1 && temp <= 37.2;

// Login validation
String username = "admin";
String password = "password123";
boolean validLogin = username.equals("admin") && 
                    password.equals("password123");

// Age-based permissions
int age = 25;
boolean canBuyAlcohol = age >= 21;
boolean canBuyTobacco = age >= 18;
boolean canBuyEither = canBuyAlcohol || canBuyTobacco;

// Student eligibility
int attendance = 85;
int marks = 70;
boolean eligible = attendance >= 75 && marks >= 40;
boolean needsImprovement = !(attendance >= 75);

// Weather conditions
boolean isSunny = true;
boolean isWarm = true;
boolean isWeekend = false;

boolean perfectDay = isSunny && isWarm && isWeekend;
boolean goodDay = (isSunny || isWarm) && !isWeekend;

// Safe division check
int a = 10, b = 0;
if (b != 0 && a / b > 5) {
    System.out.println("Division successful");
}
// b != 0 is false, so a/b is never evaluated

// Array bounds checking
int[] arr = {1, 2, 3, 4, 5};
int index = 10;
if (index < arr.length && arr[index] > 0) {
    System.out.println("Valid positive element");
}
// index < arr.length is false, so arr[index] not accessed

// User authentication
String user = null;
if (user != null && user.length() > 0) {
    System.out.println("Valid user");
}
// user != null is false, so user.length() not called

// Performance optimization
boolean expensiveOperation() {
    System.out.println("Expensive operation called");
    return true;
}

boolean result = false || expensiveOperation();
// expensiveOperation() is called

boolean result2 = true || expensiveOperation();
// expensiveOperation() is NOT called

// Example 1: Arithmetic precedence
int result1 = 10 + 5 * 2;     // 20 (not 30)
int result2 = (10 + 5) * 2;   // 30 (parentheses first)

// Example 2: Mixed operations
boolean check1 = 5 > 3 && 10 < 20;  // true && true = true
boolean check2 = 5 + 3 > 10 || 2 < 5; // false || true = true

// Example 3: Complex expression
int a = 5, b = 10, c = 15;
boolean complex = a + b * 2 > c && c % 5 == 0;
// Step 1: b * 2 = 20
// Step 2: a + 20 = 25
// Step 3: 25 > 15 = true
// Step 4: 15 % 5 = 0
// Step 5: 0 == 0 = true
// Step 6: true && true = true

// Example 4: Assignment with calculation
int x = 10;
x += 5 * 2;  // x = x + (5 * 2) = 10 + 10 = 20

// Problem 1: Leap year checker
public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) 
           || (year % 400 == 0);
}

// Problem 2: Valid triangle checker
public static boolean isValidTriangle(int a, int b, int c) {
    return (a + b > c) && (a + c > b) && (b + c > a);
}

// Problem 3: Grade calculator with multiple conditions
public static char calculateGrade(int marks, int attendance) {
    if (attendance < 75) {
        return 'F';  // Fail due to attendance
    }
    
    if (marks >= 90 && attendance >= 90) return 'A';
    else if (marks >= 80) return 'B';
    else if (marks >= 70) return 'C';
    else if (marks >= 60) return 'D';
    else return 'F';
}

// Problem 4: Number classification
public static void classifyNumber(int n) {
    boolean isPositive = n > 0;
    boolean isEven = n % 2 == 0;
    boolean isDivisibleBy5 = n % 5 == 0;
    
    System.out.println("Number: " + n);
    System.out.println("Positive: " + isPositive);
    System.out.println("Even: " + isEven);
    System.out.println("Divisible by 5: " + isDivisibleBy5);
    
    if (isPositive && isEven && isDivisibleBy5) {
        System.out.println("Perfect number for our criteria!");
    }
}

// Problem 5: Student pass/fail with conditions
public static String studentResult(int math, int science, 
                                  int english, int attendance) {
    boolean passIndividual = math >= 40 && science >= 40 
                           && english >= 40;
    double average = (math + science + english) / 3.0;
    boolean passOverall = average >= 50;
    boolean attendanceOK = attendance >= 75;
    
    if (passIndividual && passOverall && attendanceOK) {
        return "PASS";
    } else {
        return "FAIL";
    }
}

public class BankAccount {
    private double balance;
    private boolean isActive;
    
    public boolean withdraw(double amount) {
        boolean sufficientFunds = balance >= amount;
        boolean validAmount = amount > 0;
        boolean accountActive = isActive;
        
        if (sufficientFunds && validAmount && accountActive) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    public double calculateInterest(int days) {
        double dailyRate = 0.04 / 365;  // 4% annual
        return balance * dailyRate * days;
    }
}

public class Student {
    public static String evaluatePerformance(
        int attendance, int assignment, int exam) {
        
        boolean attendanceGood = attendance >= 75;
        boolean assignmentPass = assignment >= 40;
        boolean examPass = exam >= 50;
        
        int total = assignment + exam;
        boolean overallPass = total >= 100;
        
        if (attendanceGood && assignmentPass && 
            examPass && overallPass) {
            
            if (total >= 160) return "Excellent";
            else if (total >= 140) return "Good";
            else return "Satisfactory";
        } else {
            return "Needs Improvement";
        }
    }
}

public class BitwiseAdvanced {
    public static void main(String[] args) {
        demonstrateBitwiseTricks();
        implementBitManipulation();
        showRealWorldApplications();
        performanceBenchmarks();
    }
    
    private static void demonstrateBitwiseTricks() {
        System.out.println("=== Advanced Bitwise Tricks ===");
        
        // Trick 1: Swap without temporary variable
        int a = 15, b = 10;
        System.out.println("Before swap: a=" + a + ", b=" + b);
        
        a = a ^ b;  // a = 15 ^ 10 = 5
        b = a ^ b;  // b = 5 ^ 10 = 15
        a = a ^ b;  // a = 5 ^ 15 = 10
        
        System.out.println("After XOR swap: a=" + a + ", b=" + b);
        
        // Trick 2: Check if number is power of 2
        int[] numbers = {1, 2, 3, 4, 5, 8, 15, 16, 32, 33};
        
        System.out.println("\nPower of 2 check:");
        for (int num : numbers) {
            boolean isPowerOf2 = (num > 0) && ((num & (num - 1)) == 0);
            System.out.println(num + " is power of 2: " + isPowerOf2 + 
                             " (Binary: " + Integer.toBinaryString(num) + ")");
        }
        
        // Trick 3: Count set bits (Brian Kernighan's algorithm)
        System.out.println("\nCounting set bits:");
        for (int num : numbers) {
            int count = countSetBits(num);
            System.out.println(num + " (" + Integer.toBinaryString(num) + 
                             ") has " + count + " set bits");
        }
        
        // Trick 4: Find the only non-duplicate in array
        int[] array = {2, 3, 5, 4, 5, 3, 4};
        int unique = findUniqueNumber(array);
        System.out.println("\nUnique number in [2,3,5,4,5,3,4]: " + unique);
    }
    
    public static int countSetBits(int n) {
        int count = 0;
        while (n != 0) {
            n = n & (n - 1);  // Remove the rightmost set bit
            count++;
        }
        return count;
    }
    
    public static int findUniqueNumber(int[] arr) {
        int result = 0;
        for (int num : arr) {
            result ^= num;  // XOR cancels out duplicates
        }
        return result;
    }
    
    private static void implementBitManipulation() {
        System.out.println("\n=== Bit Manipulation Operations ===");
        
        int number = 44;  // Binary: 101100
        System.out.println("Original number: " + number + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(number)).replace(' ', '0') + ")");
        
        // Set specific bits
        int setBit2 = setBit(number, 2);
        System.out.println("Set bit 2: " + setBit2 + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(setBit2)).replace(' ', '0') + ")");
        
        // Clear specific bits
        int clearBit3 = clearBit(number, 3);
        System.out.println("Clear bit 3: " + clearBit3 + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(clearBit3)).replace(' ', '0') + ")");
        
        // Toggle specific bits
        int toggleBit5 = toggleBit(number, 5);
        System.out.println("Toggle bit 5: " + toggleBit5 + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(toggleBit5)).replace(' ', '0') + ")");
        
        // Check if bit is set
        boolean isBit2Set = isBitSet(number, 2);
        boolean isBit1Set = isBitSet(number, 1);
        System.out.println("Is bit 2 set: " + isBit2Set);
        System.out.println("Is bit 1 set: " + isBit1Set);
        
        // Get rightmost set bit
        int rightmostSetBit = number & -number;
        System.out.println("Rightmost set bit: " + rightmostSetBit + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(rightmostSetBit)).replace(' ', '0') + ")");
    }
    
    public static int setBit(int num, int pos) {
        return num | (1 << pos);
    }
    
    public static int clearBit(int num, int pos) {
        return num & ~(1 << pos);
    }
    
    public static int toggleBit(int num, int pos) {
        return num ^ (1 << pos);
    }
    
    public static boolean isBitSet(int num, int pos) {
        return (num & (1 << pos)) != 0;
    }
    
    private static void showRealWorldApplications() {
        System.out.println("\n=== Real-World Bitwise Applications ===");
        
        // Application 1: Permission system
        demonstratePermissionSystem();
        
        // Application 2: Flag management
        demonstrateFlagManagement();
        
        // Application 3: Efficient storage
        demonstrateEfficientStorage();
    }
    
    private static void demonstratePermissionSystem() {
        System.out.println("\n1. Permission System:");
        
        // Define permissions as bit positions
        final int READ = 1;    // 001
        final int WRITE = 2;   // 010
        final int EXECUTE = 4; // 100
        
        // User permissions
        int adminPerms = READ | WRITE | EXECUTE;  // 111 (7)
        int userPerms = READ | WRITE;             // 011 (3)
        int guestPerms = READ;                    // 001 (1)
        
        System.out.println("Admin permissions: " + adminPerms + 
                          " (Binary: " + Integer.toBinaryString(adminPerms) + ")");
        System.out.println("User permissions: " + userPerms + 
                          " (Binary: " + Integer.toBinaryString(userPerms) + ")");
        System.out.println("Guest permissions: " + guestPerms + 
                          " (Binary: " + Integer.toBinaryString(guestPerms) + ")");
        
        // Check permissions
        System.out.println("Admin can read: " + ((adminPerms & READ) != 0));
        System.out.println("User can execute: " + ((userPerms & EXECUTE) != 0));
        System.out.println("Guest can write: " + ((guestPerms & WRITE) != 0));
        
        // Add permission
        userPerms |= EXECUTE;
        System.out.println("User after adding execute: " + userPerms + 
                          " (Binary: " + Integer.toBinaryString(userPerms) + ")");
        
        // Remove permission
        adminPerms &= ~WRITE;
        System.out.println("Admin after removing write: " + adminPerms + 
                          " (Binary: " + Integer.toBinaryString(adminPerms) + ")");
    }
    
    private static void demonstrateFlagManagement() {
        System.out.println("\n2. Feature Flag Management:");
        
        // Feature flags for an application
        final int FEATURE_A = 1 << 0;  // 00001
        final int FEATURE_B = 1 << 1;  // 00010
        final int FEATURE_C = 1 << 2;  // 00100
        final int FEATURE_D = 1 << 3;  // 01000
        final int FEATURE_E = 1 << 4;  // 10000
        
        // Current enabled features
        int enabledFeatures = FEATURE_A | FEATURE_C | FEATURE_E;
        
        System.out.println("Enabled features: " + enabledFeatures + 
                          " (Binary: " + String.format("%5s", 
                          Integer.toBinaryString(enabledFeatures)).replace(' ', '0') + ")");
        
        // Check if features are enabled
        System.out.println("Feature A enabled: " + ((enabledFeatures & FEATURE_A) != 0));
        System.out.println("Feature B enabled: " + ((enabledFeatures & FEATURE_B) != 0));
        System.out.println("Feature C enabled: " + ((enabledFeatures & FEATURE_C) != 0));
        
        // Toggle feature B
        enabledFeatures ^= FEATURE_B;
        System.out.println("After toggling Feature B: " + enabledFeatures + 
                          " (Binary: " + String.format("%5s", 
                          Integer.toBinaryString(enabledFeatures)).replace(' ', '0') + ")");
    }
    
    private static void demonstrateEfficientStorage() {
        System.out.println("\n3. Efficient Storage Example:");
        
        // Store 8 boolean flags in a single byte
        byte flags = 0;
        
        // Set some flags
        flags |= (1 << 0);  // Set flag 0
        flags |= (1 << 2);  // Set flag 2
        flags |= (1 << 7);  // Set flag 7
        
        System.out.println("Flags byte: " + flags + 
                          " (Binary: " + String.format("%8s", 
                          Integer.toBinaryString(flags & 0xFF)).replace(' ', '0') + ")");
        
        // Read flags
        for (int i = 0; i < 8; i++) {
            boolean isSet = (flags & (1 << i)) != 0;
            System.out.println("Flag " + i + ": " + isSet);
        }
        
        System.out.println("Memory saved: Instead of 8 booleans (8 bytes), we use 1 byte!");
    }
    
    private static void performanceBenchmarks() {
        System.out.println("\n=== Bitwise Performance Benchmarks ===");
        
        int iterations = 1_000_000;
        int number = 12345;
        
        // Benchmark: Multiplication vs Bit Shifting
        long startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int result = number * 8;  // Regular multiplication
        }
        long multiplyTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int result = number << 3;  // Bit shifting (* 8)
        }
        long shiftTime = System.nanoTime() - startTime;
        
        System.out.println("Multiplication (* 8): " + multiplyTime + " ns");
        System.out.println("Bit shifting (<< 3): " + shiftTime + " ns");
        System.out.println("Bit shifting is " + 
                          ((double) multiplyTime / shiftTime) + "x faster");
        
        // Benchmark: Modulo vs Bitwise AND
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int result = i % 8;  // Regular modulo
        }
        long moduloTime = System.nanoTime() - startTime;
        
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            int result = i & 7;  // Bitwise AND (% 8)
        }
        long andTime = System.nanoTime() - startTime;
        
        System.out.println("Modulo (% 8): " + moduloTime + " ns");
        System.out.println("Bitwise AND (& 7): " + andTime + " ns");
        System.out.println("Bitwise AND is " + 
                          ((double) moduloTime / andTime) + "x faster");
    }
}