Skip to content
Related Articles

Related Articles

Improve Article
Bitwise AND of sub-array closest to K
  • Last Updated : 12 May, 2021

Given an integer array arr[] of size N and an integer K, the task is to find the sub-array arr[i….j] where i ≤ j and compute the bitwise AND of all sub-array elements say X then print the minimum value of |K – X| among all possible values of X.

Example:  

Input: arr[] = {1, 6}, K = 3 
Output: 2 
 

Sub-arrayBitwise AND|K – X|
{1}12
{6}63
{1, 6}12

Input: arr[] = {4, 7, 10}, K = 2 
Output: 0 
 

Method 1: 
Find the bitwise AND of all possible sub-arrays and keep track of the minimum possible value of |K – X|.



Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
int closetAND(int arr[], int n, int k)
{
    int ans = INT_MAX;
 
    // Check all possible sub-arrays
    for (int i = 0; i < n; i++) {
 
        int X = arr[i];
        for (int j = i; j < n; j++) {
            X &= arr[j];
 
            // Find the overall minimum
            ans = min(ans, abs(k - X));
        }
    }
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 4, 7, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << closetAND(arr, n, k);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.io.*;
 
class GFG {
 
    // Function to return the minimum possible value
    // of |K - X| where X is the bitwise AND of
    // the elements of some sub-array
    static int closetAND(int arr[], int n, int k)
    {
        int ans = Integer.MAX_VALUE;
 
        // Check all possible sub-arrays
        for (int i = 0; i < n; i++) {
 
            int X = arr[i];
            for (int j = i; j < n; j++) {
                X &= arr[j];
 
                // Find the overall minimum
                ans = Math.min(ans, Math.abs(k - X));
            }
        }
        return ans;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 4, 7, 10 };
        int n = arr.length;
        int k = 2;
        System.out.println(closetAND(arr, n, k));
    }
}
 
// This code is contributed by jit_t
Python3



# Python implementation of the approach
 
# Function to return the minimum possible value
# of |K - X| where X is the bitwise AND of
# the elements of some sub-array
def closetAND(arr, n, k):
 
    ans = 10**9
 
    # Check all possible sub-arrays
    for i in range(n):
 
        X = arr[i]
 
        for j in range(i,n):
            X &= arr[j]
 
            # Find the overall minimum
            ans = min(ans, abs(k - X))
         
    return ans
 
# Driver code
arr = [4, 7, 10]
n = len(arr)
k = 2;
print(closetAND(arr, n, k))
 
# This code is contributed by mohit kumar 29
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
    // Function to return the minimum possible value
    // of |K - X| where X is the bitwise AND of
    // the elements of some sub-array
    static int closetAND(int []arr, int n, int k)
    {
        int ans = int.MaxValue;
 
        // Check all possible sub-arrays
        for (int i = 0; i < n; i++)
        {
 
            int X = arr[i];
            for (int j = i; j < n; j++)
            {
                X &= arr[j];
 
                // Find the overall minimum
                ans = Math.Min(ans, Math.Abs(k - X));
            }
        }
        return ans;
    }
 
    // Driver code
    public static void Main()
    {
        int []arr = { 4, 7, 10 };
        int n = arr.Length;
        int k = 2;
         
        Console.WriteLine(closetAND(arr, n, k));
    }
}
 
// This code is contributed by AnkitRai01
PHP



<?php
// PHP implementation of the approach
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
function closetAND(&$arr, $n, $k)
{
    $ans = PHP_INT_MAX;
 
    // Check all possible sub-arrays
    for ($i = 0; $i < $n; $i++)
    {
 
        $X = $arr[$i];
        for ($j = $i; $j < $n; $j++)
        {
            $X &= $arr[$j];
 
            // Find the overall minimum
            $ans = min($ans, abs($k - $X));
        }
    }
    return $ans;
}
 
    // Driver code
    $arr = array( 4, 7, 10 );
    $n = sizeof($arr) / sizeof($arr[0]);
    $k = 2;
    echo closetAND($arr, $n, $k);
 
    return 0;
     
    // This code is contributed by ChitraNayal
?>
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
function closetAND(arr, n, k)
{
    let ans = Number.MAX_VALUE;
 
    // Check all possible sub-arrays
    for(let i = 0; i < n; i++)
    {
        let X = arr[i];
        for(let j = i; j < n; j++)
        {
            X &= arr[j];
 
            // Find the overall minimum
            ans = Math.min(ans, Math.abs(k - X));
        }
    }
    return ans;
}
 
// Driver code
let arr = [4, 7, 10 ];
let n = arr.length;
let k = 2;
 
document.write(closetAND(arr, n, k));
     
// This code is contributed by sravan kumar
 
</script>
Output: 
0
 
Time complexity: O(n2)
Method 2: 
It can be observed that while performing AND operation in the sub-array, the value of X can remain constant or decrease but will never increase. 
Hence, we will start from the first element of a sub-array and will be doing bitwise AND and comparing the |K – X| with the current minimum difference until X ≤ K because after that |K – X| will start increasing. 
Below is the implementation of the above approach:  
C++



// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
int closetAND(int arr[], int n, int k)
{
    int ans = INT_MAX;
 
    // Check all possible sub-arrays
    for (int i = 0; i < n; i++) {
 
        int X = arr[i];
        for (int j = i; j < n; j++) {
            X &= arr[j];
 
            // Find the overall minimum
            ans = min(ans, abs(k - X));
 
            // No need to perform more AND operations
            // as |k - X| will increase
            if (X <= k)
                break;
        }
    }
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 4, 7, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << closetAND(arr, n, k);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
static int closetAND(int arr[], int n, int k)
{
    int ans = Integer.MAX_VALUE;
 
    // Check all possible sub-arrays
    for (int i = 0; i < n; i++)
    {
 
        int X = arr[i];
        for (int j = i; j < n; j++)
        {
            X &= arr[j];
 
            // Find the overall minimum
            ans = Math.min(ans, Math.abs(k - X));
 
            // No need to perform more AND operations
            // as |k - X| will increase
            if (X <= k)
                break;
        }
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 4, 7, 10 };
    int n = arr.length;
    int k = 2;
    System.out.println(closetAND(arr, n, k));
}
}
 
// This code is contributed by Princi Singh
Python3



# Python implementation of the approach
import sys
 
# Function to return the minimum possible value
# of |K - X| where X is the bitwise AND of
# the elements of some sub-array
def closetAND(arr, n, k):
    ans = sys.maxsize;
 
    # Check all possible sub-arrays
    for i in range(n):
 
        X = arr[i];
        for j in range(i,n):
            X &= arr[j];
 
            # Find the overall minimum
            ans = min(ans, abs(k - X));
 
            # No need to perform more AND operations
            # as |k - X| will increase
            if (X <= k):
                break;
    return ans;
 
# Driver code
arr = [4, 7, 10 ];
n = len(arr);
k = 2;
print(closetAND(arr, n, k));
 
# This code is contributed by PrinciRaj1992
C#



// C# implementation of the approach
using System;    
     
class GFG
{
 
// Function to return the minimum possible value
// of |K - X| where X is the bitwise AND of
// the elements of some sub-array
static int closetAND(int []arr, int n, int k)
{
    int ans = int.MaxValue;
 
    // Check all possible sub-arrays
    for (int i = 0; i < n; i++)
    {
 
        int X = arr[i];
        for (int j = i; j < n; j++)
        {
            X &= arr[j];
 
            // Find the overall minimum
            ans = Math.Min(ans, Math.Abs(k - X));
 
            // No need to perform more AND operations
            // as |k - X| will increase
            if (X <= k)
                break;
        }
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 4, 7, 10 };
    int n = arr.Length;
    int k = 2;
    Console.WriteLine(closetAND(arr, n, k));
}
}
 
// This code has been contributed by 29AjayKumar
Javascript



<script>   
    // Javascript implementation of the approach
     
    // Function to return the minimum possible value
    // of |K - X| where X is the bitwise AND of
    // the elements of some sub-array
    function closetAND(arr, n, k)
    {
        let ans = Number.MAX_VALUE;
 
        // Check all possible sub-arrays
        for (let i = 0; i < n; i++)
        {
 
            let X = arr[i];
            for (let j = i; j < n; j++)
            {
                X &= arr[j];
 
                // Find the overall minimum
                ans = Math.min(ans, Math.abs(k - X));
 
                // No need to perform more AND operations
                // as |k - X| will increase
                if (X <= k)
                    break;
            }
        }
        return ans;
    }
     
    let arr = [ 4, 7, 10 ];
    let n = arr.length;
    let k = 2;
    document.write(closetAND(arr, n, k));
 
</script>
Output: 
0
 
Time complexity: O(n2)
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 



My Personal Notes
arrow_drop_up
Previous
Check if the number is even or odd whose digits and base (radix) is given
Next

Find bitwise AND (&) of all possible sub-arrays
Recommended Articles
Page :
Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
07, May 19
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Subarray whose sum is closest to K
19, Aug 18
Subarray whose absolute sum is closest to K
04, Sep 18
Count ways to generate pairs having Bitwise XOR and Bitwise AND equal to X and Y respectively
16, Sep 20
Sum of Bitwise AND of sum of pairs and their Bitwise AND from a given array
23, Feb 21
Count pairs with equal Bitwise AND and Bitwise OR value
29, Oct 20
Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR
12, Oct 20
Non-negative pairs with sum of Bitwise OR and Bitwise AND equal to N
09, Nov 20
Find the triplet from given Bitwise XOR and Bitwise AND values of all its pairs
10, Dec 20
Find subsequences with maximum Bitwise AND and Bitwise OR
12, Nov 18
Minimum possible Bitwise OR of all Bitwise AND of pairs generated from two given arrays
17, Sep 20
Count pairs from an array whose Bitwise OR is greater than Bitwise AND
08, Feb 21
Count pairs with bitwise XOR exceeding bitwise AND from a given array
04, Oct 20
Count pairs with odd Bitwise XOR that can be removed and replaced by their Bitwise OR
25, Mar 21
Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array
18, Mar 21
Leftover element after performing alternate Bitwise OR and Bitwise XOR operations on adjacent pairs
01, Apr 18
Find all possible pairs with given Bitwise OR and Bitwise XOR values
31, May 21
Bitwise OR of Bitwise AND of all subarrays of an array
23, May 21
Bitwise XOR of Bitwise AND of all pairs from two given arrays
06, May 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Split an array into subarrays with maximum Bitwise XOR of their respective Bitwise OR values
14, Jun 21
Queries to check whether bitwise AND of a subarray is even or odd
28, Jan 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ankush_953
@ankush_953
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox