Double Modular Exponentiation

Double Modular Exponentiation - Problem

You are given a 0-indexed 2D array variables where variables[i] = [a_i, b_i, c_i, m_i], and an integer target.

An index i is good if the following formula holds:

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

Return an array consisting of good indices in any order.

Input & Output

Example 1 — Basic Case

$ Input: variables = [[2,3,3,10],[3,1,4,12],[7,3,1,17],[4,2,5,5]], target = 3

› Output: [2]

💡 Note: For index 2: ((7³ % 10)¹) % 17 = (343 % 10)¹ % 17 = 3¹ % 17 = 3. Only index 2 matches target 3.

Example 2 — Multiple Matches

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

› Output: [0]

💡 Note: For index 0: ((39³ % 10)¹⁰⁰⁰) % 1000 = (59319 % 10)¹⁰⁰⁰ % 1000 = 9¹⁰⁰⁰ % 1000 = 49.

Example 3 — No Matches

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

› Output: []

💡 Note: For index 0: ((2² % 10)²) % 2 = (4²) % 2 = 16 % 2 = 0 ≠ 5. No indices match.

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⁶

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use modular exponentiation to efficiently compute very large powers without overflow. We apply the formula ((a^b % 10)^c) % m for each variable set and collect indices where the result equals the target. Best approach uses binary exponentiation: Time: O(n × log(max(b,c))), Space: O(k) where k is the number of matches.

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Direct Calculation with Modular Exponentiation

⏱️ Time: O(n × (log b + log c)) Space: O(k)

For each variable set, compute (a^b % 10)^c % m step by step and check if it equals the target. Use modular exponentiation to handle large numbers efficiently.

Optimized Modular Exponentiation

⏱️ Time: O(n × (log b + log c)) Space: O(k)

Same algorithm but with highly optimized modular exponentiation using binary exponentiation (exponentiation by squaring). This reduces time complexity for each exponentiation from O(exp) to O(log exp).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_PATTERNS 1000
#define MAX_STR_LEN 1000

typedef struct {
    char pattern[MAX_STR_LEN];
    int count;
} PatternCount;

int findPattern(PatternCount* patterns, int size, char* pattern) {
    for (int i = 0; i < size; i++) {
        if (strcmp(patterns[i].pattern, pattern) == 0) {
            return i;
        }
    }
    return -1;
}

int solution(int** grid, int n) {
    PatternCount rowPatterns[MAX_PATTERNS];
    PatternCount colPatterns[MAX_PATTERNS];
    int rowPatternsCount = 0;
    int colPatternsCount = 0;
    
    // Count frequency of each row pattern
    for (int i = 0; i < n; i++) {
        char rowStr[MAX_STR_LEN] = "";
        for (int j = 0; j < n; j++) {
            char temp[20];
            sprintf(temp, "%d", grid[i][j]);
            if (j > 0) strcat(rowStr, ",");
            strcat(rowStr, temp);
        }
        
        int idx = findPattern(rowPatterns, rowPatternsCount, rowStr);
        if (idx == -1) {
            strcpy(rowPatterns[rowPatternsCount].pattern, rowStr);
            rowPatterns[rowPatternsCount].count = 1;
            rowPatternsCount++;
        } else {
            rowPatterns[idx].count++;
        }
    }
    
    // Count frequency of each column pattern
    for (int j = 0; j < n; j++) {
        char colStr[MAX_STR_LEN] = "";
        for (int i = 0; i < n; i++) {
            char temp[20];
            sprintf(temp, "%d", grid[i][j]);
            if (i > 0) strcat(colStr, ",");
            strcat(colStr, temp);
        }
        
        int idx = findPattern(colPatterns, colPatternsCount, colStr);
        if (idx == -1) {
            strcpy(colPatterns[colPatternsCount].pattern, colStr);
            colPatterns[colPatternsCount].count = 1;
            colPatternsCount++;
        } else {
            colPatterns[idx].count++;
        }
    }
    
    // Count pairs: for each pattern, multiply row_freq * col_freq
    int pairs = 0;
    for (int i = 0; i < rowPatternsCount; i++) {
        int colIdx = findPattern(colPatterns, colPatternsCount, rowPatterns[i].pattern);
        if (colIdx != -1) {
            pairs += rowPatterns[i].count * colPatterns[colIdx].count;
        }
    }
    
    return pairs;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Count rows by counting '],['  + accounting for first and last
    int n = 1;
    for (int i = 0; line[i] && line[i+1]; i++) {
        if (line[i] == ']' && line[i+1] == ',' && line[i+2] == '[') {
            n++;
        }
    }
    
    // Handle empty case
    if (strcmp(line, "[]") == 0) {
        n = 0;
    }
    
    if (n == 0) {
        printf("0\n");
        return 0;
    }
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse the matrix
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    ptr++; // Skip first '['
    
    for (int i = 0; i < n; i++) {
        if (*ptr == '[') ptr++; // Skip row opening '['
        
        for (int j = 0; j < n; j++) {
            // Skip whitespace
            while (*ptr && isspace(*ptr)) ptr++;
            
            // Parse number
            grid[i][j] = strtol(ptr, &ptr, 10);
            
            // Skip comma if present
            while (*ptr && (*ptr == ',' || isspace(*ptr))) ptr++;
        }
        
        // Skip row closing ']' and comma
        while (*ptr && (*ptr == ']' || *ptr == ',' || isspace(*ptr))) ptr++;
    }
    
    int result = solution(grid, n);
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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