Related Articles

# Smallest value of X satisfying the condition X % A[i] = B[i] for two given arrays

• Last Updated : 17 Jul, 2021

Given two arrays A[] and B[], both consisting of N positive integers, an integer P and the elements of the array A[] are pairwise co-prime, the task is to find the smallest integer X which is at least P and X % A[i] is equal to B[i] for all i over the range of indices [0, N – 1].

Examples:

Input: A[] = {3, 4, 5}, B[] = {2, 3, 1}, P = 72
Output: 131
Explanation:
Consider the following operations for the value of X as 131.

• X % A = 131 % 3 = 2 (= B)
• X % A = 131 % 4 = 3 (= B)
• X % A = 131 % 5 = 1 (= B)

Therefore, 131 is the smallest integer which is at least P( = 72).

Input: A[] = {5, 7}, B[] = {1, 3}, P = 0
Output: 31

Approach: The idea to solve the given problem is to use the Chinese Remainder Theorem. Follow the steps below to solve the given problem:

• Calculate the LCM of the array A[], which is equal to the product of all elements present in the array A[], say M, since all the elements are co-prime.
• Using Chinese Remainder Theorem, find the required smallest positive integer Y. Therefore, the value of X is given by (Y + K * M) for some integer K, that satisfies X % A[i] = B[i] for all i over the range of indices [0, N – 1].
• The value of K can be found from the equation Y + K * M >= P, which equates to K >= (P – Y)/M.
• Therefore, the required smallest possible integer X is (Y + K * M).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Function to calculate modulo``// inverse of a w.r.t m using``// Extended Euclid Algorithm``int` `inv(``int` `a, ``int` `m)``{``    ``int` `m0 = m, t, q;``    ``int` `x0 = 0, x1 = 1;` `    ``// Base Case``    ``if` `(m == 1)``        ``return` `0;` `    ``// Perform extended``    ``// euclid algorithm``    ``while` `(a > 1)``    ``{``        ``// q is quotient``        ``q = a / m;` `        ``t = m;` `        ``// m is remainder now,``        ``// process same as``        ``// euclid's algorithm``        ``m = a % m;``        ``a = t;` `        ``t = x0;``        ``x0 = x1 - q * x0;``        ``x1 = t;``    ``}` `    ``// If x1 is negative``    ``if` `(x1 < 0)` `        ``// Make x1 positive``        ``x1 += m0;` `    ``return` `x1;``}` `// Function to implement Chinese``// Remainder Theorem to find X``int` `findMinX(``int` `A[], ``int` `B[], ``int` `N)``{``    ` `    ``// Stores the product``    ``// of array elements``    ``int` `prod = 1;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)` `        ``// Update product``        ``prod *= A[i];` `    ``// Initialize the result``    ``int` `result = 0;` `    ``// Apply the above formula``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``int` `pp = prod / A[i];``        ``result += B[i] * inv(pp, A[i]) * pp;``    ``}``    ``return` `result % prod;``}` `// Function to calculate the product``// of all elements of the array a[]``int` `product(``int` `a[], ``int` `n)``{``    ` `    ``// Stores product of``    ``// all array elements``    ``int` `ans = 1;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``ans *= a[i];``    ``}` `    ``// Return the product``    ``return` `ans;``}` `// Function to find the value of X``// that satisfies the given condition``void` `findSmallestInteger(``int` `A[], ``int` `B[],``                         ``int` `P, ``int` `n)``{``    ` `    ``// Stores the required smallest value``    ``// using Chinese Remainder Theorem``    ``int` `Y = findMinX(A, B, n);` `    ``// Stores the product``    ``// of all array elements``    ``int` `M = product(A,n);` `    ``// The equation is Y + K*M >= P``    ``// Therefore, calculate K = ceil((P-Y)/M)``    ``int` `K = ``ceil``(((``double``)P - (``double``)Y) /``                  ``(``double``)M);` `    ``// So, X = Y + K*M``    ``int` `X = Y + K * M;` `    ``// Print the resultant value of X``    ``cout << X;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 3, 4, 5 };``    ``int` `B[] = { 2, 3, 1 };``    ``int` `n = ``sizeof``(A) / ``sizeof``(A);``    ``int` `P = 72;` `    ``findSmallestInteger(A, B, P,n);``}` `// This code is contributed by SURENDRA_GANGWAR`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;``public` `class` `Main {` `    ``// Function to calculate modulo``    ``// inverse of a w.r.t m using``    ``// Extended Euclid Algorithm``    ``static` `int` `inv(``int` `a, ``int` `m)``    ``{``        ``int` `m0 = m, t, q;``        ``int` `x0 = ``0``, x1 = ``1``;` `        ``// Base Case``        ``if` `(m == ``1``)``            ``return` `0``;` `        ``// Perform extended``        ``// euclid algorithm``        ``while` `(a > ``1``) {` `            ``// q is quotient``            ``q = a / m;` `            ``t = m;` `            ``// m is remainder now,``            ``// process same as``            ``// euclid's algorithm``            ``m = a % m;``            ``a = t;` `            ``t = x0;` `            ``x0 = x1 - q * x0;` `            ``x1 = t;``        ``}` `        ``// If x1 is negative``        ``if` `(x1 < ``0``)` `            ``// Make x1 positive``            ``x1 += m0;` `        ``return` `x1;``    ``}` `    ``// Function to implement Chinese``    ``// Remainder Theorem to find X``    ``static` `int` `findMinX(``int` `A[], ``int` `B[], ``int` `N)``    ``{``        ``// Stores the product``        ``// of array elements``        ``int` `prod = ``1``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < N; i++)` `            ``// Update product``            ``prod *= A[i];` `        ``// Initialize the result``        ``int` `result = ``0``;` `        ``// Apply the above formula``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``int` `pp = prod / A[i];``            ``result += B[i] * inv(pp, A[i]) * pp;``        ``}` `        ``return` `result % prod;``    ``}` `    ``// Function to calculate the product``    ``// of all elements of the array a[]``    ``static` `int` `product(``int` `a[])``    ``{``        ``// Stores product of``        ``// all array elements``        ``int` `ans = ``1``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < a.length; i++) {``            ``ans *= a[i];``        ``}` `        ``// Return the product``        ``return` `ans;``    ``}` `    ``// Function to find the value of X``    ``// that satisfies the given condition``    ``public` `static` `void` `findSmallestInteger(``int` `A[], ``int` `B[],``                                           ``int` `P)``    ``{``        ``// Stores the required smallest value``        ``// using Chinese Remainder Theorem``        ``int` `Y = findMinX(A, B, A.length);` `        ``// Stores the product``        ``// of all array elements``        ``int` `M = product(A);` `        ``// The equation is Y + K*M >= P``        ``// Therefore, calculate K = ceil((P-Y)/M)``        ``int` `K = (``int``)Math.ceil(((``double``)P - (``double``)Y)``                               ``/ (``double``)M);` `        ``// So, X = Y + K*M``        ``int` `X = Y + K * M;` `        ``// Print the resultant value of X``        ``System.out.println(X);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = { ``3``, ``4``, ``5` `};``        ``int` `B[] = { ``2``, ``3``, ``1` `};` `        ``int` `P = ``72``;` `        ``findSmallestInteger(A, B, P);``    ``}``}`

## Python3

 `# Python3 program for the above approach``import` `math` `# Function to calculate modulo``# inverse of a w.r.t m using``# Extended Euclid Algorithm``def` `inv(a, m):``    ` `    ``m0 ``=` `m``    ``x0 ``=` `0``    ``x1 ``=` `1` `    ``# Base Case``    ``if` `(m ``=``=` `1``):``        ``return` `0` `    ``# Perform extended``    ``# euclid algorithm``    ``while` `(a > ``1``):``        ` `        ``# q is quotient``        ``q ``=` `a ``/``/` `m` `        ``t ``=` `m` `        ``# m is remainder now,``        ``# process same as``        ``# euclid's algorithm``        ``m ``=` `a ``%` `m``        ``a ``=` `t` `        ``t ``=` `x0``        ``x0 ``=` `x1 ``-` `q ``*` `x0``        ``x1 ``=` `t` `    ``# If x1 is negative``    ``if` `(x1 < ``0``):` `        ``# Make x1 positive``        ``x1 ``+``=` `m0` `    ``return` `x1` `# Function to implement Chinese``# Remainder Theorem to find X``def` `findMinX(A, B, N):``    ` `    ``# Stores the product``    ``# of array elements``    ``prod ``=` `1` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# Update product``        ``prod ``*``=` `A[i]` `    ``# Initialize the result``    ``result ``=` `0` `    ``# Apply the above formula``    ``for` `i ``in` `range``(N):``        ``pp ``=` `prod ``/``/` `A[i]``        ``result ``+``=` `B[i] ``*` `inv(pp, A[i]) ``*` `pp``        ` `    ``return` `result ``%` `prod` `# Function to calculate the product``# of all elements of the array a[]``def` `product(a, n):``    ` `    ``# Stores product of``    ``# all array elements``    ``ans ``=` `1` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ``ans ``*``=` `a[i]` `    ``# Return the product``    ``return` `ans` `# Function to find the value of X``# that satisfies the given condition``def` `findSmallestInteger(A, B, P, n):``    ` `    ``# Stores the required smallest value``    ``# using Chinese Remainder Theorem``    ``Y ``=` `findMinX(A, B, n)` `    ``# Stores the product``    ``# of all array elements``    ``M ``=` `product(A, n)` `    ``# The equation is Y + K*M >= P``    ``# Therefore, calculate K = ceil((P-Y)/M)``    ``K ``=` `math.ceil((P ``-` `Y) ``/` `M)` `    ``# So, X = Y + K*M``    ``X ``=` `Y ``+` `K ``*` `M` `    ``# Print the resultant value of X``    ``print``(X)` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``A ``=` `[ ``3``, ``4``, ``5` `]``    ``B ``=` `[ ``2``, ``3``, ``1` `]``    ``n ``=` `len``(A)``    ``P ``=` `72` `    ``findSmallestInteger(A, B, P, n)` `# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `  ``// Function to calculate modulo``  ``// inverse of a w.r.t m using``  ``// Extended Euclid Algorithm``  ``static` `int` `inv(``int` `a, ``int` `m)``  ``{``    ``int` `m0 = m, t, q;``    ``int` `x0 = 0, x1 = 1;` `    ``// Base Case``    ``if` `(m == 1)``      ``return` `0;` `    ``// Perform extended``    ``// euclid algorithm``    ``while` `(a > 1) {` `      ``// q is quotient``      ``q = a / m;` `      ``t = m;` `      ``// m is remainder now,``      ``// process same as``      ``// euclid's algorithm``      ``m = a % m;``      ``a = t;` `      ``t = x0;` `      ``x0 = x1 - q * x0;` `      ``x1 = t;``    ``}` `    ``// If x1 is negative``    ``if` `(x1 < 0)` `      ``// Make x1 positive``      ``x1 += m0;` `    ``return` `x1;``  ``}` `  ``// Function to implement Chinese``  ``// Remainder Theorem to find X``  ``static` `int` `findMinX(``int``[] A, ``int``[] B, ``int` `N)``  ``{``    ``// Stores the product``    ``// of array elements``    ``int` `prod = 1;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++)` `      ``// Update product``      ``prod *= A[i];` `    ``// Initialize the result``    ``int` `result = 0;` `    ``// Apply the above formula``    ``for` `(``int` `i = 0; i < N; i++) {``      ``int` `pp = prod / A[i];``      ``result += B[i] * inv(pp, A[i]) * pp;``    ``}` `    ``return` `result % prod;``  ``}` `  ``// Function to calculate the product``  ``// of all elements of the array a[]``  ``static` `int` `product(``int``[] a)``  ``{``    ``// Stores product of``    ``// all array elements``    ``int` `ans = 1;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < a.Length; i++) {``      ``ans *= a[i];``    ``}` `    ``// Return the product``    ``return` `ans;``  ``}` `  ``// Function to find the value of X``  ``// that satisfies the given condition``  ``public` `static` `void` `findSmallestInteger(``int``[] A, ``int``[] B,``                                         ``int` `P)``  ``{``    ``// Stores the required smallest value``    ``// using Chinese Remainder Theorem``    ``int` `Y = findMinX(A, B, A.Length);` `    ``// Stores the product``    ``// of all array elements``    ``int` `M = product(A);` `    ``// The equation is Y + K*M >= P``    ``// Therefore, calculate K = ceil((P-Y)/M)``    ``int` `K = (``int``)Math.Ceiling(((``double``)P - (``double``)Y)``                              ``/ (``double``)M);` `    ``// So, X = Y + K*M``    ``int` `X = Y + K * M;` `    ``// Print the resultant value of X``    ``Console.WriteLine(X);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] A = { 3, 4, 5 };``    ``int``[] B = { 2, 3, 1 };` `    ``int` `P = 72;` `    ``findSmallestInteger(A, B, P);``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`131`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up