Find maximum product of Bitwise AND and Bitwise OR of K-size subarray
Last Updated :
21 Mar, 2023
Given an array arr[] containing N integers and an integer K, the task is to find the maximum value of the product of Bitwise AND and Bitwise OR of all elements of a K-sized subarray.
Example:
Input: arr[] = {1, 2, 3, 4}, K = 2
Output: 6
Explanation: Bitwise AND and Bitwise XOR of all K-sized subarrays is {(0, 3), (2, 3), (0, 7)} respectively. Therefore the maximum possible value of their product is 2 * 3 = 6 which is the required answer.
Input: arr[] = {6, 7, 7, 10, 8, 2}, K = 3
Output: 42
Approach: The given problem can be solved using the sliding window technique. The idea is to maintain the value of bitwise AND and bitwise OR for the K-sized subarray windows, which can be done by maintaining an array storing the count of each bit over all the elements of the current window. If the count of ith bit is K, that bit must be included in the bitwise AND and if the count of the bit is greater than 1, it must be included in the bitwise OR. Store the maximum value of their product over all the windows in a variable ans which is the required answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int build_or( int bit[])
{
int ans = 0;
for ( int i = 0; i < 32; i++)
if (bit[i])
ans += (1 << i);
return ans;
}
int build_and( int bit[], int k)
{
int ans = 0;
for ( int i = 0; i < 32; i++)
if (bit[i] == k)
ans += (1 << i);
return ans;
}
int maximizeAndOr( int arr[], int N, int K)
{
int bit[32] = { 0 };
for ( int i = 0; i < K; i++) {
for ( int j = 0; j < 32; j++) {
if (arr[i] & (1 << j))
bit[j]++;
}
}
int ans = build_and(bit, K) * build_or(bit);
for ( int i = K; i < N; i++) {
for ( int j = 0; j < 32; j++) {
if (arr[i - K] & (1 << j))
bit[j]--;
}
for ( int j = 0; j < 32; j++) {
if (arr[i] & (1 << j))
bit[j]++;
}
ans = max(ans, build_and(bit, K)
* build_or(bit));
}
return ans;
}
int main()
{
int arr[] = { 6, 7, 7, 10, 8, 2 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 3;
cout << maximizeAndOr(arr, N, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int build_or( int [] bit)
{
int ans = 0 ;
for ( int i = 0 ; i < 32 ; i++)
if (bit[i] > 0 )
ans += ( 1 << i);
return ans;
}
static int build_and( int [] bit, int k)
{
int ans = 0 ;
for ( int i = 0 ; i < 32 ; i++)
if (bit[i] == k)
ans += ( 1 << i);
return ans;
}
static int maximizeAndOr( int [] arr, int N, int K)
{
int [] bit = new int [ 32 ];
for ( int i = 0 ; i < K; i++)
{
for ( int j = 0 ; j < 32 ; j++)
{
if ((arr[i] & ( 1 << j)) > 0 )
bit[j]++;
}
}
int ans = build_and(bit, K) * build_or(bit);
for ( int i = K; i < N; i++)
{
for ( int j = 0 ; j < 32 ; j++)
{
if ((arr[i - K] & ( 1 << j)) > 0 )
bit[j]--;
}
for ( int j = 0 ; j < 32 ; j++)
{
if ((arr[i] & ( 1 << j)) > 0 )
bit[j]++;
}
ans = Math.max(ans, build_and(bit, K) *
build_or(bit));
}
return ans;
}
public static void main(String args[])
{
int [] arr = { 6 , 7 , 7 , 10 , 8 , 2 };
int N = arr.length;
int K = 3 ;
System.out.println(maximizeAndOr(arr, N, K));
}
}
|
Python3
def build_or(bit):
ans = 0
for i in range ( 0 , 32 ):
if (bit[i]):
ans + = ( 1 << i)
return ans
def build_and(bit, k):
ans = 0
for i in range ( 0 , 32 ):
if (bit[i] = = k):
ans + = ( 1 << i)
return ans
def maximizeAndOr(arr, N, K):
bit = [ 0 for _ in range ( 32 )]
for i in range ( 0 , K):
for j in range ( 0 , 32 ):
if (arr[i] & ( 1 << j)):
bit[j] + = 1
ans = build_and(bit, K) * build_or(bit)
for i in range (K, N):
for j in range ( 0 , 32 ):
if (arr[i - K] & ( 1 << j)):
bit[j] - = 1
for j in range ( 0 , 32 ):
if (arr[i] & ( 1 << j)):
bit[j] + = 1
ans = max (ans, build_and(bit, K) *
build_or(bit))
return ans
if __name__ = = "__main__" :
arr = [ 6 , 7 , 7 , 10 , 8 , 2 ]
N = len (arr)
K = 3
print (maximizeAndOr(arr, N, K))
|
C#
using System;
class GFG
{
static int build_or( int [] bit)
{
int ans = 0;
for ( int i = 0; i < 32; i++)
if (bit[i] > 0)
ans += (1 << i);
return ans;
}
static int build_and( int [] bit, int k)
{
int ans = 0;
for ( int i = 0; i < 32; i++)
if (bit[i] == k)
ans += (1 << i);
return ans;
}
static int maximizeAndOr( int [] arr, int N, int K)
{
int [] bit = new int [32];
for ( int i = 0; i < K; i++) {
for ( int j = 0; j < 32; j++) {
if ((arr[i] & (1 << j)) > 0)
bit[j]++;
}
}
int ans = build_and(bit, K) * build_or(bit);
for ( int i = K; i < N; i++) {
for ( int j = 0; j < 32; j++) {
if ((arr[i - K] & (1 << j)) > 0)
bit[j]--;
}
for ( int j = 0; j < 32; j++) {
if ((arr[i] & (1 << j)) > 0)
bit[j]++;
}
ans = Math.Max(ans, build_and(bit, K)
* build_or(bit));
}
return ans;
}
public static void Main()
{
int [] arr = { 6, 7, 7, 10, 8, 2 };
int N = arr.Length;
int K = 3;
Console.WriteLine(maximizeAndOr(arr, N, K));
}
}
|
Javascript
<script>
function build_or(bit)
{
let ans = 0;
for (let i = 0; i < 32; i++)
if (bit[i])
ans += (1 << i);
return ans;
}
function build_and(bit, k)
{
let ans = 0;
for (let i = 0; i < 32; i++)
if (bit[i] == k)
ans += (1 << i);
return ans;
}
function maximizeAndOr(arr, N, K)
{
let bit = new Array(32).fill(0);
for (let i = 0; i < K; i++)
{
for (let j = 0; j < 32; j++)
{
if (arr[i] & (1 << j))
bit[j]++;
}
}
let ans = build_and(bit, K) * build_or(bit);
for (let i = K; i < N; i++)
{
for (let j = 0; j < 32; j++)
{
if (arr[i - K] & (1 << j))
bit[j]--;
}
for (let j = 0; j < 32; j++)
{
if (arr[i] & (1 << j))
bit[j]++;
}
ans = Math.max(ans, build_and(bit, K) *
build_or(bit));
}
return ans;
}
let arr = [ 6, 7, 7, 10, 8, 2 ];
let N = arr.length;
let K = 3;
document.write(maximizeAndOr(arr, N, K));
</script>
|
Time Complexity: O(N*K) where N is the size of the input array and K is the size of the subarrays being considered. This is because there are two nested loops in the maximizeAndOr function, each of which iterates through a window of size K.
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...