Minimum Array End - Practice Coding Problems

Minimum Array End - Problem

Bit Manipulation Medium

You're tasked with constructing a strictly increasing array of positive integers with a special bitwise property. Given two integers n and x, you need to build an array nums of size n where:

Each element is strictly greater than the previous one (nums[i+1] > nums[i])
The bitwise AND of all elements equals x

Your goal is to find the minimum possible value of the last element nums[n-1]. This is a fascinating bit manipulation challenge that requires understanding how AND operations preserve certain bits across multiple numbers.

Example: If n = 3 and x = 4, you need 3 numbers where a & b & c = 4. Since 4 = 100₂, all numbers must have bit 2 set. The optimal array might be [4, 5, 6] giving us the minimum last element of 6.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, x = 4

› Output: 6

💡 Note: We need 3 numbers where their AND equals 4 (binary: 100). Since bit 2 must be set in all numbers, the minimum array could be [4, 5, 6]. The bitwise AND is 4 & 5 & 6 = 4, and the last element is 6.

example_2.py — Single Element

$ Input: n = 1, x = 5

› Output: 5

💡 Note: When n=1, we only need one number, and it must be at least x to satisfy the AND condition. So the array is [5] and the last element is 5.

example_3.py — Larger Sequence

$ Input: n = 6, x = 5

› Output: 13

💡 Note: We need 6 numbers where AND equals 5 (binary: 101). The optimal array is [5, 7, 9, 11, 13]. All preserve bits 0 and 2 from x=5, giving AND result of 5.

Constraints

1 ≤ n ≤ 10⁸
1 ≤ x ≤ 10⁸
All array elements must be positive integers
The array must be strictly increasing

Visualization

Tap to expand

Key Insight: We only need to calculate the last element directly!Time: O(log x) | Space: O(1) - No need to build the entire array

Understanding the Visualization

Master Lock Pattern

The master lock (x) shows which switches must be ON in every lock

Available Switches

Switches that are OFF in the master can be freely toggled

Counting Pattern

Use these free switches to create an increasing binary count

Minimum Result

This gives us the smallest possible nth lock combination

Key Takeaway

🎯 Key Insight: By understanding that we can only modify '0' bit positions in x and treating them as binary counter slots, we can directly compute the minimum array end in O(log x) time without constructing the entire array.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses bit manipulation to achieve O(log x) time complexity. The key insight is that all numbers must preserve the '1' bits from x, and we can only modify the '0' bit positions. By treating these positions as slots for a binary counter representing (n-1), we can directly compute the minimum possible last element without constructing the entire array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(2^(n*log(max_value)))	O(n)	Generate all possible arrays and find the minimum valid last element
Bit Manipulation (Optimal)	O(log x)	O(1)	Use bit manipulation to construct the minimum array end efficiently

Brute Force Simulation — Algorithm Steps

Start with first number as x (minimum possible)
For each position, try all numbers greater than the previous
Check if current partial array's AND still equals x
Continue until we have n numbers
Return the minimum last element found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with base

Begin with x as first number (minimum possible)

Branch out

Try all valid next numbers greater than current

Validate AND

Check if partial array still maintains AND = x

Backtrack

Remove invalid paths and continue searching

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

long long backtrack(long long* arr, int size, int pos, int n, int x) {
    if (pos == n) {
        if (size == 0) return LLONG_MAX;
        long long result = arr[0];
        for (int i = 1; i < size; i++) {
            result &= arr[i];
        }
        return result == x ? arr[size - 1] : LLONG_MAX;
    }
    
    long long minResult = LLONG_MAX;
    long long start = size == 0 ? x : arr[size - 1] + 1;
    
    for (long long num = start; num < start + 100; num++) {
        if ((num & x) == x) {
            arr[size] = num;
            long long result = backtrack(arr, size + 1, pos + 1, n, x);
            if (result < minResult) {
                minResult = result;
            }
            
            if (minResult != LLONG_MAX) break;
        }
    }
    
    return minResult;
}

long long minimumArrayEnd(int n, int x) {
    long long* arr = (long long*)malloc(n * sizeof(long long));
    long long result = backtrack(arr, 0, 0, n, x);
    free(arr);
    return result;
}

int main() {
    int n, x;
    scanf("%d %d", &n, &x);
    printf("%lld\n", minimumArrayEnd(n, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n*log(max_value)))

For each position, we might try exponentially many numbers, leading to exponential overall complexity

⚡ Linearithmic

Space Complexity

O(n)

Only need to store the current array being tested

⚡ Linearithmic Space

38.0K Views

Medium Frequency

~25 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler