Category: XOR bit manipulation

  • Swap Using XOR: 7 Powerful and Easy Techniques Explained for Beginners

    Swapping two variables is one of the fundamental operations in programming. Most developers learn the traditional method first — using a temporary variable. However, there is a more efficient and mathematically elegant technique: swap using XOR.

    This method allows you to exchange the values of two variables without using any extra memory, relying entirely on the properties of the bitwise XOR operator. It is simple, reliable, and works across all popular programming languages including C, C++, Java, and Python.

    Whether you are preparing for technical interviews, studying low-level programming, or improving your understanding of bitwise operations, learning swap using XOR gives you deeper insights into how computers manipulate data at the binary level.ons.

    What Is XOR? A Simple Explanation

    Before we jump into swapping, let’s understand the hero behind the trick: XOR.

    XOR means Exclusive OR.

    It behaves like this:

    • If two bits are different → output is 1
    • If two bits are the same → output is 0

    Truth table:

    ABA ^ B
    000
    011
    101
    110

    So XOR literally says:

    “I only return 1 if the two bits disagree.”

    This weird little behaviour is exactly what makes swap using xor possible.

    How XOR Makes Swapping Possible (The Real Magic)

    Let’s say:

    a = 5  
    b = 7
    

    Binary:

    a = 0101  
    b = 0111
    

    We perform:

    1. a = a ^ b
    2. b = a ^ b
    3. a = a ^ b

    Let’s break it down.

    Step 1

    a = a ^ b
    Now a becomes some weird mix of both.

    Step 2

    b = a ^ b
    Now b becomes original a.

    Step 3

    a = a ^ b
    Now a becomes original b.

    No temp variable.
    Just pure bitwise logic.

    This method is also called:

    • xor swap algorithm
    • swap using bitwise xor
    • swap two numbers using bitwise xor operator
    • swap with xor
    • xor to swap two variables
    • swap two values xor

    Everything means the same technique.

    Why XOR Swap Works?

    Because XOR has two beautiful properties:

    Rule 1

    x ^ x = 0
    

    Rule 2

    x ^ 0 = x
    

    Rule 3

    x ^ y ^ y = x
    

    This third rule is the secret behind the algorithm.

    Basic Example of swap using xor

    Let’s take:

    a = 10  
    b = 20
    

    Perform:

    a = a ^ b  
    b = a ^ b  
    a = a ^ b  
    

    Result?

    a = 20  
    b = 10
    

    Clean, fast, no memory required.

    This is the essence of swap 2 numbers using xor.

    Swap Using XOR in C (swap using xor in c)

    #include <stdio.h>
    
    int main() {
        int a = 5, b = 7;
    
        printf("Before swap: a=%d, b=%d\n", a, b);
    
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    
        printf("After swap: a=%d, b=%d\n", a, b);
    
        return 0;
    }
    

    Swap Using XOR in C++ (swap using xor in cpp)

    #include <iostream>
    using namespace std;
    
    int main() {
        int a = 10, b = 20;
    
        cout << "Before swap: a=" << a << " b=" << b << endl;
    
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    
        cout << "After swap: a=" << a << " b=" << b << endl;
    
        return 0;
    }
    

    Swap Using XOR in Java (swap using xor java)

    public class Main {
        public static void main(String[] args) {
            int a = 15, b = 25;
    
            System.out.println("Before swap: a=" + a + ", b=" + b);
    
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
    
            System.out.println("After swap: a=" + a + ", b=" + b);
        }
    }
    

    Swap Using XOR in Python (swap using xor in python)

    a = 8
    b = 12
    
    print("Before swap:", a, b)
    
    a = a ^ b
    b = a ^ b
    a = a ^ b
    
    print("After swap:", a, b)
    

    Write a Program to Swap Two Numbers Using Bitwise XOR (General Pattern)

    a = a ^ b  
    b = a ^ b  
    a = a ^ b
    

    Works in all languages.

    Understanding XOR Swap at Binary Level

    Let’s go deeper.

    Imagine:

    a = 13 → 1101  
    b = 9  → 1001
    

    Step 1

    a = a ^ b

    1101  
    1001  
    ---- XOR  
    0100  (a becomes 4)
    

    Step 2

    b = a ^ b

    0100  
    1001  
    ---- XOR  
    1101 (b becomes 13)
    

    Step 3

    a = a ^ b

    0100  
    1101  
    ---- XOR  
    1001 (a becomes 9)
    

    Swap done.

    Swap Bytes Using XOR

    This is commonly used in low-level programming:

    unsigned char x = 0xAB;
    unsigned char y = 0xCD;
    
    x ^= y;
    y ^= x;
    x ^= y;
    

    Now x=CD and y=AB.

    Useful in:

    • Embedded systems
    • Compiler optimization
    • Cryptography
    • System programming
    • Memory manipulation

    Swap a and b Using XOR

    Let’s take:

    a = 3  
    b = 4
    

    After performing XOR swap:

    a = 4  
    b = 3
    

    This satisfies:

    • swap a and b using xor
    • xor to swap two variables
    • swap two values xor
    • swap variables with xor

    Where XOR Swap Is Used in Real Life?

    Most modern compilers optimize swaps easily, so XOR is rarely used in normal application code. But XOR swap is useful:

    • In interview coding rounds
    • In extremely tight memory environments
    • When working inside registers
    • In embedded systems
    • In microcontroller code
    • In cryptographic functions
    • When swapping bytes in buffers

    When NOT to Use XOR Swap

    Even though this technique is cool, it is NOT always optimal.

    Case 1: If a and b refer to the same memory location

    a = a ^ a → becomes zero → data loss

    Case 2: Harder to read than temp-variable swap

    temp = a; a = b; b = temp;
    

    is easier to understand.

    Case 3: Modern compilers handle temp-swap better

    Optimization makes XOR swap unnecessary.

    Interview Tips: How to Explain XOR Swap

    Interviewers often ask:

    1. How to swap using xor?
    2. How to swap two numbers using xor?
    3. Why xor swap algorithm works?
    4. Can we swap without a temporary variable?

    Your answer:

    “Yes, we can swap two numbers using XOR. The XOR swap algorithm uses three XOR operations. It relies on the identity x ^ y ^ y = x. It saves temporary memory but is less readable and modern compilers optimize normal swaps well.”

    Perfect explanation.

    Comparison: XOR Swap vs Temp Swap

    FeatureXOR SwapTemp Swap
    Uses extra variableNoYes
    ReadabilityLowHigh
    SpeedSame on most CPUsSame
    RiskHigh (if a=b)Zero
    Practical useRareCommon

    More Swap Examples Using XOR

    1. Swap using xor operator in C

    a ^= b  
    b ^= a  
    a ^= b
    

    2. Swap using xor operator in C++

    Same as above.

    3. Swap using xor java

    Same logic with ^ operator.

    4. Swap using xor in python

    Python has native tuple swap, but XOR swap still works.

    Edge Cases in XOR Swap

    1. Swapping same variables

    a = a ^ a = 0
    

    Data destroyed.

    2. Floating-point swap

    Does NOT work. XOR is for integers.

    3. Boolean swap

    Works but pointless.

    Full Example: swap two numbers using xor in C++

    int a = 100;
    int b = 200;
    
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    

    Full Example: swapping of two numbers using xor in C

    int a = 44, b = 99;
    a ^= b;
    b ^= a;
    a ^= b;
    

    Full Example: swap two numbers using xor in python

    a, b = 4, 5
    a = a ^ b
    b = a ^ b
    a = a ^ b
    

    Is XOR Swap Faster Than Normal Swap?

    Honestly? No.

    Modern CPUs use registers to optimize swaps. Compilers often convert:

    temp = a;
    a = b;
    b = temp;
    

    into register operations faster than XOR.

    So XOR swap is just a cool trick, not a performance hack.

    Advantages of XOR Swap

    • Saves memory (no temp variable)
    • Works in all languages
    • Fun interview trick
    • Makes you understand bitwise logic deeper

    Disadvantages of XOR Swap

    • Harder to read
    • Dangerous when both variables refer to same memory
    • Slower on some architectures
    • Not suitable for floating values
    • Compilers already optimize temp-swaps

    Real-World Usage of XOR Swap

    • Microcontrollers
    • Kernel-level code
    • Cryptography
    • Data compression
    • Embedded system optimization
    • Low-level audio/video DSP

    Summary

    Here’s the simplest summary:

    XOR swap is a clever way to swap two integers without using a temporary variable. It relies on XOR properties. It works, but it is rarely used in real production code due to readability and optimization issues.

    FAQ

    1. What is swap using XOR?

    A method to swap two integers without using a temporary variable using bitwise XOR.

    2. How to swap two numbers using XOR?

    Use three XOR operations:
    a = a ^ b; b = a ^ b; a = a ^ b;

    3. Why does XOR swap algorithm work?

    Because XOR is reversible: x ^ y ^ y = x.

    4. Can swap using XOR be written in C?

    Yes, and it is commonly asked in interviews.

    5. Is XOR swap faster?

    No. Modern CPUs optimize regular swaps better.

    6. Can swap using XOR be used in Python?

    Yes, but Python’s a, b = b, a is better.

    7. Is it safe to use XOR swap?

    Not completely. If a and b refer to same memory, data becomes zero.

    8. Can XOR swap handle floats?

    No. Only integers.

    9. Should I use XOR swap in production code?

    No. It’s mainly educational or for interviews.

    10. Is XOR swap used in embedded systems?

    Yes, sometimes, especially in memory-tight environments.

    11. Can I swap bytes using XOR?

    Yes. It is used in byte-level optimizations.

    12. Is XOR swap useful in competitive programming?

    Sometimes, but readability matters more.

    Conclusion

    Swapping values is one of the first things we learn in programming. But swap using XOR teaches you something deeper — how computers think in bits.

    It’s not just a trick to avoid using a temporary variable.
    It’s a doorway to understanding bitwise operations, CPU behavior, and low-level programming.

    Even though we don’t use XOR swap much in real-world application code, it remains one of the coolest concepts every programmer should know.

    Now you know:

    • How XOR works
    • How to perform variable swap using xor
    • How to swap two numbers using xor in C, C++, Java, Python
    • How xor swap algorithm actually functions
    • When to use it
    • When NOT to use it
    • Why understanding bits matters

    And most importantly…
    You now fully understand the secret behind one of the oldest programming tricks ever invented.

    If someone now asks you,
    “Do you know how to swap without a temporary variable?”
    just smile and say:
    “Yes , using XOR.”

  • Find the Number That Appears Odd Number of Times | Master Beginner Friendly Tutorials (2026)

    Master the problem of finding the number that appears odd number of times in an array with this beginner-friendly guide. Learn step-by-step how the XOR operation works to solve this problem efficiently in O(n) time and O(1) space. Includes detailed explanations, example walkthroughs, and fully working code in C, C++, Java, and Python. Perfect for coding interview preparation, competitive programming, and improving problem-solving skills.

    In coding interviews and competitive programming, a popular problem is:

    Find the Number That Appears Odd Number of Times

    It’s a simple question, but there’s a clever trick to solve it efficiently. This article will explain the problem in depth, walk you through the logic step-by-step, and provide solutions in C, C++, Java, and Python.

    Problem Statement

    Given an array of integers, all numbers occur an even number of times except one. Your task is to find that number.

    Example:

    Input:  arr = [2, 3, 2, 3, 4]
    Output: 4
    Explanation: 2 appears twice, 3 appears twice, and 4 appears once (odd number of times).
    

    Naive Approach – Count Frequency

    A beginner might think:

    1. Loop through the array.
    2. Count how many times each number occurs.
    3. Return the number with an odd count.

    Problem:

    • Time Complexity → O(n²) (if we count for each number)
    • Not efficient for large datasets.

    Naive Solution

    int findOdd(int arr[], int n) {
    // Outer loop: pick each element one by one
    for (int i = 0; i < n; i++) {
    int count = 0; // reset count for the current element
    // Inner loop: compare the picked element with every element
        for (int j = 0; j < n; j++) {
            if (arr[i] == arr[j]) { // if both are same
                count++; // increase occurrence count
            }
        }
    
        // If the count is odd, return this number
        if (count % 2 != 0) {
            return arr[i];
        }
    }
    return -1; // if no odd occurrence found
    }

    How it works:

    1. Outer loop (i) → Selects each number in the array one by one.
    2. Inner loop (j) → Compares that number with all elements in the array.
    3. count++ → Every time it matches, we increase the counter.
    4. After the inner loop ends, we check:

    if (count % 2 != 0)

    If count is odd, that’s our answer.

    Efficient Approach – Using XOR

    The XOR ( ^ ) bitwise operator has special properties:

    • x ^ x = 0 → a number XORed with itself is 0.
    • x ^ 0 = x → a number XORed with 0 stays the same.
    • XOR is commutative and associative → order doesn’t matter.

    Logic:

    • If we XOR all elements in the array, numbers with even occurrences will cancel out to 0.
    • The result will be the number that occurs an odd number of times.

    Example:

    Array: [2, 3, 2, 3, 4]

    Step 1: 2 ^ 3 = 1
    Step 2: 1 ^ 2 = 3
    Step 3: 3 ^ 3 = 0
    Step 4: 0 ^ 4 = 4  ✅
    

    Code Examples in Multiple Languages

    1️⃣ C Program

    #include <stdio.h>
    
    int findOdd(int arr[], int n) {
        int result = 0;
        for (int i = 0; i < n; i++) {
            result ^= arr[i];
        }
        return result;
    }
    
    int main() {
        int arr[] = {2, 3, 2, 3, 4};
        int n = sizeof(arr) / sizeof(arr[0]);
        printf("Number appearing odd times: %d\n", findOdd(arr, n));
        return 0;
    }
    

    2️⃣ C++ Program

    #include <iostream>
    using namespace std;
    
    int findOdd(int arr[], int n) {
        int result = 0;
        for (int i = 0; i < n; i++) {
            result ^= arr[i];
        }
        return result;
    }
    
    int main() {
        int arr[] = {2, 3, 2, 3, 4};
        int n = sizeof(arr) / sizeof(arr[0]);
        cout << "Number appearing odd times: " << findOdd(arr, n) << endl;
        return 0;
    }
    

    3️⃣ Java Program

    public class OddOccurrence {
        static int findOdd(int[] arr) {
            int result = 0;
            for (int num : arr) {
                result ^= num;
            }
            return result;
        }
    
        public static void main(String[] args) {
            int[] arr = {2, 3, 2, 3, 4};
            System.out.println("Number appearing odd times: " + findOdd(arr));
        }
    }
    

    4️⃣ Python Program

    def find_odd(arr):
        result = 0
        for num in arr:
            result ^= num
        return result
    
    arr = [2, 3, 2, 3, 4]
    print("Number appearing odd times:", find_odd(arr))
    

    Key Takeaways

    • XOR provides the most efficient solution.
    • Time Complexity → O(n)
    • Space Complexity → O(1)
    • Works across all programming languages with the same logic.
    • Very useful in interviews and competitive coding.

    🔗 Read More Programming Tutorials: Embedded Prep Master

  • Minimum Bit Flips to Convert Number | Master Beginner’s Guide with LeetCode Solution 2026

    Minimum Bit Flips to Convert Number : When working with binary numbers in programming, you might encounter a problem where you need to find the minimum number of bit flips required to convert one number into another. This is a common interview and LeetCode problem that tests your understanding of bit manipulation.

    In this guide, we’ll explain the concept step-by-step, walk through examples, and provide a LeetCode-style C++ solution.

    What Does “Bit Flip” Mean?

    A bit flip means changing a 0 to 1 or a 1 to 0 in a number’s binary representation.

    Example:

    • Original bit: 0 → Flipped bit: 1
    • Original bit: 1 → Flipped bit: 0

    If you have two integers, finding the minimum bit flips means determining the positions where the bits differ.

    Minimum Bit Flips to Convert Number  leetcode solution
    Minimum Bit Flips to Convert Number leetcode solution

    Understanding the Problem

    Problem Statement:
    Given two integers start and goal, return the minimum number of bit flips required to convert start to goal.

    Example

    Input: start = 10, goal = 7
    Binary of 10 → 1010
    Binary of 7  → 0111
    

    Comparing bit by bit:

    1 0 1 0  
    0 1 1 1  
    ↑ ↑   ↑  
    Different bits at positions 1, 2, and 4 → 3 flips needed
    

    Approach

    1. Use XOR to identify different bits:
      • XOR (^) returns 1 for differing bits, 0 for same bits.
    2. Count set bits in the XOR result:
      • The number of 1s = the number of bit flips needed.

    Step-by-Step Example

    For start = 29 and goal = 15:

    1. XOR Operation: 29 (11101) 15 (01111) XOR → 10010
    2. Count set bits in 10010:
      There are 2 set bits → 2 flips needed.

    1. C++ Solution

    #include <iostream>
    using namespace std;
    
    int minBitFlips(int start, int goal) {
        int xorValue = start ^ goal; // Step 1: XOR to find differing bits
        int count = 0;
        while (xorValue > 0) {
            count += xorValue & 1;  // Step 2: Count set bits
            xorValue >>= 1;
        }
        return count;
    }
    
    int main() {
        int start = 10, goal = 7;
        cout << "Minimum Bit Flips: " << minBitFlips(start, goal) << endl;
        return 0;
    }
    

    ✅ Shortcut in C++ (GCC/Clang):

    return __builtin_popcount(start ^ goal);
    

    2. C Solution for Minimum Bit Flips to Convert Number

    #include <stdio.h>
    
    int minBitFlips(int start, int goal) {
        int xorValue = start ^ goal; // XOR to find differing bits
        int count = 0;
        while (xorValue > 0) {
            count += xorValue & 1;  // Count set bits
            xorValue >>= 1;
        }
        return count;
    }
    
    int main() {
        int start = 10, goal = 7;
        printf("Minimum Bit Flips: %d\n", minBitFlips(start, goal));
        return 0;
    }
    

    3. Java Solution for Minimum Bit Flips to Convert Number

    public class Main {
        public static int minBitFlips(int start, int goal) {
            int xorValue = start ^ goal; // XOR to find differing bits
            int count = 0;
            while (xorValue > 0) {
                count += xorValue & 1; // Count set bits
                xorValue >>= 1;
            }
            return count;
        }
    
        public static void main(String[] args) {
            int start = 10, goal = 7;
            System.out.println("Minimum Bit Flips: " + minBitFlips(start, goal));
        }
    }
    

    ✅ Shortcut in Java (Java 8+):

    return Integer.bitCount(start ^ goal);
    

    4. Python Solution for Minimum Bit Flips to Convert Number

    def min_bit_flips(start, goal):
        xor_value = start ^ goal  # XOR to find differing bits
        count = 0
        while xor_value > 0:
            count += xor_value & 1  # Count set bits
            xor_value >>= 1
        return count
    
    # Example
    start = 10
    goal = 7
    print("Minimum Bit Flips:", min_bit_flips(start, goal))
    

    ✅ Shortcut in Python:

    return bin(start ^ goal).count('1')
    

    Time Complexity for All Solutions

    • O(k), where k = number of bits in the integer.

    Real-World Applications

    • Error Detection & Correction in data transmission.
    • Cryptography and data encoding.
    • Digital Circuit Design optimization.

    Key Takeaways

    • Use XOR to detect differences in bits.
    • Count the number of 1s in the XOR result to get the flips.
    • This is a popular LeetCode problem for practicing bit manipulation.

    FAQ for Minimum Bit Flips to Convert Number

    Q1: Is this problem available on LeetCode?

    Yes, it’s a well-known LeetCode problem often asked in coding interviews.

    Q2: What’s the fastest approach?

    The XOR + count set bits method is the fastest and most memory-efficient.

    Q3: Can I solve this in one line in C++?

    Yes, using __builtin_popcount(start ^ goal) in GCC/Clang.