Double Modular Exponentiation - Practice Coding Problems

Double Modular Exponentiation - Problem

You are given a 2D array variables where each element variables[i] = [a_i, b_i, c_i, m_i] represents a set of parameters for a double modular exponentiation calculation, and an integer target.

Your task is to find all "good" indices. An index i is considered good if the following formula evaluates to the target:

((a_i^b_i % 10)^c_i) % m_i == target

The calculation involves two levels of modular exponentiation:

First, compute a_i^b_i % 10 (only the last digit matters)
Then, raise that result to the power of c_i and take modulo m_i

Return an array containing all good indices in any order.

Input & Output

example_1.py — Basic Case

$ Input: variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2

› Output: [0,2]

💡 Note: For index 0: ((2³ % 10)³) % 10 = (8³) % 10 = 512 % 10 = 2 ✓. For index 1: ((3³ % 10)³) % 1 = (7³) % 1 = 0 ≠ 2. For index 2: ((6¹ % 10)¹) % 4 = (6¹) % 4 = 2 ✓.

example_2.py — Single Match

$ Input: variables = [[39,3,1000,1000]], target = 17

› Output: [0]

💡 Note: For index 0: ((39³ % 10)¹⁰⁰⁰) % 1000. First, 39³ = 59319, so 39³ % 10 = 9. Then 9¹⁰⁰⁰ % 1000 = 17.

example_3.py — No Matches

$ Input: variables = [[1,1,1,1],[2,2,2,2]], target = 5

› Output: []

💡 Note: For index 0: ((1¹ % 10)¹) % 1 = 0 ≠ 5. For index 1: ((2² % 10)²) % 2 = ((4)²) % 2 = 0 ≠ 5. No indices satisfy the condition.

Visualization

Tap to expand

Understanding the Visualization

First Transformation

Calculate a^b % 10 to get the last digit of a^b

Second Transformation

Use the result as base for (result)^c % m

Target Matching

Compare final result with target to determine if index is good

Key Takeaway

🎯 Key Insight: Fast exponentiation reduces time complexity from O(b+c) to O(log b + log c) per calculation, making it essential for handling large exponents efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n * log(max(b, c)))

For each of n variables, fast exponentiation takes O(log(exponent)) time

⚡ Linearithmic

Space Complexity

O(k)

Only store the result array where k is the number of good indices

✓ Linear Space

Constraints

1 ≤ variables.length ≤ 1000
variables[i] = [a_i, b_i, c_i, m_i]
1 ≤ a_i, b_i, c_i, m_i ≤ 10³
0 ≤ target ≤ 10³
The result array can be returned in any order

Asked in

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

The optimal approach uses fast exponentiation to efficiently compute modular powers in O(log n) time per exponent. The key insight is that we can use binary exponentiation to avoid the expensive repeated multiplication of naive approaches, especially important when dealing with large exponents up to 10³.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Naive Exponentiation	O(n * max(b, c))	O(k)	Calculate each formula using naive exponentiation without optimization
Optimized with Fast Exponentiation (Optimal)	O(n * log(max(b, c)))	O(k)	Use fast exponentiation to efficiently compute modular powers

Brute Force with Naive Exponentiation — Algorithm Steps

Iterate through each set of variables [a, b, c, m]
Calculate a^b % 10 using repeated multiplication
Calculate (result)^c % m using repeated multiplication
Compare with target and add index to result if equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Variable Set

Iterate through each [a, b, c, m] in the variables array

First Exponentiation

Calculate a^b % 10 using repeated multiplication

Second Exponentiation

Calculate (result)^c % m using repeated multiplication

Compare and Store

If result equals target, add index to good indices

Code -

solution.c — C

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

int naivePower(int base, int exp, int mod) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result = (result * base) % mod;
    }
    return result;
}

int* getGoodIndices(int** variables, int variablesSize, int* variablesColSize, int target, int* returnSize) {
    int* goodIndices = (int*)malloc(variablesSize * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < variablesSize; i++) {
        int a = variables[i][0], b = variables[i][1];
        int c = variables[i][2], m = variables[i][3];
        
        // Step 1: Calculate a^b % 10
        int firstResult = naivePower(a, b, 10);
        // Step 2: Calculate (firstResult)^c % m
        int finalResult = naivePower(firstResult, c, m);
        // Check if it equals target
        if (finalResult == target) {
            goodIndices[count++] = i;
        }
    }
    
    *returnSize = count;
    return goodIndices;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max(b, c))

For each of n variables, we perform up to max(b, c) multiplications

✓ Linear Growth

Space Complexity

O(k)

Only store the result array where k is the number of good indices

✓ Linear Space

Constraints

1 ≤ variables.length ≤ 1000
variables[i] = [a_i, b_i, c_i, m_i]
1 ≤ a_i, b_i, c_i, m_i ≤ 10³
0 ≤ target ≤ 10³
The result array can be returned in any order

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force with Naive Exponentiation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler