Minimum Array End - Practice Coding Problems

Minimum Array End - Problem

Bit Manipulation Medium

You are given two integers n and x. You have to construct an array of positive integers nums of size n where:

For every 0 <= i < n - 1, nums[i + 1] is greater than nums[i]
The result of the bitwise AND operation between all elements of nums is x

Return the minimum possible value of nums[n - 1].

Input & Output

Example 1 — Basic Case

$ Input: n = 3, x = 4

› Output: 6

💡 Note: Array [4,5,6] has AND = 4 & 5 & 6 = 4, strictly increasing, minimum last element is 6

Example 2 — Single Element

$ Input: n = 1, x = 2

› Output: 2

💡 Note: Array [2] has AND = 2, only one element so result is 2

Example 3 — Larger Case

$ Input: n = 4, x = 1

› Output: 7

💡 Note: Array [1,3,5,7] has AND = 1 & 3 & 5 & 7 = 1, strictly increasing, minimum last element is 7

Constraints

1 ≤ n ≤ 10⁸
1 ≤ x ≤ 10⁸

Visualization

Tap to expand

Understanding the Visualization

Input

n=3 numbers needed, AND result must be x=4

Constraint

Array must be strictly increasing and AND = x

Output

Minimum possible last element

Key Takeaway

🎯 Key Insight: Use x as a bit template and fill zero positions with binary patterns to create minimal increasing sequence

Asked in

M Microsoft 25 G Google 20

The key insight is that since AND of all elements must equal x, every number must have all bits of x set. We use x as a template and fill zero bit positions with the binary representation of (n-1) to construct the minimum possible last element. Best approach is bit manipulation. Time: O(log n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(2^(n×log(x)))	O(n)	Try all possible arrays starting from x and check constraints
Optimal Bit Manipulation	O(log n)	O(1)	Use x as template and fill zero bits with binary counting pattern

Brute Force Simulation — Algorithm Steps

Start with first element as x
Try all combinations for remaining n-1 elements
Check if array is increasing and AND equals x

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with x

Begin array with x as first element

Try combinations

Test all possible next elements > previous

Check constraints

Verify AND equals x and array is increasing

Code -

solution.c — C

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

long long backtrack(long long* arr, int size, int n, int x) {
    if (size == n) {
        long long andResult = arr[0];
        for (int i = 1; i < size; i++) {
            andResult &= arr[i];
        }
        if (andResult == x) {
            return arr[size - 1];
        }
        return LLONG_MAX;
    }
    
    long long last = arr[size - 1];
    long long minResult = LLONG_MAX;
    
    for (long long candidate = last + 1; candidate <= last + 100; candidate++) {
        arr[size] = candidate;
        long long result = backtrack(arr, size + 1, n, x);
        if (result < minResult) {
            minResult = result;
        }
        
        if (result != LLONG_MAX) {
            return result;
        }
    }
    
    return minResult;
}

long long solution(int n, int x) {
    if (n == 1) return x;
    
    long long arr[100];
    arr[0] = x;
    long long result = backtrack(arr, 1, n, x);
    return result != LLONG_MAX ? result : x + n - 1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×log(x)))

For each position, we try exponentially many values

⚡ Linearithmic

Space Complexity

O(n)

Array to store current candidate solution

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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