Check if Number is Even or Odd Using Bits in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a number is even using bitwise AND.

DSA Typescript

function isEven(num: number): boolean {
  return (num [1] 1) === 0;
}

Drag options to blanks, or click blank then click option'

A^

B&

C|

D>>

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' instead of AND '&'.

Using XOR '^' which does not check evenness.

Using right shift '>>' which shifts bits instead of checking.

The bitwise AND operator '&' with 1 checks the least significant bit. If it is 0, the number is even.

2fill in blank

medium

Complete the code to check if a number is odd using bitwise operation.

DSA Typescript

function isOdd(num: number): boolean {
  return (num [1] 1) === 1;
}

Drag options to blanks, or click blank then click option'

A&

B|

C^

D>>

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' which does not isolate the least significant bit.

Using XOR '^' which toggles bits.

Using right shift '>>' which shifts bits instead of checking.

Using bitwise AND '&' with 1 checks if the least significant bit is 1, which means the number is odd.

3fill in blank

hard

Fix the error in the function to correctly return true if number is even.

DSA Typescript

function checkEven(num: number): boolean {
  if ((num [1] 1) == 1) {
    return false;
  }
  return true;
}

Drag options to blanks, or click blank then click option'

A|

B^

C>>

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' which does not isolate the bit.

Using XOR '^' which toggles bits.

Using right shift '>>' which shifts bits instead of checking.

The bitwise AND '&' with 1 checks the least significant bit. If it is 1, the number is odd, so return false; otherwise true.

4fill in blank

hard

Fill both blanks to create a function that returns 'Even' or 'Odd' using bitwise check.

DSA Typescript

function evenOrOdd(num: number): string {
  if ((num [1] 1) === [2]) {
    return 'Odd';
  }
  return 'Even';
}

Drag options to blanks, or click blank then click option'

A&

B|

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' instead of AND '&'.

Comparing to 0 instead of 1 for odd check.

Use bitwise AND '&' with 1 to check the least significant bit. If it equals 1, the number is odd.

5fill in blank

hard

Fill all three blanks to create a function that returns true if number is odd, false if even, using bitwise operators.

DSA Typescript

function isNumberOdd(num: number): boolean {
  return (num [1] [2]) === [3];
}

Drag options to blanks, or click blank then click option'

A&

B|

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' which does not isolate the bit.

Comparing to 0 instead of 1 for odd check.

Use bitwise AND '&' with 1 and compare to 1 to check if number is odd.

Practice

1. What does the expression num & 1 check when determining if a number is even or odd?

easy

A. It checks if num is greater than 1.

B. It checks if the least significant bit of num is 1, indicating odd number.

C. It checks if num is divisible by 2 without remainder.

D. It checks if num is negative.

Solution

1. Step 1: Understand bitwise AND with 1

   The expression num & 1 isolates the least significant bit (rightmost bit) of the number.

2. Step 2: Interpret the least significant bit

   If the least significant bit is 1, the number is odd; if 0, it is even.

3. Final Answer:

   It checks if the least significant bit of num is 1, indicating odd number. -> Option B

4. Quick Check:

   num & 1 = 1 means odd [OK]

Hint: Check last bit with & 1; 1 means odd, 0 means even [OK]

Common Mistakes:

• Thinking & 1 checks divisibility by 2
• Confusing bitwise AND with logical AND
• Assuming it checks if number is negative

2. Which of the following TypeScript code snippets correctly checks if a number n is even using bitwise operators?

easy

A. if ((n & 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

B. if ((n | 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

C. if ((n & 0) === 1) { console.log('Even'); } else { console.log('Odd'); }

D. if ((n ^ 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

Solution

1. Step 1: Understand bitwise AND with 1

   The expression n & 1 extracts the least significant bit of n.

2. Step 2: Check if least significant bit is zero

   If (n & 1) === 0, the number is even; otherwise, it is odd.

3. Final Answer:

   if ((n & 1) === 0) { console.log('Even'); } else { console.log('Odd'); } -> Option A

4. Quick Check:

   Use n & 1 === 0 for even check [OK]

Hint: Use (n & 1) === 0 to check even numbers [OK]

Common Mistakes:

• Using bitwise OR instead of AND
• Comparing with wrong values like 0 or 1 incorrectly
• Using XOR without understanding its effect

3. What will be the output of the following TypeScript code?

const numbers = [2, 3, 4, 5];
numbers.forEach(num => {
  if (num & 1) {
    console.log(num + ' is Odd');
  } else {
    console.log(num + ' is Even');
  }
});

medium

A. 2 is Odd
3 is Odd
4 is Odd
5 is Odd

B. 2 is Even
3 is Even
4 is Even
5 is Even

C. 2 is Odd
3 is Even
4 is Odd
5 is Even

D. 2 is Even
3 is Odd
4 is Even
5 is Odd

Solution

1. Step 1: Evaluate bitwise AND for each number

   For each number, num & 1 checks the last bit: 2 & 1 = 0 (even), 3 & 1 = 1 (odd), 4 & 1 = 0 (even), 5 & 1 = 1 (odd).

2. Step 2: Print corresponding output

   Numbers with num & 1 === 1 print 'Odd', others print 'Even'.

3. Final Answer:

   2 is Even 3 is Odd 4 is Even 5 is Odd -> Option D

4. Quick Check:

   Bitwise check matches even/odd output [OK]

Hint: Check each number's last bit; 1 means odd, 0 means even [OK]

Common Mistakes:

• Assuming all numbers are odd
• Confusing bitwise AND with logical AND
• Printing wrong labels for even/odd

4. Identify the error in this TypeScript code that tries to check if a number x is odd using bits:

function isOdd(x: number): boolean {
  return x & 1 === 1;
}

medium

A. The bitwise AND operator has lower precedence than ===, causing wrong evaluation.

B. The function should use bitwise OR instead of AND.

C. The function should return a string, not boolean.

D. There is no error; the code works correctly.

Solution

1. Step 1: Check operator precedence in expression

   Bitwise AND (&) has lower precedence than strict equality (===), so x & 1 === 1 is evaluated as x & (1 === 1).

2. Step 2: Understand the evaluation result

   1 === 1 is true, which converts to 1, so expression becomes x & 1. This returns a number, not a boolean, causing unexpected behavior.

3. Step 3: Fix the expression with parentheses

   Use parentheses: (x & 1) === 1 to ensure correct evaluation order.

4. Final Answer:

   The bitwise AND operator has lower precedence than ===, causing wrong evaluation. -> Option A

5. Quick Check:

   Use parentheses: (x & 1) === 1 [OK]

Hint: Use parentheses around bitwise operation before comparison [OK]

Common Mistakes:

• Ignoring operator precedence
• Using bitwise OR instead of AND
• Returning wrong data type

5. You want to filter an array of numbers to keep only the even ones using bitwise operations in TypeScript. Which code snippet correctly achieves this?

const nums = [10, 15, 22, 33, 40];
const evens = nums.filter( /* your code here */ );
console.log(evens);

hard

A. nums.filter(num => (num & 1) === 1)

B. nums.filter(num => (num | 1) === 0)

C. nums.filter(num => (num & 1) === 0)

D. nums.filter(num => (num ^ 1) === 0)

Solution

1. Step 1: Understand filtering condition for even numbers

   Even numbers have their least significant bit as 0, so (num & 1) === 0 checks for even numbers.

2. Step 2: Apply filter with correct condition

   Using nums.filter(num => (num & 1) === 0) returns only even numbers from the array.

3. Step 3: Verify output

   For [10, 15, 22, 33, 40], the filtered array is [10, 22, 40].

4. Final Answer:

   nums.filter(num => (num & 1) === 0) -> Option C

5. Quick Check:

   Filter even numbers with (num & 1) === 0 [OK]

Hint: Filter with (num & 1) === 0 to get even numbers [OK]

Common Mistakes:

• Using bitwise OR or XOR incorrectly
• Filtering for odd numbers instead of even
• Missing parentheses causing wrong evaluation