Program to find out the value of a power of 2 in Python

Finding the value of 2^(2^p) mod q is a common mathematical problem that involves computing very large powers efficiently. Python's built-in pow() function provides an elegant solution using modular exponentiation.

Problem Understanding

Given two integers p and q, we need to calculate 2^(2^p) mod q. For example, if p = 5 and q = 6:

• First calculate 2^p = 2^5 = 32
• Then calculate 2^32 mod 6
• The result is 4

Solution Approach

We use Python's pow(base, exponent, modulus) function which efficiently computes (base^exponent) % modulus using modular exponentiation ?

def solve(p, q):
    # Calculate 2^(2^p) mod q
    exponent = 2 ** p  # Calculate 2^p first
    result = pow(2, exponent, q)  # Then 2^(2^p) mod q
    return result

# Test with the given example
p = 5
q = 6
answer = solve(p, q)
print(f"2^(2^{p}) mod {q} = {answer}")

2^(2^5) mod 6 = 4

Step-by-Step Calculation

Let's break down the calculation for p = 5, q = 6 ?

def solve_with_steps(p, q):
    print(f"Given: p = {p}, q = {q}")
    
    # Step 1: Calculate 2^p
    power_of_two = 2 ** p
    print(f"Step 1: 2^{p} = {power_of_two}")
    
    # Step 2: Calculate 2^(2^p) mod q
    result = pow(2, power_of_two, q)
    print(f"Step 2: 2^{power_of_two} mod {q} = {result}")
    
    return result

solve_with_steps(5, 6)

Given: p = 5, q = 6
Step 1: 2^5 = 32
Step 2: 2^32 mod 6 = 4

Testing with Multiple Examples

def solve(p, q):
    return pow(2, 2 ** p, q)

# Test cases
test_cases = [(5, 6), (3, 7), (4, 10), (2, 5)]

for p, q in test_cases:
    result = solve(p, q)
    print(f"p = {p}, q = {q} ? 2^(2^{p}) mod {q} = {result}")

p = 5, q = 6 ? 2^(2^5) mod 6 = 4
p = 3, q = 7 ? 2^(2^3) mod 7 = 4
p = 4, q = 10 ? 2^(2^4) mod 10 = 6
p = 2, q = 5 ? 2^(2^2) mod 5 = 1

Why Use pow() with Three Arguments?

The three-argument pow(base, exponent, modulus) is much more efficient than calculating (base ** exponent) % modulus because:

• It uses modular exponentiation algorithm
• Prevents integer overflow for very large exponents
• Computes the result without storing the full value of 2^(2^p)

Conclusion

Use Python's pow(2, 2**p, q) to efficiently calculate 2^(2^p) mod q. This approach handles very large exponents without memory issues and provides the correct modular result.