Problem Statement

Suppose

n

1

{\displaystyle n_{1}}

,

n

2

{\displaystyle n_{2}}

,

…

{\displaystyle \ldots }

,

n

k

{\displaystyle n_{k}}

are positive integers that are pairwise co-prime.   Then, for any given sequence of integers

a

1

{\displaystyle a_{1}}

,

a

2

{\displaystyle a_{2}}

,

…

{\displaystyle \dots }

,

a

k

{\displaystyle a_{k}}

,   there exists an integer

x

{\displaystyle x}

solving the following system of simultaneous congruences: Furthermore, all solutions

x

{\displaystyle x}

of this system are congruent modulo the product,

N

n

1

n

2

…

n

k

{\displaystyle N=n_{1}n_{2}\ldots n_{k}}

.

Write a program to solve a system of linear congruences by applying the   Chinese Remainder Theorem. If the system of equations cannot be solved, your program must somehow indicate this. (It may throw an exception or return a special false value.) Since there are infinitely many solutions, the program should return the unique solution

s

{\displaystyle s}

where

0 ≤ s ≤

n

1

n

2

…

n

k

{\displaystyle 0\leq s\leq n_{1}n_{2}\ldots n_{k}}

.

Show the functionality of this program by printing the result such that the

n

{\displaystyle n}

's   are

[ 3 , 5 , 7 ]

{\displaystyle [3,5,7]}

and the

a

{\displaystyle a}

's   are

[ 2 , 3 , 2 ]

{\displaystyle [2,3,2]}

.

Algorithm:   The following algorithm only applies if the

n

i

{\displaystyle n_{i}}

's   are pairwise co-prime. Suppose, as above, that a solution is required for the system of congruences: Again, to begin, the product

N

n

1

n

2

…

n

k

{\displaystyle N=n_{1}n_{2}\ldots n_{k}}

is defined. Then a solution

x

{\displaystyle x}

can be found as follows: For each

i

{\displaystyle i}

,   the integers

n

i

{\displaystyle n_{i}}

and

N

/

n

i

{\displaystyle N/n_{i}}

are co-prime. Using the   Extended Euclidean algorithm,   we can find integers

r

i

{\displaystyle r_{i}}

and

s

i

{\displaystyle s_{i}}

such that

r

i

n

i

s

i

N

/

n

i

= 1

{\displaystyle r_{i}n_{i}+s_{i}N/n_{i}=1}

. Then, one solution to the system of simultaneous congruences is: and the minimal solution,

Let's start with the solution:

program ChineseRemainderTheorem;

uses
  System.SysUtils, Velthuis.BigIntegers;

function mulInv(a, b: BigInteger): BigInteger;
var
  b0, x0, x1, q, amb, xqx: BigInteger;
begin
  b0 := b;
  x0 := 0;
  x1 := 1;

  if (b = 1) then
    exit(1);

  while (a > 1) do
  begin
    q := a div b;
    amb := a mod b;
    a := b;
    b := amb;
    xqx := x1 - q * x0;
    x1 := x0;
    x0 := xqx;
  end;

  if (x1 < 0) then
    x1 := x1 + b0;

  Result := x1;
end;

function chineseRemainder(n: TArray; a: TArray)
  : BigInteger;
var
  i: Integer;
  prod, p, sm: BigInteger;
begin
  prod := 1;

  for i := 0 to High(n) do
    prod := prod * n[i];

  p := 0;
  sm := 0;

  for i := 0 to High(n) do
  begin
    p := prod div n[i];
    sm := sm + a[i] * mulInv(p, n[i]) * p;
  end;
  Result := sm mod prod;
end;

var
  n, a: TArray;

begin
  n := [3, 5, 7];
  a := [2, 3, 2];

  Writeln(chineseRemainder(n, a).ToString);
end.