Check if Number is Power of Two in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code snippet?

Given the function to check if a number is a power of two, what will be printed when calling isPowerOfTwo(16)?

DSA Typescript

function isPowerOfTwo(n: number): boolean {
  return n > 0 && (n & (n - 1)) === 0;
}

console.log(isPowerOfTwo(16));

A true

B false

C undefined

D TypeError

💡 Hint

Remember that powers of two have only one bit set in binary.

The function uses a bitwise trick: a power of two number has exactly one bit set. The expression n & (n - 1) clears the lowest set bit. If the result is zero, it means only one bit was set, so the number is a power of two.

❓ Predict Output

intermediate

What is the output of this code snippet?

What will isPowerOfTwo(0) return in the following function?

DSA Typescript

function isPowerOfTwo(n: number): boolean {
  return n > 0 && (n & (n - 1)) === 0;
}

console.log(isPowerOfTwo(0));

A SyntaxError

B false

C true

D RangeError

💡 Hint

Zero is not a power of two.

The function returns false because the first condition n > 0 fails for zero.

🔧 Debug

advanced

What error does this code raise?

Identify the error when running this code snippet:

DSA Typescript

function isPowerOfTwo(n: number): boolean {
  return n > 0 && (n & (n - 1)) === 0;
}

console.log(isPowerOfTwo(8));

A No error, outputs true

B TypeError

C ReferenceError

D SyntaxError

💡 Hint

Check the operator used for comparison.

The code uses a single equals sign = instead of the comparison operator ===, causing a syntax error.

🚀 Application

advanced

How many numbers between 1 and 16 (inclusive) are powers of two?

Using the power of two check, count how many numbers from 1 to 16 are powers of two.

DSA Typescript

function isPowerOfTwo(n: number): boolean {
  return n > 0 && (n & (n - 1)) === 0;
}

let count = 0;
for (let i = 1; i <= 16; i++) {
  if (isPowerOfTwo(i)) count++;
}
console.log(count);

A 4

B 6

C 5

D 7

💡 Hint

Powers of two up to 16 are 1, 2, 4, 8, 16.

The powers of two between 1 and 16 are 1, 2, 4, 8, and 16, totaling 5 numbers.

🧠 Conceptual

expert

Which option correctly explains why n & (n - 1) === 0 checks for power of two?

Why does the expression n & (n - 1) === 0 return true only for powers of two?

A Because powers of two have exactly one bit set, and subtracting 1 flips all bits after that bit, so ANDing results in zero.

B Because powers of two are always even numbers, and this expression checks if n is divisible by 2.

C Because this expression counts the number of set bits in n and returns true if it is more than one.

D Because subtracting 1 from any number always results in zero when ANDed with the original number.

💡 Hint

Think about binary representation of powers of two.

Powers of two have only one bit set. Subtracting 1 flips all bits after that set bit. ANDing them clears the only set bit, resulting in zero.

Practice

1. What does it mean if a number is a power of two?

easy

A. It is divisible by 3

B. It is always an odd number

C. It can be written as 2 raised to some integer exponent

D. It is a prime number

Solution

1. Step 1: Understand the definition of power of two

   A number is a power of two if it equals 2 raised to an integer exponent, like 2^0=1, 2^1=2, 2^2=4, etc.

2. Step 2: Check other options

   Odd numbers, divisibility by 3, or primality do not define powers of two.

3. Final Answer:

   It can be written as 2 raised to some integer exponent -> Option C

4. Quick Check:

   Power of two = 2^n [OK]

Hint: Power of two means 2 multiplied by itself n times [OK]

Common Mistakes:

• Thinking all powers of two are odd
• Confusing powers of two with prime numbers
• Assuming divisibility by 3 means power of two

2. Which of the following TypeScript expressions correctly checks if a number n is a power of two using bitwise operations?

easy

A. return n > 0 && (n & (n - 1)) === 0;

B. return n > 0 && (n | (n - 1)) === 0;

C. return n > 0 && (n & (n + 1)) === 0;

D. return n > 0 && (n ^ (n - 1)) === 0;

Solution

1. Step 1: Understand the bitwise check for power of two

   The expression n & (n - 1) clears the lowest set bit. For powers of two, this results in zero.

2. Step 2: Analyze each option

   return n > 0 && (n & (n - 1)) === 0; uses the correct bitwise AND with (n-1). Options A, B, and C use incorrect bitwise operators or operands.

3. Final Answer:

   return n > 0 && (n & (n - 1)) === 0; -> Option A

4. Quick Check:

   Bitwise AND with (n-1) = 0 means power of two [OK]

Hint: Use n & (n-1) === 0 to check power of two [OK]

Common Mistakes:

• Using bitwise OR instead of AND
• Using (n + 1) instead of (n - 1)
• Forgetting to check n > 0

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

function isPowerOfTwo(n: number): boolean {
  return n > 0 && (n & (n - 1)) === 0;
}
console.log(isPowerOfTwo(16));
console.log(isPowerOfTwo(18));

medium

A. true true

B. false true

C. false false

D. true false

Solution

1. Step 1: Check isPowerOfTwo(16)

   16 in binary is 10000. 16 & 15 (01111) = 0, so returns true.

2. Step 2: Check isPowerOfTwo(18)

   18 in binary is 10010. 18 & 17 (10001) = 16 (not zero), so returns false.

3. Final Answer:

   true false -> Option D

4. Quick Check:

   16 is power of two, 18 is not [OK]

Hint: Check bitwise AND with (n-1) to confirm power of two [OK]

Common Mistakes:

• Assuming 18 is power of two because it's even
• Ignoring the n > 0 condition
• Misreading bitwise AND results

4. Identify the error in this TypeScript function that checks if a number is a power of two:

function checkPower(n: number): boolean {
  return (n & (n - 1)) === 0;
}

medium

A. Missing check for n > 0 to avoid false positives

B. Incorrect bitwise operator used

C. Function should return number, not boolean

D. Parentheses are misplaced

Solution

1. Step 1: Analyze the function logic

   The function uses bitwise AND correctly but does not check if n is positive.

2. Step 2: Understand why n > 0 is needed

   Without n > 0, input 0 returns true incorrectly because 0 & -1 = 0.

3. Final Answer:

   Missing check for n > 0 to avoid false positives -> Option A

4. Quick Check:

   Check n > 0 before bitwise test [OK]

Hint: Always check n > 0 before bitwise power of two test [OK]

Common Mistakes:

• Ignoring zero or negative inputs
• Assuming bitwise alone is enough
• Misunderstanding bitwise AND behavior

5. You want to filter an array of numbers to keep only those that are powers of two. Which TypeScript code snippet correctly does this?

const numbers = [0, 1, 2, 3, 4, 5, 8, 16, 18];
const powersOfTwo = numbers.filter(n => ???);
console.log(powersOfTwo);

hard

A. n >= 0 && (n | (n - 1)) === 0

B. n > 0 && (n & (n - 1)) === 0

C. n > 0 && (n & (n + 1)) === 0

D. n !== 0 && (n ^ (n - 1)) === 0

Solution

1. Step 1: Understand the filter condition

   We want to keep numbers that are powers of two, so the condition must check n > 0 and bitwise AND with (n-1) equals zero.

2. Step 2: Evaluate each option

   n > 0 && (n & (n - 1)) === 0 correctly uses the standard power of two check. Options B, C, and D use incorrect bitwise operations or conditions.

3. Final Answer:

   n > 0 && (n & (n - 1)) === 0 -> Option B

4. Quick Check:

   Filter with bitwise AND and n > 0 [OK]

Hint: Filter with n > 0 and n & (n-1) === 0 [OK]

Common Mistakes:

• Using bitwise OR or XOR instead of AND
• Not checking n > 0
• Using (n + 1) instead of (n - 1)