# Calculate the value of 2 raised to the power of twice the binary representation of N

• Difficulty Level : Easy
• Last Updated : 11 Jun, 2021

Given a positive integer N, the task is to find the value of (22 * X), where X is the binary representation of N. Since the answer can be very large, print it modulo 109 + 7
Examples:

Input: N = 2
Output: 1048576
Explanation:
The binary representation of 2 is (10)2
Therefore, the value of (22 * 10) % (109 + 7) = (220) % (109 + 7) = 1048576

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.

Input: N = 150
Output: 654430484

Naive Approach: The simplest approach to solve this problem is to generate the binary representation of N, say X, and calculate the value of (22 * X) % (109 + 7) using modular exponentiation:

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;``#define M 1000000007` `// Function to find the value``// of power(X, Y) in O(log Y)``long` `long` `power(``long` `long` `X,``                ``long` `long` `Y)``{``    ``// Stores power(X, Y)``    ``long` `long` `res = 1;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == 0)``        ``return` `0;` `    ``// Calculate power(X, Y)``    ``while` `(Y > 0) {` `        ``// If Y is an odd number``        ``if` `(Y & 1) {` `            ``// Update res``            ``res = (res * X) % M;``        ``}` `        ``// Update Y``        ``Y = Y >> 1;` `        ``// Update X``        ``X = (X * X) % M;``    ``}` `    ``return` `res;``}` `// Function to calculate``// (2^(2 * x)) % (10^9 + 7)``int` `findValue(``long` `long` `int` `n)``{` `    ``// Stores binary``    ``// representation of n``    ``long` `long` `X = 0;` `    ``// Stores power of 10``    ``long` `long` `pow_10 = 1;` `    ``// Calculate the binary``    ``// representation of n``    ``while` `(n) {` `        ``// If n is an odd number``        ``if` `(n & 1) {` `            ``// Update X``            ``X += pow_10;``        ``}` `        ``// Update pow_10``        ``pow_10 *= 10;` `        ``// Update n``        ``n /= 2;``    ``}` `    ``// Double the value of X``    ``X = (X * 2) % M;` `    ``// Stores the value of``    ``// (2^(2 * x)) % (10^9 + 7)``    ``long` `long` `res = power(2, X);` `    ``return` `res;``}` `// Driver Code``int` `main()``{` `    ``long` `long` `n = 2;``    ``cout << findValue(n);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``class` `GFG``{` `  ``static` `int` `M  = ``1000000007``;` `  ``// Function to find the value``  ``// of power(X, Y) in O(log Y)``  ``static` `int`  `power(``int`  `X,``                    ``int`  `Y)``  ``{` `    ``// Stores power(X, Y)``    ``int`  `res = ``1``;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == ``0``)``      ``return` `0``;` `    ``// Calculate power(X, Y)``    ``while` `(Y > ``0``)``    ``{` `      ``// If Y is an odd number``      ``if` `((Y & ``1``) != ``0``)``      ``{` `        ``// Update res``        ``res = (res * X) % M;``      ``}` `      ``// Update Y``      ``Y = Y >> ``1``;` `      ``// Update X``      ``X = (X * X) % M;``    ``}``    ``return` `res;``  ``}`` ` `  ``// Function to calculate``  ``// (2^(2 * x)) % (10^9 + 7)``  ``static` `int` `findValue(``int` `n)``  ``{` `    ``// Stores binary``    ``// representation of n``    ``int`  `X = ``0``;` `    ``// Stores power of 10``    ``int`  `pow_10 = ``1``;` `    ``// Calculate the binary``    ``// representation of n``    ``while` `(n != ``0``)``    ``{` `      ``// If n is an odd number``      ``if` `((n & ``1``) != ``0``)``      ``{` `        ``// Update X``        ``X += pow_10;``      ``}` `      ``// Update pow_10``      ``pow_10 *= ``10``;` `      ``// Update n``      ``n /= ``2``;``    ``}` `    ``// Double the value of X``    ``X = (X * ``2``) % M;` `    ``// Stores the value of``    ``// (2^(2 * x)) % (10^9 + 7)``    ``int`  `res = power(``2``, X);``    ``return` `res;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int`  `n = ``2``;``    ``System.out.println(findValue(n));``  ``}``}` `// This code is contributed by susmitakundugoaldanga.`

## Python3

 `# Python3 program to implement``# the above approach``M ``=` `1000000007` `# Function to find the value``# of power(X, Y) in O(log Y)``def` `power(X, Y):``    ` `    ``# Stores power(X, Y)``    ``res ``=` `1` `    ``# Update X``    ``X ``=` `X ``%` `M` `    ``# Base Case``    ``if` `(X ``=``=` `0``):``        ``return` `0` `    ``# Calculate power(X, Y)``    ``while` `(Y > ``0``):` `        ``# If Y is an odd number``        ``if` `(Y & ``1``):` `            ``# Update res``            ``res ``=` `(res ``*` `X) ``%` `M` `        ``# Update Y``        ``Y ``=` `Y >> ``1` `        ``# Update X``        ``X ``=` `(X ``*` `X) ``%` `M` `    ``return` `res` `# Function to calculate``# (2^(2 * x)) % (10^9 + 7)``def` `findValue(n):` `    ``# Stores binary``    ``# representation of n``    ``X ``=` `0` `    ``# Stores power of 10``    ``pow_10 ``=` `1` `    ``# Calculate the binary``    ``# representation of n``    ``while``(n):` `        ``# If n is an odd number``        ``if` `(n & ``1``):``            ` `            ``# Update X``            ``X ``+``=` `pow_10` `        ``# Update pow_10``        ``pow_10 ``*``=` `10` `        ``# Update n``        ``n ``/``/``=` `2` `    ``# Double the value of X``    ``X ``=` `(X ``*` `2``) ``%` `M` `    ``# Stores the value of``    ``# (2^(2 * x)) % (10^9 + 7)``    ``res ``=` `power(``2``, X)` `    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``n ``=` `2``    ` `    ``print``(findValue(n))``    ` `# This code is contributed by AnkThon`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG``{` `  ``static` `int` `M  = 1000000007;` `  ``// Function to find the value``  ``// of power(X, Y) in O(log Y)``  ``static` `int`  `power(``int`  `X,``                    ``int`  `Y)``  ``{` `    ``// Stores power(X, Y)``    ``int`  `res = 1;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == 0)``      ``return` `0;` `    ``// Calculate power(X, Y)``    ``while` `(Y > 0)``    ``{` `      ``// If Y is an odd number``      ``if` `((Y & 1) != 0)``      ``{` `        ``// Update res``        ``res = (res * X) % M;``      ``}` `      ``// Update Y``      ``Y = Y >> 1;` `      ``// Update X``      ``X = (X * X) % M;``    ``}``    ``return` `res;``  ``}`` ` `  ``// Function to calculate``  ``// (2^(2 * x)) % (10^9 + 7)``  ``static` `int` `findValue(``int` `n)``  ``{` `    ``// Stores binary``    ``// representation of n``    ``int`  `X = 0;` `    ``// Stores power of 10``    ``int`  `pow_10 = 1;` `    ``// Calculate the binary``    ``// representation of n``    ``while` `(n != 0)``    ``{` `      ``// If n is an odd number``      ``if` `((n & 1) != 0)``      ``{` `        ``// Update X``        ``X += pow_10;``      ``}` `      ``// Update pow_10``      ``pow_10 *= 10;` `      ``// Update n``      ``n /= 2;``    ``}` `    ``// Double the value of X``    ``X = (X * 2) % M;` `    ``// Stores the value of``    ``// (2^(2 * x)) % (10^9 + 7)``    ``int`  `res = power(2, X);``    ``return` `res;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int`  `n = 2;``    ``Console.WriteLine(findValue(n));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``
Output:
`1048576`

Time Complexity: O(log2(X)), where X is the binary representation of N
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized using Dynamic programming based on the following observations:

If N == 1 then the required output is (21)2 = (21)2
If N == 2 then the required output is (210)2 = (210)2
If N == 3 then the required output is (211)2 = (210 * 21)2
If N == 4 then the required output is (2100)2 = (2100)2
If N == 5 then the required output is (2101)2 = (2100 * 21)2
………………………..
Below is the relation between the dynamic programming states:
If N is a power of 2, then dp[N] = power(dp[N / 2], 10)
Otherwise, dp[N] = dp[(N & (-N))] * dp[N – (N & (-N))]
dp[N]2: Stores the required output for the positive integer N

Follow the steps below to solve the problem:

• Initialize an array, say dp[], such that dp[i]2 stores the value of (22 * X) % (109 + 7), where X is the binary representation of i.
• Iterate over the range [3, N] using variable i and find all possible value of dp[i] using the tabulation method.
• Finally, print the value of dp[N]2

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;``#define M 1000000007` `// Function to find the value``// of power(X, Y) in O(log Y)``long` `long` `power(``long` `long` `X,``                ``long` `long` `Y)``{``    ``// Stores power(X, Y)``    ``long` `long` `res = 1;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == 0)``        ``return` `0;` `    ``// Calculate power(X, Y)``    ``while` `(Y > 0) {` `        ``// If Y is an odd number``        ``if` `(Y & 1) {` `            ``// Update res``            ``res = (res * X) % M;``        ``}` `        ``// Update Y``        ``Y = Y >> 1;` `        ``// Update X``        ``X = (X * X) % M;``    ``}` `    ``return` `res;``}` `// Function to calculate``// (2^(2 * x)) % (10^9 + 7)``long` `long` `findValue(``long` `long` `N)``{` `    ``// dp[N] * dp[N]: Stores value``    ``// of (2^(2 * x)) % (10^9 + 7)``    ``long` `long` `dp[N + 1];` `    ``// Base Case``    ``dp = 2;``    ``dp = 1024;` `    ``// Iterate over the range [3, N]``    ``for` `(``int` `i = 3; i <= N; i++) {` `        ``// Stores rightmost``        ``// bit of i``        ``int` `y = (i & (-i));` `        ``// Stores the value``        ``// of (i - y)``        ``int` `x = i - y;` `        ``// If x is power``        ``// of 2``        ``if` `(x == 0) {` `            ``// Update dp[i]``            ``dp[i]``                ``= power(dp[i / 2], 10);``        ``}``        ``else` `{` `            ``// Update dp[i]``            ``dp[i]``                ``= (dp[x] * dp[y]) % M;``        ``}``    ``}` `    ``return` `(dp[N] * dp[N]) % M;``}` `// Driver Code``int` `main()``{` `    ``long` `long` `n = 150;``    ``cout << findValue(n);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``class` `GFG``{``  ``static` `final` `long` `M = ``1000000007``;` `  ``// Function to find the value``  ``// of power(X, Y) in O(log Y)``  ``static` `long` `power(``long` `X,``                    ``long` `Y)``  ``{` `    ``// Stores power(X, Y)``    ``long` `res = ``1``;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == ``0``)``      ``return` `0``;` `    ``// Calculate power(X, Y)``    ``while` `(Y > ``0``)``    ``{` `      ``// If Y is an odd number``      ``if` `(Y % ``2` `== ``1``)``      ``{` `        ``// Update res``        ``res = (res * X) % M;``      ``}` `      ``// Update Y``      ``Y = Y >> ``1``;` `      ``// Update X``      ``X = (X * X) % M;``    ``}` `    ``return` `res;``  ``}` `  ``// Function to calculate``  ``// (2^(2 * x)) % (10^9 + 7)``  ``static` `long` `findValue(``int` `N)``  ``{` `    ``// dp[N] * dp[N]: Stores value``    ``// of (2^(2 * x)) % (10^9 + 7)``    ``long` `[]dp = ``new` `long``[N + ``1``];` `    ``// Base Case``    ``dp[``1``] = ``2``;``    ``dp[``2``] = ``1024``;` `    ``// Iterate over the range [3, N]``    ``for` `(``int` `i = ``3``; i <= N; i++)``    ``{` `      ``// Stores rightmost``      ``// bit of i``      ``int` `y = (i & (-i));` `      ``// Stores the value``      ``// of (i - y)``      ``int` `x = i - y;` `      ``// If x is power``      ``// of 2``      ``if` `(x == ``0``)``      ``{` `        ``// Update dp[i]``        ``dp[i]``          ``= power(dp[i / ``2``], ``10``);``      ``}``      ``else``      ``{` `        ``// Update dp[i]``        ``dp[i]``          ``= (dp[x] * dp[y]) % M;``      ``}``    ``}``    ``return` `(dp[N] * dp[N]) % M;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `n = ``150``;``    ``System.out.print(findValue(n));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program to implement``# the above approach``M ``=` `1000000007``;` `# Function to find the value``# of power(X, Y) in O(log Y)``def` `power(X, Y):``    ` `    ``# Stores power(X, Y)``    ``res ``=` `1``;` `    ``# Update X``    ``X ``=` `X ``%` `M;` `    ``# Base Case``    ``if` `(X ``=``=` `0``):``        ``return` `0``;` `    ``# Calculate power(X, Y)``    ``while` `(Y > ``0``):` `        ``# If Y is an odd number``        ``if` `(Y ``%` `2` `=``=` `1``):``            ` `            ``# Update res``            ``res ``=` `(res ``*` `X) ``%` `M;` `        ``# Update Y``        ``Y ``=` `Y >> ``1``;` `        ``# Update X``        ``X ``=` `(X ``*` `X) ``%` `M;``    ``return` `res;` `# Function to calculate``# (2^(2 * x)) % (10^9 + 7)``def` `findValue(N):` `    ``# dp[N] * dp[N]: Stores value``    ``# of (2^(2 * x)) % (10^9 + 7)``    ``dp ``=` `[``0``]``*``(N ``+` `1``);` `    ``# Base Case``    ``dp[``1``] ``=` `2``;``    ``dp[``2``] ``=` `1024``;` `    ``# Iterate over the range [3, N]``    ``for` `i ``in` `range``(``3``, N ``+` `1``):` `        ``# Stores rightmost``        ``# bit of i``        ``y ``=` `(i & (``-``i));` `        ``# Stores the value``        ``# of (i - y)``        ``x ``=` `i ``-` `y;` `        ``# If x is power``        ``# of 2``        ``if` `(x ``=``=` `0``):` `            ``# Update dp[i]``            ``dp[i] ``=` `power(dp[i ``/``/` `2``], ``10``);``        ``else``:` `            ``# Update dp[i]``            ``dp[i] ``=` `(dp[x] ``*` `dp[y]) ``%` `M;` `    ``return` `(dp[N] ``*` `dp[N]) ``%` `M;` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `150``;``    ``print``(findValue(n));` `# This code is contributed by 29AjayKumar`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG``{``  ``static` `readonly` `long` `M = 1000000007;` `  ``// Function to find the value``  ``// of power(X, Y) in O(log Y)``  ``static` `long` `power(``long` `X,``                    ``long` `Y)``  ``{` `    ``// Stores power(X, Y)``    ``long` `res = 1;` `    ``// Update X``    ``X = X % M;` `    ``// Base Case``    ``if` `(X == 0)``      ``return` `0;` `    ``// Calculate power(X, Y)``    ``while` `(Y > 0)``    ``{` `      ``// If Y is an odd number``      ``if` `(Y % 2 == 1)``      ``{` `        ``// Update res``        ``res = (res * X) % M;``      ``}` `      ``// Update Y``      ``Y = Y >> 1;` `      ``// Update X``      ``X = (X * X) % M;``    ``}` `    ``return` `res;``  ``}` `  ``// Function to calculate``  ``// (2^(2 * x)) % (10^9 + 7)``  ``static` `long` `findValue(``int` `N)``  ``{` `    ``// dp[N] * dp[N]: Stores value``    ``// of (2^(2 * x)) % (10^9 + 7)``    ``long` `[]dp = ``new` `long``[N + 1];` `    ``// Base Case``    ``dp = 2;``    ``dp = 1024;` `    ``// Iterate over the range [3, N]``    ``for` `(``int` `i = 3; i <= N; i++)``    ``{` `      ``// Stores rightmost``      ``// bit of i``      ``int` `y = (i & (-i));` `      ``// Stores the value``      ``// of (i - y)``      ``int` `x = i - y;` `      ``// If x is power``      ``// of 2``      ``if` `(x == 0)``      ``{` `        ``// Update dp[i]``        ``dp[i]``          ``= power(dp[i / 2], 10);``      ``}``      ``else``      ``{` `        ``// Update dp[i]``        ``dp[i]``          ``= (dp[x] * dp[y]) % M;``      ``}``    ``}``    ``return` `(dp[N] * dp[N]) % M;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `n = 150;``    ``Console.Write(findValue(n));``  ``}``}` `// This code contributed by shikhasingrajput`
Output:
`654430484`

Time Complexity: O(N *log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up