Skip to content
QuizMaker logoQuizMaker
Activity
DSA Course: Interview Patterns and Problem Solving
Module 14: Bit Manipulation
Best Time to Buy and Sell Stock: Greedy Pattern
Maximum Subarray: Kadane Pattern
Move Zeroes: Two pointers Pattern
Contains Duplicate: Set Pattern
Valid Anagram: Frequency map Pattern
Longest Substring Without Repeating Characters: Sliding window Pattern
Valid Palindrome: Two pointers Pattern
Longest Palindromic Substring: Expand around center Pattern
Group Anagrams: Hash key Pattern
Binary Search: Classic search Pattern
Search Insert Position: Lower bound Pattern
First Bad Version: Predicate search Pattern
Search in Rotated Sorted Array: Rotated search Pattern
Find Minimum in Rotated Sorted Array: Rotated minimum Pattern
Valid Parentheses: Stack matching Pattern
Min Stack: Auxiliary stack Pattern
Daily Temperatures: Monotonic stack Pattern
Next Greater Element I: Monotonic stack Pattern
Evaluate Reverse Polish Notation: Stack evaluation Pattern
Reverse Linked List: Pointer reversal Pattern
Merge Two Sorted Lists: Dummy node Pattern
Linked List Cycle: Fast and slow pointers Pattern
Middle of the Linked List: Fast and slow pointers Pattern
Remove Nth Node From End: Two pointers Pattern
Binary Tree Traversals: DFS recursion Pattern
Maximum Depth of Binary Tree: Height recursion Pattern
Binary Tree Level Order Traversal: BFS queue Pattern
Validate Binary Search Tree: Range bounds Pattern
Lowest Common Ancestor: Recursive split Pattern
Connected Components: Adjacency DFS Pattern
Number of Islands: Grid DFS Pattern
Flood Fill: Boundary DFS Pattern
Clone Graph: Hash Map DFS Pattern
Course Schedule: Topological Sort Pattern
Union Find Components: Disjoint Set Pattern
Shortest Path in Unweighted Graph: BFS Distance Pattern
Climbing Stairs: Fibonacci DP Pattern
House Robber: Pick or Skip DP Pattern
Coin Change: Minimum Coins DP Pattern
Longest Increasing Subsequence: Binary Search DP Pattern
Longest Common Subsequence: 2D DP Pattern
0/1 Knapsack: Capacity DP Pattern
Longest Consecutive Sequence: Hash Set Pattern
Subarray Sum Equals K: Prefix Sum Hashmap Pattern
First Unique Character: Frequency Map Pattern
Find Duplicates: Frequency Map Pattern
Ransom Note: Character Availability Pattern
Sort Colors: Dutch National Flag Pattern
Next Permutation: Pivot and Suffix Reversal Pattern
Merge Intervals: Sort and Sweep Pattern
Find First and Last Position: Boundary Binary Search Pattern
Search a 2D Matrix: Flattened Binary Search Pattern
Subsets: Pick or Skip Recursion Pattern
Generate Parentheses: Valid State Backtracking Pattern
Combination Sum: Reuse Choice Backtracking Pattern
N-Queens: Constraint Backtracking Pattern
Word Search: Grid Backtracking Pattern
Kth Largest Element: Size-K Min-Heap Pattern
Top K Frequent Elements: Frequency Heap Pattern
Merge K Sorted Lists: Min-Heap Multiway Merge Pattern
Median Finder: Two Heaps Pattern
Task Scheduler: Greedy Max-Heap Pattern
Jump Game: Farthest Reach Greedy Pattern
Gas Station: Greedy Reset Pattern
Non-overlapping Intervals: Earliest End Greedy Pattern
Minimum Arrows to Burst Balloons: Interval End Greedy Pattern
Partition Labels: Last Occurrence Greedy Pattern
Single Number: XOR Cancellation Pattern
Power of Two: n and n-1 Pattern
Number of 1 Bits: Brian Kernighan Pattern
Single Number III: Rightmost Set Bit Pattern
XOR From 1 to N: Modulo Cycle Pattern
Prime Check: Square Root Trial Division Pattern
Sieve of Eratosthenes: Prime Marking Pattern
GCD: Euclidean Remainder Pattern
Binary Exponentiation: Fast Power Pattern
Modular Inverse: Extended Euclid Pattern
Implement Trie: Prefix Tree Pattern
Longest Common Prefix: Single Branch Trie Pattern
LRU Cache: Hash Map Plus Recency List Pattern
Segment Tree: Range Sum Query Pattern
Fenwick Tree: Binary Indexed Prefix Sum Pattern
CONTENTS

Power of Two: n and n-1 Pattern

Check whether a positive number has exactly one set bit.

DSA Course: Interview Patterns and Problem Solving
Module 14: Bit Manipulation
dsa
bit-manipulation
+1
May 29, 2026
23
A

Learning Outcome

After this lesson, you should be able to recognize the one-set-bit property of powers of two.

Problem Statement

Given an integer n, return true if it is a power of two.

InputOutputWhy
n = 16true16 is binary 10000, which has exactly one set bit.

Brute Force Approach

Repeatedly divide by 2 until the number becomes odd. This works but is longer and easy to mishandle for zero or negative values.

Optimized Approach

A positive power of two has one set bit. n & (n

    1. clears the lowest set bit, so the result is zero only when there was one set bit.

Exact Pseudocode

if n <= 0:
  return false
return (n & (n - 1)) == 0

Reference Code

class Solution:
    def isPowerOfTwo(self, n):
        return n > 0 and (n & (n - 1)) == 0

Sample Dry Run

StepStateResult
n = 16binary 10000one set bit

n

  • 1 = 15
binary 01111lower bits become 1

n & (n

10000 & 01111 = 00000true
n = 1810010 & 10001 is not zerofalse

Complexity

MeasureValueReason
TimeO(1)The check uses constant-time bit operations.
SpaceO(1)No extra data structure is used.

Edge Cases

  • Zero is not a power of two.
  • Negative numbers are not powers of two.
  • Do the n > 0 check before trusting the bit expression.

Interview Checklist

  • Remember the one-set-bit property.
  • Use n & (n

      1. to remove the lowest set bit.
  • Guard against n <= 0.

FAQs

Why does zero need a separate check?

0 & -1 is 0, so without n > 0, zero would incorrectly pass.

What does n & (n

    1. do?

It clears the lowest set bit of n.

What is the core pattern?

Single-set-bit check.

Share this article

Share on TwitterShare on LinkedInShare on FacebookShare on WhatsAppShare on Email

Test your knowledge

Take a quick quiz based on this chapter.

mediumDSA Course
Power of Two - n and n-1 Pattern Practice Quiz
5 questions8 min

0 comments

Please login to comment.
No comments yet.
Lesson 2 of 5 in Module 14: Bit Manipulation
Previous in Module 14: Bit Manipulation
Single Number: XOR Cancellation Pattern
Next in Module 14: Bit Manipulation
Number of 1 Bits: Brian Kernighan Pattern
Back to DSA Course: Interview Patterns and Problem Solving
Back to moduleCategories