Chinese Remainder Theorem Solver - Problem

Given a system of simultaneous congruences, solve for the unique solution modulo the product of all moduli using the Chinese Remainder Theorem.

The system of congruences is given as:

x ≡ a₁ (mod m₁)
x ≡ a₂ (mod m₂)
...
x ≡ aₖ (mod mₖ)

Where all moduli m₁, m₂, ..., mₖ are pairwise coprime (their greatest common divisor is 1).

Return the unique solution x such that 0 ≤ x < M, where M = m₁ × m₂ × ... × mₖ.

Input & Output

Example 1 — Basic Three Congruences

$ Input: remainders = [2,3,2], moduli = [3,5,7]

› Output: 23

💡 Note: System: x ≡ 2 (mod 3), x ≡ 3 (mod 5), x ≡ 2 (mod 7). Check: 23%3=2✓, 23%5=3✓, 23%7=2✓

Example 2 — Two Congruences

$ Input: remainders = [1,4], moduli = [2,5]

› Output: 9

💡 Note: System: x ≡ 1 (mod 2), x ≡ 4 (mod 5). Check: 9%2=1✓, 9%5=4✓. Range is 0 to 9.

Example 3 — Larger Moduli

$ Input: remainders = [3,5,7], moduli = [4,9,11]

› Output: 139

💡 Note: System: x ≡ 3 (mod 4), x ≡ 5 (mod 9), x ≡ 7 (mod 11). Solution x=139 within range [0, 395]

Constraints

1 ≤ remainders.length = moduli.length ≤ 10
2 ≤ moduli[i] ≤ 100
0 ≤ remainders[i] < moduli[i]
All moduli are pairwise coprime (gcd(mᵢ, mⱼ) = 1 for i ≠ j)

Visualization

Tap to expand

Asked in

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

The Chinese Remainder Theorem provides an elegant solution to systems of simultaneous congruences. The key insight is using modular inverses and weighted combinations rather than brute force testing. Best approach uses the mathematical formula with time complexity O(k × log(max moduli)) and space O(k).

Common Approaches

✓ Brute Force Search

⏱️ Time: O(M × k) Space: O(1)

Check each possible value x from 0 to M-1 and see if it satisfies all congruences simultaneously. Return the first valid solution found.

Chinese Remainder Theorem Formula

⏱️ Time: O(k × log(max(moduli))) Space: O(k)

Apply the standard Chinese Remainder Theorem construction: compute partial products, find modular inverses using Extended Euclidean Algorithm, then combine weighted contributions.

Brute Force Search — Algorithm Steps

Calculate M = product of all moduli
For each x from 0 to M-1, check if x % moduli[i] == remainders[i] for all i
Return the first x that satisfies all congruences

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Range

M = 3×5×7 = 105, test x = 0 to 104

Test Each x

For x=23: 23%3=2✓, 23%5=3✓, 23%7=2✓

Found Solution

x=23 satisfies all congruences

Code -

solution.c — C

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

long long solution(int* remainders, int* moduli, int n) {
    if (remainders == NULL || moduli == NULL || n == 0) {
        return 0;
    }
    
    // Calculate product of all moduli
    long long M = 1;
    for (int i = 0; i < n; i++) {
        M *= moduli[i];
    }
    
    // Test each number from 0 to M-1
    for (long long x = 0; x < M; x++) {
        int valid = 1;
        for (int i = 0; i < n; i++) {
            if (x % moduli[i] != remainders[i]) {
                valid = 0;
                break;
            }
        }
        if (valid) {
            return x;
        }
    }
    
    return 0;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int remainders[100], moduli[100];
    int n = 0;
    
    // Simple parsing
    char *token = strtok(line1, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            remainders[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int m = 0;
    token = strtok(line2, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            moduli[m++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%lld\n", solution(remainders, moduli, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M × k)

M is product of moduli (can be huge), k checks per number

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for iteration and checking

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

324 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

Chinese Remainder Theorem Solver - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler