# Count of N-size maximum sum Arrays with elements in range [0, 2^K – 1] and Bitwise AND equal to 0

• Last Updated : 16 Jul, 2021

Given two positive integers N and K, the task is to find the number of arrays of size N such that each array element lies over the range [0, 2K – 1] with the maximum sum of array element having Bitwise AND of all array elements 0.

Examples:

Input: N = 2 K = 2
Output: 4
Explanation:
The possible arrays with maximum sum having the Bitwise AND of all array element as 0 {0, 3}, {3, 0}, {1, 2}, {2, 1}. The count of such array is 4.

Input: N = 5 K = 6
Output: 15625

Approach: The given problem can be solved by observing the fact that as the Bitwise AND of the generated array should be 0, then for each i in the range [0, K – 1] there should be at least 1 element with an ith bit equal to 0 in its binary representation. Therefore, to maximize the sum of the array, it is optimal to have exactly 1 element with the ith bit unset.

Hence, for each of the K bits, there are NC1 ways to make it unset in 1 array element. Therefore, the resultant count of an array having the maximum sum is given by NK.

Below is the implementation of the approach :

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the value of X to` `// the power Y` `int` `power(``int` `x, unsigned ``int` `y)` `{` `    ``// Stores the value of X^Y` `    ``int` `res = 1;`   `    ``while` `(y > 0) {`   `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `(y & 1)` `            ``res = res * x;`   `        ``// Update the value of y and x` `        ``y = y >> 1;` `        ``x = x * x;` `    ``}`   `    ``// Return the result` `    ``return` `res;` `}`   `// Function to count number of arrays` `// having element over the range` `// [0, 2^K - 1] with Bitwise AND value` `// 0 having maximum possible sum` `void` `countArrays(``int` `N, ``int` `K)` `{` `    ``// Print the value of N^K` `    ``cout << ``int``(power(N, K));` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5, K = 6;` `    ``countArrays(N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `public` `class` `GFG` `{`   `// Function to find the value of X to` `// the power Y` `static` `int` `power(``int` `x, ``int` `y)` `{` `  `  `    ``// Stores the value of X^Y` `    ``int` `res = ``1``;`   `    ``while` `(y > ``0``) {`   `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `(y%``2``!=``0``)` `            ``res = res * x;`   `        ``// Update the value of y and x` `        ``y = y >> ``1``;` `        ``x = x * x;` `    ``}`   `    ``// Return the result` `    ``return` `res;` `}`   `// Function to count number of arrays` `// having element over the range` `// [0, 2^K - 1] with Bitwise AND value` `// 0 having maximum possible sum` `static` `void` `countArrays(``int` `N, ``int` `K)` `{` `  `  `    ``// Print the value of N^K` `   ``System.out.println((``int``)(power(N, K)));` `}`     `// Driver Code` `public` `static` `void` `main(String args[]) ` `{` `    ``int` `N = ``5``, K = ``6``;` `    ``countArrays(N, K);` `}` `}`   `// This code is contributed by SoumikMondal`

## Python3

 `# Python Program for the above approach`   `# Function to find the value of X to` `# the power Y` `def` `power(x, y):` `    ``# Stores the value of X^Y` `    ``res ``=` `1`   `    ``while` `(y > ``0``):`   `        ``# If y is odd, multiply x` `        ``# with result` `        ``if` `(y & ``1``):` `            ``res ``=` `res ``*` `x`   `        ``# Update the value of y and x` `        ``y ``=` `y >> ``1` `        ``x ``=` `x ``*` `x`   `    ``# Return the result` `    ``return` `res`   `# Function to count number of arrays` `# having element over the range` `# [0, 2^K - 1] with Bitwise AND value` `# 0 having maximum possible sum` `def` `countArrays(N, K):` `    ``# Print the value of N^K` `    ``print``(power(N, K))`     `# Driver Code`   `N ``=` `5``;` `K ``=` `6``;` `countArrays(N, K)`   `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find the value of X to` `// the power Y` `static` `int` `power(``int` `x, ``int` `y)` `{` `    `  `    ``// Stores the value of X^Y` `    ``int` `res = 1;`   `    ``while` `(y > 0)` `    ``{` `        `  `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `(y % 2 != 0)` `            ``res = res * x;`   `        ``// Update the value of y and x` `        ``y = y >> 1;` `        ``x = x * x;` `    ``}`   `    ``// Return the result` `    ``return` `res;` `}`   `// Function to count number of arrays` `// having element over the range` `// [0, 2^K - 1] with Bitwise AND value` `// 0 having maximum possible sum` `static` `void` `countArrays(``int` `N, ``int` `K)` `{` `    `  `    ``// Print the value of N^K` `    ``Console.WriteLine((``int``)(power(N, K)));` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 5, K = 6;` `    `  `    ``countArrays(N, K);` `}` `}`   `// This code is contributed by subhammahato348`

## Javascript

 ``

Output:

`15625`

Time Complexity: O(log K)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :