Super Pow

Super Pow - Problem

Your task is to calculate a^b mod 1337 where a is a positive integer and b is an extremely large positive integer given in the form of an array.

For example, if a = 2 and b = [3], then b represents the number 3, so we need to calculate 2^3 mod 1337 = 8.

If a = 2 and b = [1,0], then b represents the number 10, so we need to calculate 2^10 mod 1337 = 1024.

Note: a and elements of b are guaranteed to be positive integers.

Input & Output

Example 1 — Basic Single Digit

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

› Output: 8

💡 Note: b represents the number 3, so we calculate 2^3 mod 1337 = 8 mod 1337 = 8

Example 2 — Multi-digit Exponent

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

› Output: 1024

💡 Note: b represents the number 10, so we calculate 2^10 mod 1337 = 1024 mod 1337 = 1024

Example 3 — Large Base with Modulo Effect

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

› Output: 1198

💡 Note: Large base: (2147483647^2) mod 1337. First reduce base: 2147483647 mod 1337 = 1198, then 1198^2 mod 1337 = 1198

Constraints

1 ≤ a ≤ 2³¹ - 1
1 ≤ b.length ≤ 2000
0 ≤ b[i] ≤ 9
b does not contain leading zeros except for the number 0 itself

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to use modular exponentiation properties to handle extremely large exponents efficiently. Since direct calculation of a^b is impossible when b has thousands of digits, we process the exponent digit by digit using the mathematical property a^(10x+y) = (a^x)^10 × a^y mod 1337. The optimal approach uses Chinese Remainder Theorem with factorization 1337 = 7 × 191. Time: O(n), Space: O(1)

Common Approaches

✓ Chinese Remainder Theorem Optimization

⏱️ Time: O(n) Space: O(1)

Since 1337 = 7 × 191 and gcd(7,191) = 1, we can compute a^b mod 7 and a^b mod 191 separately, then combine using Chinese Remainder Theorem for better performance.

Direct Calculation (Impossible)

⏱️ Time: O(b) Space: O(1)

Convert the array b to an actual integer, then compute a^b and take modulo 1337. This approach fails for large exponents due to integer overflow and computational limits.

Modular Exponentiation with Digit Processing

⏱️ Time: O(n) Space: O(1)

Process the exponent digit by digit using the property a^(xy) = (a^x)^y and Euler's theorem. Since 1337 = 7 × 191, we can use Chinese Remainder Theorem for optimization.

Chinese Remainder Theorem Optimization — Algorithm Steps

Factorize 1337 = 7 × 191
Compute a^b mod 7 and a^b mod 191 separately
Use Euler's theorem: a^φ(m) ≡ 1 (mod m)
Combine results using Chinese Remainder Theorem

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Problem

Compute a^b mod 7 and a^b mod 191 separately

Use Euler's Theorem

Apply φ(7)=6, φ(191)=190 for optimization

Combine with CRT

Merge results to get final answer mod 1337

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int a, int* b, int bSize) {
    const int MOD = 1337;
    
    // Handle edge cases
    if (bSize == 0 || (bSize == 1 && b[0] == 0)) {
        return 1;
    }
    
    // Reduce base modulo 1337
    a = a % MOD;
    if (a == 0) {
        return 0;
    }
    if (a == 1) {
        return 1;
    }
    
    // For Euler's theorem: φ(1337) = φ(7 * 191) = φ(7) * φ(191) = 6 * 190 = 1140
    const int phi = 1140;
    
    // Convert array to number mod phi (for large exponents)
    // But first check if exponent is small enough to compute directly
    
    // If exponent array is small (length <= 3), compute directly
    if (bSize <= 3) {
        long long exp = 0;
        for (int i = 0; i < bSize; i++) {
            exp = exp * 10 + b[i];
        }
        
        // Direct modular exponentiation
        long long result = 1;
        long long base = a;
        while (exp > 0) {
            if (exp % 2 == 1) {
                result = (result * base) % MOD;
            }
            base = (base * base) % MOD;
            exp /= 2;
        }
        return result;
    }
    
    // For large exponents, use Euler's theorem
    // a^b ≡ a^(b mod φ(1337) + φ(1337)) (mod 1337) when gcd(a, 1337) = 1
    
    int exp_mod = 0;
    for (int i = 0; i < bSize; i++) {
        exp_mod = (exp_mod * 10 + b[i]) % phi;
    }
    
    // Add phi to ensure exponent >= phi (required for Euler's theorem)
    exp_mod += phi;
    
    // Modular exponentiation
    long long result = 1;
    long long base = a;
    while (exp_mod > 0) {
        if (exp_mod % 2 == 1) {
            result = (result * base) % MOD;
        }
        base = (base * base) % MOD;
        exp_mod /= 2;
    }
    
    return result;
}

int main() {
    int a;
    scanf("%d", &a);
    
    static char line[1000];
    scanf(" %s", line);
    
    static int b[1000];
    int bSize = 0;
    parseArray(line, b, &bSize);
    
    printf("%d\n", solution(a, b, bSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Process each digit once, with constant time CRT operations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for CRT calculations

✓ Linear Space

89.0K Views

Medium Frequency

~35 min Avg. Time

856 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

Chinese Remainder Theorem Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler