Skip to content
Related Articles

Related Articles

Improve Article

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

  • Last Updated : 05 Aug, 2021

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 ith element should lie between 0 and 2K – 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 =2
Output : 4
Explanation : The required arrays are ( {1, 2}, {2, 1}, {0, 3}, {3, 0} )

Input : N=1 K =1
Output : 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.
  • 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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :