Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:

• [4,5,6,7,0,1,2] if it was rotated 4 times.

• [0,1,2,4,5,6,7] if it was rotated 7 times.

Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].

Given the sorted rotated array nums of unique elements, return the minimum element of this array.

You must write an algorithm that runs in O(log n) time.

Example

• Input: nums = [3,4,5,1,2]

• Output: 1

• Explanation: The original array was [1,2,3,4,5] rotated 3 times.

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0;
        int right = nums.size() - 1;
        int mid;

        while (left < right) {
            mid = left + (right - left) / 2;

            if (nums[mid] > nums[right]) {
                left = mid + 1;
            }
            else if (nums[mid] <= nums[right]) {
                right = mid;
            }
        }
        return nums[left];
    }
};

Problem Summary

Given a sorted array of a unique elements that has been rotated, find the minimum element in the array. The algorithm must have a time complexity of O(logn).

Core Idea

The key constraints is the O(logn) time complexity, which stongly suggests a Binary Search approach.

Although the entire array is not sorted, it is composed of two sorted subarrays. The minimum element is the “pivot” point where the rotation occurs (i.e., the first element of the second sorted array.)

The strategy is to use binary search to efficiently find this pivot point. We can determine which of the two sorted subarrays our mid pointer is in by comparing nums[mid] with the element at the right boundary, nums[right] .

Algorithm Logic

1. Initialize two pinters: left = 0 and right = num.size() - 1 .

2. Loop as long as left < right.

3. Calculate middle index using left + (right - left) / 2 . This formula is preferred over (left + right) / 2 to prevent potential integer overflow if the numbers are very large.

4. Compare num[mid] with nums[right] to decide which half of the array to discard:

   • If nums[mid] > nums[right] : This indicates that the mid element is in the larger, left sorted subarray. Therefore, the pivot must be in the right half. We discard the left half by setting left = mid + 1 .

   • If num[mid] ≤ nums[right] : This indicates that the segment from mid to right is sorted. The minimum element must be in the left half, and it’s possible that nums[mid] is the minimum itself. We discard the right half by setting right = mid .

5. The loop terminates when left and right converge to the same index. This index holds the minimum element in the array.

6. Return nums[left]

7. if nums[mid] > nums[right], then make the left flag be mid + 1.

8. else if nums[mid] ≤ nums[right], make the right flag be mid.

Example Walkthrough

Let's trace the algorithm with nums = [3, 4, 5, 1, 2].

• Initial State: left = 0, right = 4

• Iteration 1:

  • mid = 0 + (4 - 0) / 2 = 2

  • nums[mid] is nums[2], which is 5.

  • nums[right] is nums[4], which is 2.

  • Condition nums[mid] > nums[right] (5 > 2) is true.

  • The minimum must be to the right of mid. We update left = mid + 1 = 3.

  • New search space: [3, 4] (elements [1, 2]).

• Iteration 2:

  • left = 3, right = 4.

  • mid = 3 + (4 - 3) / 2 = 3.

  • nums[mid] is nums[3], which is 1.

  • nums[right] is nums[4], which is 2.

  • Condition nums[mid] > nums[right] (1 > 2) is false. We use the else block.

  • The minimum is in the left half (or mid is the minimum). We update right = mid = 3.

  • New search space: [3, 3] (element [1]).

• Termination:

  • Now, left = 3 and right = 3. The while (left < right) condition is false. The loop ends.

• Result:

  • Return nums[left], which is nums[3], giving us the answer 1.

Question

Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

Example 1:

Input: nums = [3,0,1]

Output: 2

Explanation:

n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.

Thought

This question asks us to find the only missing number, so we can use the XOR ^ bit operation. It means that 0 ^ x = x, x ^ x = 0. Take example 1, for instance, the input nums are 3, 0, 1, and the full numbers are 0, 1, 2, 3.

Therefore, we can XOR all of them: 3^0^1^0^1^2^3 = (3^3) ^ (2) ^ (1^1) ^ (0^0) = 2. As we can see, the answer is 2.

Core Idea

The problem gives us two sets of numbers: the complete range [0, n] and the incomplete input nums. Since only one number is missing, XORing all elements from both sets together will cause every number that appears in both sets to cancel itself out, leaving only the missing number.

Method 1: Bit Manipulation (XOR)

Key Properties

• x ^ x = 0

• x ^ 0 = x

Logic Walkthrough

• Example: nums = [3, 0, 1]

• n: nums.size() is 3

• Complete Range: {0, 1, 2, 3}

• Input nums: {3, 0, 1}

• Combined XOR: (0 ^ 1 ^ 2 ^ 3) ^ (3 ^ 0 ^ 1)

• Rearrange & Cancel: (3 ^ 3) ^ (2) ^ (1 ^ 1) ^ (0 ^ 0) = 2

• The result is the missing number, 2.

Complexity

• Time: O(n)

• Space: O(1)

Given an integer n, return an array ans of length n + 1 where ans[i] is the number of set bits in the binary representation of i.

• Example: n = 5 → Output: [0, 1, 1, 2, 1, 2]

• Constraints: 0 <= n <= 10^5

Solution 1: Brute Force

This is the most intuitive approach. We iterate through each number from 0 to n, and for each number, we manually count its set bits.

The Algorithm for counting bits of a single number i:

1. Initialize a counter for the current number, e.g., count = 0.

2. Use a temporary variable temp_num = i to avoid modifying the main loop’s counter.

3. Use a while loop that continues as long as temp_num is not 0.

4. Check the LSB: Use the bitwise AND operator(&) to check if the least significant bit is a 1.

5. Shift to the Next Bit: Use the right shift operator (>>) to discard the LSB.

6. The loop terminates when the number becomes 0.

C++ implementation:

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ans(n + 1);
        for (int i = 0; i <= n; ++i) {
            // Logic to count bits for each number 'i'
            int count = 0;
            int temp_num = i;
            while (temp_num != 0) {
                if ((temp_num & 1) == 1) { // or simply: if (temp_num & 1)
                    count++;
                }
                temp_num = temp_num >> 1;
            }
            ans[i] = count;
        }
        return ans;
    }
};

Complexity Analysis:

• Time Complexity: O(n * log(n))

  • The outer for loop runs n + 1 times.

  • The inner while loop runs for a number of times equal to the number of bits in i, which is approximately log(i).

• Space Complexity: O(n)

  • We need O(n) space for the ans array that we return.

The goal is to write a function that takes an unsigned integer and returns the number of ‘1’ bits it has in its binary representation. This value is also known as Hamming weight. This is the classic bit manipulation problem.

Solution 1: Bit-by-Bit Check

Core Idea:

This approach checks each bit of the number individually.

1. Check LSB: Use the bitwise AND operator (n & 1) to check if the Least Significant Bit (LSB) is a 1 . If it is, increment a counter. For example, 5 (101) & 1 (001) results in 1.

2. Right Shift: Shift the number one bit to the right (n >> 1) to discard the LSB and examine the next bit in the following iteration.

3. Repeat: Continue these steps until the number becomes 0.

Time Complexity: O(1), as the loop runs a fixed number of times (32 for a 32-bit integer).

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;
        while (n != 0) {
            // check if LSB == 1 
            if (n & 1) {
                count++;
            }
            // right shift
            n >>= 1;
        }
        return count;
    }
};

Solution 2: Clear Rightmost Set Bit (Optimized)

Core Idea:

This clever approach uses a trick to eliminate one set bit at a time.

1. Key Operation: This operation n & (n - 1) clears the rightmost set bit (’1’) of n. For example, if n is 12 (1100), n-1 is 11 (1011). n & (n - 1) results in 8 (1000), effectively removing the rightmost ‘1’.

2. Count and Repeat: We apply this operation repeatedly and increment a counter each time until n becomes 0. The total count is the number of set bits.

Time Complexity: O(m), where m is the number of set bits. This is highly efficient for numbers with few ‘1’s (sparse numbers).

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;
        while (n != 0) {
            n = n & (n - 1);
            count++;
        }
        return count;
    }
};