Merge pull request #227 from Priyangshuyogi/myone

Chinese Remainder Theorem in cpp

Author: prateekiiest

Competitive Coding/Math/Chinese Remainder Theorem/Modular multiplicative inverse.md

@@ -0,0 +1,29 @@
+Given two integers ‘a’ and ‘m’, find modular multiplicative inverse of ‘a’ under modulo ‘m’.
+
+The modular multiplicative inverse is an integer ‘x’ such that.
+
+ a x ≡ 1 (mod m) 
+ 
+The value of x should be in {0, 1, 2, … m-1}, i.e., in the ring of integer modulo m.
+
+The multiplicative inverse of “a modulo m” exists if and only if a and m are relatively prime (i.e., if gcd(a, m) = 1).
+
+Examples:
+
+Input:  a = 3, m = 11
+
+Output: 4
+
+Since (4x3) mod 11 = 1, 
+4 is modulo inverse of 3
+
+One might think, 15 also as a valid output as "(15x3) mod 11" 
+is also 1, but 15 is not in ring {0, 1, 2, ... 10}, so not 
+valid.
+
+Input:  a = 10, m = 17
+
+Output: 12
+
+Since (10x12) mod 17 = 1, 12 is modulo inverse of 3
+

Competitive Coding/Math/Chinese Remainder Theorem/README.md

@@ -0,0 +1,87 @@
+The Chinese remainder theorem is a theorem of number theory, which states that if one knows the remainders of the Euclidean division of an 
+integer n by several integers, then one can determine uniquely the remainder of the division of n by the product of these integers, under 
+the condition that the divisors are pairwise coprime.
+SAY.........
+We are given two arrays num[0..k-1] and rem[0..k-1].
+In num[0..k-1], every pair is coprime (gcd for every pair is 1).We need to find minimum positive number x such that:
+
+     x % num[0]    =  rem[0], 
+     x % num[1]    =  rem[1], 
+     .......................
+     x % num[k-1]  =  rem[k-1] 
+     
+Basically, we are given k numbers which are pairwise coprime, and given remainders of these numbers when an unknown number x is divided
+by them. We need to find the minimum possible value of x that produces given remainders.
+
+Examples:
+
+Input:  num[] = {5, 7}, rem[] = {1, 3}
+
+Output: 31
+
+Explanation: 
+
+31 is the smallest number such that:
+
+  (1) When we divide it by 5, we get remainder 1. 
+  
+  (2) When we divide it by 7, we get remainder 3.
+
+Input:  num[] = {3, 4, 5}, rem[] = {2, 3, 1}
+
+Output: 11
+
+Explanation:
+
+11 is the smallest number such that:
+
+  (1) When we divide it by 3, we get remainder 2. 
+  
+  (2) When we divide it by 4, we get remainder 3.
+  
+  (3) When we divide it by 5, we get remainder 1.
+  
+ //////// The solution is based on below formula.\\\\\\\\\\\\
+
+
+x =  ( ∑ (rem[i]*pp[i]*inv[i]) ) % prod
+   Where 0 <= i <= n-1
+
+rem[i] is given array of remainders
+
+prod is product of all given numbers
+prod = num[0] * num[1] * ... * num[k-1]
+
+pp[i] is product of all but num[i]
+pp[i] = prod / num[i]
+
+inv[i] = Modular Multiplicative Inverse of pp[i] with respect to num[i]
+
+/// I have explained the Modular multiplicative inverse method by Extended Euclidean algorithms in another file
+(Named : Modular multiplicative inverse).///
+
+///////WORKING PROCESS\\\\\\\
+
+Example:
+
+Let us take below example to understand the solution
+
+   num[] = {3, 4, 5}
+   
+   rem[] = {2, 3, 1}
+   
+   prod  = 60 
+   
+   pp[]  = {20, 15, 12}
+   
+   inv[] = {2,  3,  3}  { (20X2)%3 = 1, (15X3)%4 = 1
+                          (12X3)%5 = 1}
+
+   x = (rem[0]*pp[0]*inv[0] + rem[1]*pp[1]*inv[1] + rem[2]*pp[2]*inv[2]) % prod
+   
+     = (2*20*2 + 3*15*3 + 1*12*3) % 60
+     
+     = (40 + 135 + 36) % 60
+     
+     = 11
+     

Competitive Coding/Math/Chinese Remainder Theorem/code.cpp

@@ -0,0 +1,83 @@
+Below is C++ implementation of above formula. We can use Extended Euclid based method(Described in the folder) discussed here to find inverse modulo.
+
+// A C++ program to demonstrate working of Chinise remainder Theorem
+
+// Returns modulo inverse of a with respect to m using extended Euclid Algorithm.  
+
+#include<bits/stdc++.h>
+using namespace std;
+int inv(int a, int m)
+{
+    int m0 = m, t, q;
+    int x0 = 0, x1 = 1;
+ 
+    if (m == 1)
+       return 0;
+ 
+    // Application of extended Euclid Algorithm
+    while (a > 1)
+    {
+        // q is quotient
+        q = a / m;
+ 
+        t = m;
+ 
+        // m is remainder
+        m = a % m, a = t;
+ 
+        t = x0;
+ 
+        x0 = x1 - q * x0;
+ 
+        x1 = t;
+    }
+ 
+    // Make x1 positive
+    if (x1 < 0)
+       x1 += m0;
+ 
+    return x1;
+}
+ 
+// k is size of num[] and rem[].  Returns the smallest
+// number x such that:
+//  x % num[0] = rem[0],
+//  x % num[1] = rem[1],
+//  ..................
+//  x % num[k-2] = rem[k-1]
+// Assumption: Numbers in num[] are pairwise coprime i.e(gcd for every pair is 1)
+
+int findMinX(int num[], int rem[], int k)
+{
+    // Compute product of all numbers
+    int prod = 1;
+    for (int i = 0; i < k; i++)
+        prod *= num[i];
+ 
+    // Initialize result
+    int result = 0;
+ 
+    // Apply above formula
+    for (int i = 0; i < k; i++)
+    {
+        int pp = prod / num[i];
+        result += rem[i] * inv(pp, num[i]) * pp;
+    }
+ 
+    return result % prod;
+}
+ 
+// Main method
+
+int main(void)
+{
+    int num[] = {3, 4, 5};
+    int rem[] = {2, 3, 1};
+    int k = sizeof(num)/sizeof(num[0]);
+    cout << "x is " << findMinX(num, rem, k);
+    return 0;
+}
+
+Output:
+
+x is 11

Competitive Coding/Math/Chinese Remainder Theorem/code_MMI.cpp

@@ -0,0 +1,50 @@
+// Iterative C++ program to find modular inverse using extended Euclid algorithm.
+// Returns modulo inverse of a with respect to m using extended Euclid Algorithm.
+//Time Complexity of this method is O(Log m).
+// Assumption: a and m are coprimes, i.e., gcd(a, m) = 1
+
+#include <stdio.h>
+int modInverse(int a, int m)
+{
+    int m0 = m, t, q;
+    int x0 = 0, x1 = 1;
+ 
+    if (m == 1)
+      return 0;
+ 
+    while (a > 1)
+    {
+        // q is quotient
+        q = a / m;
+ 
+        t = m;
+ 
+        // m is remainder
+        m = a % m, a = t;
+ 
+        t = x0;
+ 
+        x0 = x1 - q * x0;
+ 
+        x1 = t;
+    }
+ 
+    // Make x1 positive
+    if (x1 < 0)
+       x1 += m0;
+ 
+    return x1;
+}
+ 
+// Main method
+int main()
+{
+    int a = 3, m = 11;
+ 
+    printf("Modular multiplicative inverse is %d\n",
+          modInverse(a, m));
+    return 0;
+}
+
+Output:
+Modular multiplicative inverse is 4.