Find a Value of a Mysterious Function Closest to Target

Find a Value of a Mysterious Function Closest to Target - Problem

Winston discovered a mysterious function func(arr, l, r) that performs a bitwise AND operation on all elements in the subarray from index l to index r (inclusive). The function returns arr[l] & arr[l+1] & ... & arr[r].

Given an integer array arr and a target value target, your mission is to find indices l and r such that the absolute difference |func(arr, l, r) - target| is minimized.

Your goal: Return the minimum possible value of |func(arr, l, r) - target|.

Note: Both l and r must satisfy 0 <= l, r < arr.length.

Example: If arr = [9,12,3,7,15] and target = 5, we need to check all possible subarrays and find which one gives us a bitwise AND result closest to 5.

Input & Output

example_1.py — Basic Case

$ Input: arr = [9,12,3,7,15], target = 5

› Output: 2

💡 Note: We need to find the subarray whose bitwise AND is closest to 5. Checking key subarrays: [3] gives AND=3, difference=2. [7] gives AND=7, difference=2. [3,7] gives AND=3, difference=2. The minimum difference is 2.

example_2.py — Single Element

$ Input: arr = [1000000], target = 1

› Output: 999999

💡 Note: With only one element, the only possible subarray is [1000000] itself. The bitwise AND is 1000000, so the difference with target 1 is |1000000 - 1| = 999999.

example_3.py — Exact Match

$ Input: arr = [1,2,4,8,16], target = 4

› Output: 0

💡 Note: The subarray [4] has bitwise AND equal to 4, which exactly matches our target. The difference is |4 - 4| = 0.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁶
1 ≤ target ≤ 10⁶
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

AND Monotonicity

Each additional element can only turn bits OFF, creating limited unique values

Set Tracking

Track all possible AND values efficiently using a set data structure

Optimal Search

Find minimum difference by checking each unique value against target

Key Takeaway

🎯 Key Insight: Bitwise AND's monotonic decreasing property limits unique values to at most log(max_value), enabling efficient optimization

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a set-based technique that leverages the monotonic property of bitwise AND operations. Since AND can only turn bits off (never on), each position generates at most log(max_value) unique values. This reduces time complexity from O(n³) to O(n × log(max_val)).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Set + Binary Search	O(n × log(max_val))	O(log(max_val))	Use set to store unique AND values and binary search for closest to target
Brute Force (All Subarrays)	O(n³)	O(1)	Check every possible subarray and compute bitwise AND for each

Optimized with Set + Binary Search — Algorithm Steps

Initialize empty set to store possible AND values
For each element in array, create new set
Add current element to new set
For each value in previous set, add (value & current_element)
Update set and track minimum difference with target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty set of possible values

Process Element

Add current element and AND it with all previous values

Update Set

Store unique values and track minimum difference

Code -

solution.c — C

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

#define MAX_UNIQUE_VALUES 64

int closestToTarget(int* arr, int arrSize, int target) {
    int prevSet[MAX_UNIQUE_VALUES];
    int prevCount = 0;
    int minDiff = INT_MAX;
    
    for (int i = 0; i < arrSize; i++) {
        int currSet[MAX_UNIQUE_VALUES];
        int currCount = 1;
        currSet[0] = arr[i];
        
        // Add current number alone
        int diff = abs(arr[i] - target);
        if (diff < minDiff) minDiff = diff;
        
        // AND current number with all previous values
        for (int j = 0; j < prevCount; j++) {
            int andResult = prevSet[j] & arr[i];
            
            // Check if already exists
            int exists = 0;
            for (int k = 0; k < currCount; k++) {
                if (currSet[k] == andResult) {
                    exists = 1;
                    break;
                }
            }
            
            if (!exists) {
                currSet[currCount++] = andResult;
                diff = abs(andResult - target);
                if (diff < minDiff) minDiff = diff;
            }
        }
        
        // Copy current set to previous set
        for (int j = 0; j < currCount; j++) {
            prevSet[j] = currSet[j];
        }
        prevCount = currCount;
        
        if (minDiff == 0) break;
    }
    
    return minDiff;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_val))

For each element, we process at most log(max_val) unique values in the set

⚡ Linearithmic

Space Complexity

O(log(max_val))

Set can contain at most log(max_val) unique values due to AND properties

✓ Linear Space

31.2K Views

Medium Frequency

~25 min Avg. Time

1.3K 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

Optimized with Set + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler