 Open in App
Not now

# Solve Linear Congruences Ax = B (mod N) for values of x in range [0, N-1]

• Difficulty Level : Medium
• Last Updated : 12 Jul, 2021

Given three positive integers A, B, and N, which represent a linear congruence of the form AX=B (mod N), the task is to print all possible values of X (mod N) i.e in the range [0, N-1] that satisfies this equation. If there is no solution, print -1.

Examples:

Input: A=15, B=9, N=18
Output: 15, 3, 9
Explanation: The values of X satisfying the condition AX=B (mod N) are {3, 9, 15}.
(15*15)%18 = 225%18=9
(3*15)%18 = 45%18=9
(9*15)%18 = 135%18=9

Input: A=9, B=21, N=30
Output: 9, 19, 20

Approach: The idea is based on the following observations:

• A solution exists if and only if B is divisible by GCD(A, N) i.e B%GCD(A, N)=0.
• The number of solutions for X (mod N) is GCD(A, N).

Proof:

1. Given, AX=B (mod N)
⇒ there exist a number Y such that AX=B+NY
AX-NY=B — (1)
This is a linear Diophantine equation, and is solvable if and only if GCD(A, N) divides B.
2. Now, using the Extended Euclidean Algorithm, u and v can be found such that Au+Nv=GCD(A, N)=d(say)
Au+Nv=d
Au=d (mod N) — (2)
3. Assuming B%d=0, so that solution of Equation 1 exists,
Multiplying both sides of Equation 2 by B/d, (possible since B/d is an integer),
Au*(B/d)=d*(B/d) (mod N) or A*(u*B/d)=B (mod N).
Thus, u*B/d is a solution of Equation 1.
4. Let X0 be u*B/d.
Thus, the d solutions of Equation 1 will be X0, X0+(N/d), X0+2*(N/d), …, X0+(d-1)*(N/d)

Follow the steps below to solve the problem:

• Initialize variable d as GCD(A, N) as well as u using the Extended Euclidean Algorithm.
• If B is not divisible by d, print -1 as the result.
• Else iterate in the range [0, d-1] using the variable i and in each iteration print the value of u*(B/d)+i*(N/d).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to stores the values of x and y` `// and find the value of gcd(a, b)` `long` `long` `ExtendedEuclidAlgo(` `    ``long` `long` `a, ``long` `long` `b,` `    ``long` `long``& x, ``long` `long``& y)` `{` `    ``// Base Case` `    ``if` `(b == 0) {` `        ``x = 1;` `        ``y = 0;` `        ``return` `a;` `    ``}` `    ``else` `{`   `        ``// Store the result of recursive call` `        ``long` `long` `x1, y1;` `        ``long` `long` `gcd` `            ``= ExtendedEuclidAlgo(b, a % b, x1, y1);`   `        ``// Update x and y using results of` `        ``// recursive call` `        ``x = y1;` `        ``y = x1 - ``floor``(a / b) * y1;`   `        ``return` `gcd;` `    ``}` `}`   `// Function to give the distinct` `// solutions of ax = b (mod n)` `void` `linearCongruence(``long` `long` `A,` `                      ``long` `long` `B,` `                      ``long` `long` `N)` `{` `    ``A = A % N;` `    ``B = B % N;`   `    ``long` `long` `u = 0, v = 0;`   `    ``// Function Call to find` `    ``// the value of d and u` `    ``long` `long` `d = ExtendedEuclidAlgo(A, N, u, v);`   `    ``// No solution exists` `    ``if` `(B % d != 0) {` `        ``cout << -1 << endl;` `        ``return``;` `    ``}`   `    ``// Else, initialize the value of x0` `    ``long` `long` `x0 = (u * (B / d)) % N;` `    ``if` `(x0 < 0)` `        ``x0 += N;`   `    ``// Print all the answers` `    ``for` `(``long` `long` `i = 0; i <= d - 1; i++)` `        ``cout << (x0 + i * (N / d)) % N << ``" "``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Input` `    ``long` `long` `A = 15;` `    ``long` `long` `B = 9;` `    ``long` `long` `N = 18;`   `    ``// Function Call` `    ``linearCongruence(A, B, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;`   `class` `GFG{` `    `  `// Function to stores the values of x and y` `// and find the value of gcd(a, b)` `public` `static` `long``[] ExtendedEuclidAlgo(``long` `a,` `                                        ``long` `b)` `{` `    `  `    ``// Base Case` `    ``if` `(a == ``0``) ` `    ``{` `        ``return` `new` `long``[]{b, ``0``, ``1``};` `    ``}` `    ``else` `    ``{` `        `  `        ``// Store the result of recursive call` `        ``long` `x1 = ``1``, y1 = ``1``;` `        ``long` `gcdy[] = ExtendedEuclidAlgo(b % a, a);` `        ``long` `gcd = gcdy[``0``];` `        ``x1 = gcdy[``1``];` `        ``y1 = gcdy[``2``];`   `        ``// Update x and y using results of` `        ``// recursive call` `        ``long` `y = x1;` `        ``long` `x = y1 - (``long``)Math.floor(b / a) * x1;`   `        ``return` `new` `long``[] {gcd, x, y};` `    ``}` `}`   `// Function to give the distinct` `// solutions of ax = b (mod n)` `public` `static` `void` `linearCongruence(``long` `A,` `                                    ``long` `B,` `                                    ``long` `N)` `{` `    ``A = A % N;` `    ``B = B % N;` `    `  `    ``long` `u = ``0``, v = ``0``;`   `    ``// Function Call to find` `    ``// the value of d and u` `    ``long` `person[] = ExtendedEuclidAlgo(A, N);` `    ``long` `d = person[``0``];` `    ``u = person[``1``];` `    ``v = person[``2``];`   `    ``// No solution exists` `    ``if` `(B % d != ``0``) ` `    ``{` `        ``System.out.println(-``1``);` `        ``return``;` `    ``}`   `    ``// Else, initialize the value of x0` `    ``long` `x0 = (u * (B / d)) % N;` `    ``if` `(x0 < ``0``)` `        ``x0 += N;` `    `  `    ``// Print all the answers` `    ``for``(``long` `i = ``0``; i <= d - ``1``; i++)` `    ``{` `        ``long` `an = (x0 + i * (N / d)) % N;` `        ``System.out.print(an + ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `    `  `    ``// Input` `    ``long` `A = ``15``;` `    ``long` `B = ``9``;` `    ``long` `N = ``18``;`   `    ``// Function Call` `    ``linearCongruence(A, B, N);` `}` `}`   `// This code is contributed by Shubhamsingh10`

## Python3

 `# Python3 program for the above approach`   `# Function to stores the values of x and y` `# and find the value of gcd(a, b)` `def` `ExtendedEuclidAlgo(a, b):` `    `  `    ``# Base Case` `    ``if` `a ``=``=` `0` `: ` `        ``return` `b, ``0``, ``1` `        `  `    ``gcd, x1, y1 ``=` `ExtendedEuclidAlgo(b ``%` `a, a)` `    `  `    ``# Update x and y using results of recursive` `    ``# call` `    ``x ``=` `y1 ``-` `(b ``/``/` `a) ``*` `x1` `    ``y ``=` `x1` `    `  `    ``return` `gcd, x, y` `    `  `# Function to give the distinct` `# solutions of ax = b (mod n)` `def` `linearCongruence(A, B, N):` `    `  `    ``A ``=` `A ``%` `N` `    ``B ``=` `B ``%` `N` `    ``u ``=` `0` `    ``v ``=` `0` `    `  `    ``# Function Call to find` `    ``# the value of d and u` `    ``d, u, v ``=` `ExtendedEuclidAlgo(A, N)` `    `  `    ``# No solution exists` `    ``if` `(B ``%` `d !``=` `0``):` `        ``print``(``-``1``)` `        ``return` `    `  `    ``# Else, initialize the value of x0` `    ``x0 ``=` `(u ``*` `(B ``/``/` `d)) ``%` `N` `    ``if` `(x0 < ``0``):` `        ``x0 ``+``=` `N` `    `  `    ``# Pr all the answers` `    ``for` `i ``in` `range``(d):` `        ``print``((x0 ``+` `i ``*` `(N ``/``/` `d)) ``%` `N, end ``=` `" "``)`   `# Driver Code`   `# Input` `A ``=` `15` `B ``=` `9` `N ``=` `18`   `# Function Call` `linearCongruence(A, B, N)`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{` `    `  `    ``// Function to stores the values of x and y` `    ``// and find the value of gcd(a, b)` `    ``public` `static` `long``[] ExtendedEuclidAlgo(``long` `a,` `                                            ``long` `b)` `    ``{` `        `  `        ``// Base Case` `        ``if` `(a == 0) ` `        ``{` `            ``return` `new` `long``[]{b, 0, 1};` `        ``}` `        ``else` `        ``{` `            `  `            ``// Store the result of recursive call` `            ``long` `x1 = 1, y1 = 1;` `            ``long``[] gcdy = ExtendedEuclidAlgo(b % a, a);` `            ``long` `gcd = gcdy;` `            ``x1 = gcdy;` `            ``y1 = gcdy;` `    `  `            ``// Update x and y using results of` `            ``// recursive call` `            ``long` `y = x1;` `            ``long` `x = y1 - (``long``)(b / a) * x1;` `    `  `            ``return` `new` `long``[] {gcd, x, y};` `        ``}` `    ``}` `    `  `    ``// Function to give the distinct` `    ``// solutions of ax = b (mod n)` `    ``public` `static` `void` `linearCongruence(``long` `A,` `                                        ``long` `B,` `                                        ``long` `N)` `    ``{` `        ``A = A % N;` `        ``B = B % N;` `        `  `        ``long` `u = 0, v = 0;` `    `  `        ``// Function Call to find` `        ``// the value of d and u` `        ``long` `[]person = ExtendedEuclidAlgo(A, N);` `        ``long` `d = person;` `        ``u = person;` `        ``v = person;` `    `  `        ``// No solution exists` `        ``if` `(B % d != 0) ` `        ``{` `            ``Console.WriteLine(-1);` `            ``return``;` `        ``}` `    `  `        ``// Else, initialize the value of x0` `        ``long` `x0 = (u * (B / d)) % N;` `        ``if` `(x0 < 0)` `            ``x0 += N;` `        `  `        ``// Print all the answers` `        ``for``(``long` `i = 0; i <= d - 1; i++)` `        ``{` `            ``long` `an = (x0 + i * (N / d)) % N;` `            ``Console.Write(an + ``" "``);` `        ``}` `    ``}`   `// Driver Code` `    ``static` `public` `void` `Main (){` `        `  `        ``// Input` `        ``long` `A = 15;` `        ``long` `B = 9;` `        ``long` `N = 18;` `    `  `        ``// Function Call` `        ``linearCongruence(A, B, N);` `    ``}` `}`   `// This code is contributed by Shubhamsingh10`

## Javascript

 ``

Output

`15 3 9 `

Time Complexity: O(log(min(A, N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles