Super Pow - Practice Coding Problems

Super Pow - Problem

Super Power Modulo Challenge

You need to calculate a^b mod 1337 where:
• a is a positive integer
• b is an extremely large positive integer given as an array of digits

The challenge here is that b can be so large that it won't fit in any standard integer type! For example, b could be represented as [1,2,3,4,5,6,7,8,9,0] meaning the number 1234567890.

Goal: Efficiently compute the modular exponentiation without overflow
Input: Integer a and array b representing a huge number
Output: a^b mod 1337 as an integer

Input & Output

example_1.py — Basic Case

$ Input: a = 2, b = [3]

› Output: 8

💡 Note: 2^3 = 8, and 8 mod 1337 = 8

example_2.py — Large Exponent

$ Input: a = 2, b = [1,0]

› Output: 1024

💡 Note: 2^10 = 1024, and 1024 mod 1337 = 1024

example_3.py — Modulo Effect

$ Input: a = 2147483647, b = [2,0,0]

› Output: 1198

💡 Note: 2147483647^200 mod 1337 = 1198 (demonstrates the modulo effect)

Constraints

1 ≤ a ≤ 2³¹ - 1
1 ≤ b.length ≤ 2000
0 ≤ b[i] ≤ 9
b doesn't contain leading zeros
The result should be computed modulo 1337

Visualization

Tap to expand

Understanding the Visualization

Recursive Decomposition

Break a^[1,2,3,4] into (a^[1,2,3])^10 * a^4

Apply Modular Arithmetic

Use (x*y) mod m = ((x mod m) * (y mod m)) mod m

Prevent Overflow

Each intermediate result stays within bounds

Key Takeaway

🎯 Key Insight: Use the mathematical property a^[d1,d2,d3] = (a^[d1,d2])^10 * a^d3 combined with modular arithmetic to handle arbitrarily large exponents efficiently!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses divide and conquer with modular arithmetic. Key insight: break down a^[d1,d2,d3] = (a^[d1,d2])^10 * a^d3 and apply modulo 1337 at each step to prevent overflow. This handles arbitrarily large exponents in O(n) time where n is the number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer with Modular Arithmetic	O(n)	O(n)	Break down the problem using mathematical properties and modular arithmetic
Brute Force (Direct Calculation)	O(b)	O(1)	Convert array to number and calculate power directly

Divide and Conquer with Modular Arithmetic — Algorithm Steps

Base case: if b is empty, return 1
Pop last digit from b
Recursively calculate a^(remaining digits) mod 1337
Raise result to power 10, then multiply by a^(last digit)
Apply modulo 1337 at each step

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Problem

a^[1,2,3] = (a^[1,2])^10 * a^3

Recursive Call

Solve a^[1,2] first

Combine Results

Multiply results with modular arithmetic

Code -

solution.c — C

#include <stdio.h>

const int MOD = 1337;

int powMod(int base, int exp, int mod) {
    int result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

int helper(int a, int* b, int index) {
    if (index < 0) {
        return 1;
    }
    
    int part1 = powMod(helper(a, b, index - 1), 10, MOD);
    int part2 = powMod(a, b[index], MOD);
    return (part1 * part2) % MOD;
}

int superPow(int a, int* b, int bSize) {
    return helper(a % MOD, b, bSize - 1);
}

int main() {
    int a;
    char bStr[1000];
    scanf("%d %s", &a, bStr);
    
    int b[1000];
    int size = 0;
    for (int i = 0; bStr[i] != '\0'; i++) {
        b[size++] = bStr[i] - '0';
    }
    
    printf("%d\n", superPow(a, b, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of digits in b, each digit is processed once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of digits

⚡ Linearithmic Space

24.6K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Divide and Conquer with Modular Arithmetic — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler