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-array Bitwise AND |K – X| {1} 1 2 {6} 6 3 {1, 6} 1 2 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++ 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 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 |
# 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# 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 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
?> |
<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> |
0
Time complexity: O(n2)
Auxiliary Space: O(1), as no extra space is required.
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++ 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 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 |
# 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# 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 |
<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> |
0
Time complexity: O(n2)
Auxiliary Space: O(1)