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++
#include <bits/stdc++.h>
using namespace std;
int closetAND(int arr[], int n, int k)
{
int ans = INT_MAX;
for (int i = 0; i < n; i++) {
int X = arr[i];
for (int j = i; j < n; j++) {
X &= arr[j];
ans = min(ans, abs(k - X));
}
}
return ans;
}
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
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.io.*;
class GFG {
static int closetAND(int arr[], int n, int k)
{
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int X = arr[i];
for (int j = i; j < n; j++) {
X &= arr[j];
ans = Math.min(ans, Math.abs(k - X));
}
}
return ans;
}
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));
}
}
|
Python3
def closetAND(arr, n, k):
ans = 10**9
for i in range(n):
X = arr[i]
for j in range(i,n):
X &= arr[j]
ans = min(ans, abs(k - X))
return ans
arr = [4, 7, 10]
n = len(arr)
k = 2;
print(closetAND(arr, n, k))
|
C#
using System;
class GFG
{
static int closetAND(int []arr, int n, int k)
{
int ans = int.MaxValue;
for (int i = 0; i < n; i++)
{
int X = arr[i];
for (int j = i; j < n; j++)
{
X &= arr[j];
ans = Math.Min(ans, Math.Abs(k - X));
}
}
return ans;
}
public static void Main()
{
int []arr = { 4, 7, 10 };
int n = arr.Length;
int k = 2;
Console.WriteLine(closetAND(arr, n, k));
}
}
|
PHP
<?php
function closetAND(&$arr, $n, $k)
{
$ans = PHP_INT_MAX;
for ($i = 0; $i < $n; $i++)
{
$X = $arr[$i];
for ($j = $i; $j < $n; $j++)
{
$X &= $arr[$j];
$ans = min($ans, abs($k - $X));
}
}
return $ans;
}
$arr = array( 4, 7, 10 );
$n = sizeof($arr) / sizeof($arr[0]);
$k = 2;
echo closetAND($arr, $n, $k);
return 0;
?>
|
Javascript
<script>
function closetAND(arr, n, k)
{
let ans = Number.MAX_VALUE;
for(let i = 0; i < n; i++)
{
let X = arr[i];
for(let j = i; j < n; j++)
{
X &= arr[j];
ans = Math.min(ans, Math.abs(k - X));
}
}
return ans;
}
let arr = [4, 7, 10 ];
let n = arr.length;
let k = 2;
document.write(closetAND(arr, n, k));
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
int closetAND(int arr[], int n, int k)
{
int ans = INT_MAX;
for (int i = 0; i < n; i++) {
int X = arr[i];
for (int j = i; j < n; j++) {
X &= arr[j];
ans = min(ans, abs(k - X));
if (X <= k)
break;
}
}
return ans;
}
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
class GFG
{
static int closetAND(int arr[], int n, int k)
{
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++)
{
int X = arr[i];
for (int j = i; j < n; j++)
{
X &= arr[j];
ans = Math.min(ans, Math.abs(k - X));
if (X <= k)
break;
}
}
return ans;
}
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));
}
}
|
Python3
import sys
def closetAND(arr, n, k):
ans = sys.maxsize;
for i in range(n):
X = arr[i];
for j in range(i,n):
X &= arr[j];
ans = min(ans, abs(k - X));
if (X <= k):
break;
return ans;
arr = [4, 7, 10 ];
n = len(arr);
k = 2;
print(closetAND(arr, n, k));
|
C#
using System;
class GFG
{
static int closetAND(int []arr, int n, int k)
{
int ans = int.MaxValue;
for (int i = 0; i < n; i++)
{
int X = arr[i];
for (int j = i; j < n; j++)
{
X &= arr[j];
ans = Math.Min(ans, Math.Abs(k - X));
if (X <= k)
break;
}
}
return ans;
}
public static void Main(String[] args)
{
int []arr = { 4, 7, 10 };
int n = arr.Length;
int k = 2;
Console.WriteLine(closetAND(arr, n, k));
}
}
|
Javascript
<script>
function closetAND(arr, n, k)
{
let ans = Number.MAX_VALUE;
for (let i = 0; i < n; i++)
{
let X = arr[i];
for (let j = i; j < n; j++)
{
X &= arr[j];
ans = Math.min(ans, Math.abs(k - X));
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>
|
Time complexity: O(n2)
Auxiliary Space: O(1)