Bit manipulation is a powerful technique used to solve problems by directly manipulating bits. Here are some common bit manipulation techniques:

1. AND Operation (&):

• Used to clear bits.
• Example: To check if the least significant bit (LSB) is set: java if (x & 1) { // LSB is set }

1. OR Operation (|):

• Used to set bits.
• Example: To set the 3rd bit of a number to 1: java x = x | (1 << 3);

1. XOR Operation (^):

• Used to flip bits.
• Example: To toggle the 3rd bit: java x = x ^ (1 << 3);

1. NOT Operation (~):

• Flips all the bits of a number.
• Example: java x = ~x; // All bits are flipped

1. Left Shift (<<):

• Shifts bits to the left, essentially multiplying the number by powers of 2.
• Example: java x = x << 2; // Equivalent to multiplying x by 4

1. Right Shift (>>):

• Shifts bits to the right, effectively dividing the number by powers of 2.
• Example: java x = x >> 2; // Equivalent to dividing x by 4

1. Unsigned Right Shift (>>>):

• Shifts bits to the right without considering the sign of the number (used for unsigned integers).
• Example: java x = x >>> 2;

1. Checking if a number is a power of 2:

• A number is a power of 2 if it has exactly one bit set to 1.
• Example: java boolean isPowerOfTwo = (x > 0) && (x & (x - 1)) == 0;

1. Counting Set Bits (Hamming Weight):

• To count the number of 1s in the binary representation of a number: java int count = 0; while (x > 0) { count++; x = x & (x - 1); // This clears the lowest set bit }

1. Clearing the Lowest Set Bit:

   • To clear the lowest set bit (i.e., turn the first 1 bit from the right to 0): java x = x & (x - 1);

2. Setting the Lowest Unset Bit:

   • To set the lowest 0 bit (turn the first 0 bit from the right to 1): java x = x | (x + 1);

3. Extracting a Specific Bit:

   • To get the value of the nth bit: java boolean bit = (x & (1 << n)) != 0;

These techniques are useful for optimizing certain problems, especially those involving binary arithmetic, number properties, or data representation.

Title:

Debugging Techniques for Competitive Programming: How to Identify and Fix Common Errors"**

Introduction:
Debugging is an essential skill in competitive programming. Whether it’s a runtime error, wrong answer (WA), or time limit exceeded (TLE), debugging effectively can make or break your performance in contests. In this blog, I’ll share simple and practical debugging techniques that will help you fix errors quickly.

1. Understand the Common Types of Errors:

Before debugging, identify the type of error:
- Syntax Error: Missing semicolons, unmatched parentheses, etc.
- Runtime Error: Division by zero, invalid memory access, or stack overflow.
- Wrong Answer (WA): Code executes but produces incorrect results.
- Time Limit Exceeded (TLE): Code takes too long to run, often due to inefficient algorithms.

2. Debugging Techniques:

A. Use cout Statements (Basic Approach):

• Add cout statements to check variable values at key points in the program.
• Example:
  cpp cout << "Value of x: " << x << endl; cout << "Array state: "; for (int i = 0; i < n; i++) cout << arr[i] << " "; cout << endl;
• Focus on edge cases, like empty arrays, single elements, or maximum constraints.

B. Use Assertions:

• Add assertions to check if your assumptions are correct.
• Example:
  cpp assert(n > 0 && "Array size must be greater than zero!");

C. Binary Search on the Bug:

• If the issue occurs for specific inputs, narrow down the problematic part using binary search on the input or the logic.
• Example: For a segmentation fault, print variable states at different points to find where it fails.

D. Debug Edge Cases First:

• Test small or extreme inputs like:
• n = 1
• All elements are the same
• Negative values or large constraints (n = 10^5)

E. Check Data Types:

• Use appropriate data types to prevent overflow.
• Example:
  cpp long long sum = 0; // Use long long for sums exceeding int limits. sum += arr[i];

F. Use Debugging Tools:

• Use GDB or online tools like ideone.com for step-by-step debugging.
• Use macros to simplify debugging during contests:
  cpp #define debug(x) cout << #x << ": " << x << endl; debug(n); // Prints "n: <value>"

3. Preventing Errors:

A. Modularize Your Code:

• Break the program into smaller functions.
• Example: Write separate functions for input handling, logic, and output.

B. Follow Constraints Strictly:

• Carefully read the problem statement and respect constraints.
• Example: If 1 ≤ n ≤ 100, don’t assume n can be 0 or negative.

C. Write Test Cases:

• Write your own test cases to validate edge conditions.
• Use brute force and compare outputs with your optimized solution for random inputs.

4. Example:

Problem:
Given an array of integers, find the sum of all even numbers.

Incorrect Code:
```cpp

include

using namespace std;

int main() { int arr[] = {1, 2, 3, 4, 5}; int n = sizeof(arr) / sizeof(arr[0]); int sum = 0;

for (int i = 0; i < n; i++) {
    if (arr[i] % 2 == 0); // Error: Semicolon ends the if condition prematurely
        sum += arr[i];
}

cout << "Sum of even numbers: " << sum << endl;
return 0;

} ```

Error:
The semicolon after the if statement causes incorrect logic.

Debugging Steps:
1. Add cout statements inside the loop:
cpp cout << "arr[" << i << "] = " << arr[i] << ", sum = " << sum << endl;
2. Notice that all numbers are being added, not just even ones.
3. Fix the semicolon mistake.

Correct Code:
```cpp

include

using namespace std;

int main() { int arr[] = {1, 2, 3, 4, 5}; int n = sizeof(arr) / sizeof(arr[0]); int sum = 0;

for (int i = 0; i < n; i++) {
    if (arr[i] % 2 == 0) { // No semicolon here
        sum += arr[i];
    }
}

cout << "Sum of even numbers: " << sum << endl;
return 0;

} ```

Output:
Sum of even numbers: 6

5. Key Takeaways:

• Debugging is an iterative process. Start small, isolate the issue, and fix it step-by-step.
• Practice writing clean, modular code to make debugging easier.
• Use debugging tools and macros during contests to save time.