# Count N-length arrays of made up of elements not exceeding 2^K – 1 having maximum sum and Bitwise AND equal to 0

Given two integers **N** and **K, **the task is to find the number of **N**-length arrays that satisfies the following conditions:

- The sum of the array elements is maximum possible.
- For every possible value of
**i**(*1 ≤ i ≤ N*), the**i**element should lie between^{th}**0**and**2**.^{K}– 1 - Also, Bitwise AND of all the array elements should be 0.

**Note:** Since, the answer can be large, so print the answer *modulo 10^9 + 7**.*

**Examples :**

Input :N=2 K =2Output :4Explanation :The required arrays are ( {1, 2}, {2, 1}, {0, 3}, {3, 0} )

Input :N=1 K =1Output :1

**Approach:** The idea is to observe that if all the bits of all the elements in the array are **1**, then the bitwise AND of all elements wont be **0** although the sum would be maximized. So for each bit, flip the **1** to **0** at each bit in at least one of the elements to make the bitwise AND equal to **0** and at the same time keeping the sum maximum. So for every bit, choose exactly one element and flip the bit there. Since there are **K** bits and **N** elements, the answer is just **N^K**. Follow the steps below to solve the problem:

- Define a function
**power(long long x, long long y, int p)**and perform the following tasks:- Initialize the variable
**res**as**1**to store the result. - Update the value of
**x**as**x%p.** - If
**x**is equal to**0,**then return**0.** - Iterate in a while loop till
**y**is greater than**0**and perform the following tasks.- If
**y**is odd, then set the value of**res**as**(res*x)%p.** - Divide
**y**by**2.** - Set the value of
**x**as**(x*x)%p.**

- If

- Initialize the variable
- Initialize the variable
**mod**as**1e9+7.** - Initialize the variable
**ans**as the value returned by the function**power(N, K, mod).** - After performing the above steps, print the value of
**ans**as the answer.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to calculate the power of n^k % p` `int` `power(` `long` `long` `x, unsigned ` `int` `y, ` `int` `p)` `{` ` ` `int` `res = 1;` ` ` `// Update x if it is more` ` ` `// than or equal to p` ` ` `x = x % p;` ` ` `// In case x is divisible by p;` ` ` `if` `(x == 0)` ` ` `return` `0;` ` ` `while` `(y > 0) {` ` ` `// If y is odd, multiply` ` ` `// x with result` ` ` `if` `(y & 1)` ` ` `res = (res * x) % p;` ` ` `// y must be even now` ` ` `y = y >> 1; ` `// y = y/2` ` ` `x = (x * x) % p;` ` ` `}` ` ` `return` `res;` `}` `// Function to count the number of` `// arrays satisfying required conditions` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `int` `mod = 1000000007;` ` ` `// Calculating N^K` ` ` `int` `ans = power(n, k, mod);` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `n = 3, k = 5;` ` ` `int` `ans = countArrays(n, k);` ` ` `cout << ans << endl;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `class` `GFG{` ` ` `// Function to calculate the power of n^k % p` `static` `int` `power(` `int` `x, ` `int` `y, ` `int` `p)` `{` ` ` `int` `res = ` `1` `;` ` ` `// Update x if it is more` ` ` `// than or equal to p` ` ` `x = x % p;` ` ` `// In case x is divisible by p;` ` ` `if` `(x == ` `0` `)` ` ` `return` `0` `;` ` ` `while` `(y > ` `0` `)` ` ` `{` ` ` ` ` `// If y is odd, multiply` ` ` `// x with result` ` ` `if` `((y & ` `1` `) == ` `1` `)` ` ` `res = (res * x) % p;` ` ` `// y must be even now` ` ` `y = y >> ` `1` `; ` `// y = y/2` ` ` `x = (x * x) % p;` ` ` `}` ` ` `return` `res;` `}` `// Function to count the number of` `// arrays satisfying required conditions` `static` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `int` `mod = ` `1000000007` `;` ` ` ` ` `// Calculating N^K` ` ` `int` `ans = power(n, k, mod);` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `main (String[] args)` `{` ` ` `int` `n = ` `3` `, k = ` `5` `;` ` ` `int` `ans = countArrays(n, k);` ` ` ` ` `System.out.println(ans);` `}` `}` `// This code is contributed by shubhamsingh10` |

## Python3

`# Python3 program for the above approach` `# Function to calculate the power of n^k % p` `def` `power(x, y, p):` ` ` `res ` `=` `1` ` ` `# Update x if it is more` ` ` `# than or equal to p` ` ` `x ` `=` `x ` `%` `p` ` ` `# In case x is divisible by p;` ` ` `if` `(x ` `=` `=` `0` `):` ` ` `return` `0` ` ` `while` `(y > ` `0` `):` ` ` `# If y is odd, multiply` ` ` `# x with result` ` ` `if` `(y & ` `1` `):` ` ` `res ` `=` `(res ` `*` `x) ` `%` `p` ` ` `# y must be even now` ` ` `y ` `=` `y >> ` `1` `# y = y/2` ` ` `x ` `=` `(x ` `*` `x) ` `%` `p` ` ` `return` `res` `# Function to count the number of` `# arrays satisfying required conditions` `def` `countArrays(n, k):` ` ` `mod ` `=` `1000000007` ` ` ` ` `# Calculating N^K` ` ` `ans ` `=` `power(n, k, mod)` ` ` `return` `ans` `# Driver Code` `n ` `=` `3` `k ` `=` `5` `ans ` `=` `countArrays(n, k)` `print` `(ans)` `# This code is contributed by gfgking` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to calculate the power of n^k % p` `static` `int` `power(` `int` `x, ` `int` `y, ` `int` `p)` `{` ` ` `int` `res = 1;` ` ` `// Update x if it is more` ` ` `// than or equal to p` ` ` `x = x % p;` ` ` `// In case x is divisible by p;` ` ` `if` `(x == 0)` ` ` `return` `0;` ` ` `while` `(y > 0) {` ` ` `// If y is odd, multiply` ` ` `// x with result` ` ` `if` `((y & 1) !=0)` ` ` `res = (res * x) % p;` ` ` `// y must be even now` ` ` `y = y >> 1; ` `// y = y/2` ` ` `x = (x * x) % p;` ` ` `}` ` ` `return` `res;` `}` `// Function to count the number of` `// arrays satisfying required conditions` `static` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `int` `mod = 1000000007;` ` ` `// Calculating N^K` ` ` `int` `ans = power(n, k, mod);` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `n = 3, k = 5;` ` ` `int` `ans = countArrays(n, k);` ` ` `Console.Write(ans);` `}` `}` `// This code is contributed by SURENDRA_GANGWAR.` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to calculate the power of n^k % p` ` ` `function` `power(x, y, p) {` ` ` `let res = 1;` ` ` `// Update x if it is more` ` ` `// than or equal to p` ` ` `x = x % p;` ` ` `// In case x is divisible by p;` ` ` `if` `(x == 0)` ` ` `return` `0;` ` ` `while` `(y > 0) {` ` ` `// If y is odd, multiply` ` ` `// x with result` ` ` `if` `(y & 1)` ` ` `res = (res * x) % p;` ` ` `// y must be even now` ` ` `y = y >> 1; ` `// y = y/2` ` ` `x = (x * x) % p;` ` ` `}` ` ` `return` `res;` ` ` `}` ` ` `// Function to count the number of` ` ` `// arrays satisfying required conditions` ` ` `function` `countArrays(n, k) {` ` ` `let mod = 1000000007;` ` ` `// Calculating N^K` ` ` `let ans = power(n, k, mod);` ` ` `return` `ans;` ` ` `}` ` ` `// Driver Code` ` ` `let n = 3, k = 5;` ` ` `let ans = countArrays(n, k);` ` ` `document.write(ans);` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output:**

243

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**