Given two integers A and B where A is not divisible by B, the task is to express A / B as a natural number modulo m where m = 1000000007.
Note: This representation is useful where we need to express Probability of an event, Area of Curves and polygons etc.
Examples:
Input: A = 2, B = 6
Output: 333333336
Input: A = 4, B = 5
Output: 600000005
Approach: We know that, A / B can be written as A * (1 / B) i.e. A * (B ^ -1).
It is known that the modulo(%) operator satisfies the relation:
(a * b) % m = ( (a % m) * (b % m) ) % m
So, we can write:
(b ^ -1) % m = (b ^ m-2) % m (Fermat's little theorem)
Therefore the result will be:
( (A mod m) * ( power(B, m-2) % m) ) % m
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
#define ll long long int #define m 1000000007 // Function to return the GCD of given numbers int gcd( int a, int b)
{ if (a == 0)
return b;
return gcd(b % a, a);
} // Recursive function to return (x ^ n) % m ll modexp(ll x, ll n) { if (n == 0) {
return 1;
}
else if (n % 2 == 0) {
return modexp((x * x) % m, n / 2);
}
else {
return (x * modexp((x * x) % m, (n - 1) / 2) % m);
}
} // Function to return the fraction modulo mod ll getFractionModulo(ll a, ll b) { ll c = gcd(a, b);
a = a / c;
b = b / c;
// (b ^ m-2) % m
ll d = modexp(b, m - 2);
// Final answer
ll ans = ((a % m) * (d % m)) % m;
return ans;
} // Driver code int main()
{ ll a = 2, b = 6;
cout << getFractionModulo(a, b) << endl;
return 0;
} |
// Java implementation of the approach import java.io.*;
class GFG {
static long m = 1000000007 ;
// Function to return the GCD of given numbers static long gcd( long a, long b)
{ if (a == 0 )
return b;
return gcd(b % a, a);
} // Recursive function to return (x ^ n) % m static long modexp( long x, long n)
{ if (n == 0 ) {
return 1 ;
}
else if (n % 2 == 0 ) {
return modexp((x * x) % m, n / 2 );
}
else {
return (x * modexp((x * x) % m, (n - 1 ) / 2 ) % m);
}
} // Function to return the fraction modulo mod static long getFractionModulo( long a, long b)
{ long c = gcd(a, b);
a = a / c;
b = b / c;
// (b ^ m-2) % m
long d = modexp(b, m - 2 );
// Final answer
long ans = ((a % m) * (d % m)) % m;
return ans;
} // Driver code public static void main (String[] args) {
long a = 2 , b = 6 ;
System.out.println(getFractionModulo(a, b));
}
} // This code is contributed by inder_verma |
# Python3 implementation of the approach m = 1000000007
# Function to return the GCD # of given numbers def gcd(a, b):
if (a = = 0 ):
return b
return gcd(b % a, a)
# Recursive function to return (x ^ n) % m def modexp(x, n):
if (n = = 0 ) :
return 1
elif (n % 2 = = 0 ) :
return modexp((x * x) % m, n / / 2 )
else :
return (x * modexp((x * x) % m,
(n - 1 ) / 2 ) % m)
# Function to return the fraction modulo mod def getFractionModulo(a, b):
c = gcd(a, b)
a = a / / c
b = b / / c
# (b ^ m-2) % m
d = modexp(b, m - 2 )
# Final answer
ans = ((a % m) * (d % m)) % m
return ans
# Driver code if __name__ = = "__main__" :
a = 2
b = 6
print ( getFractionModulo(a, b))
# This code is contributed by ita_c |
//C# implementation of the approach using System;
public class GFG{
static long m = 1000000007;
// Function to return the GCD of given numbers static long gcd( long a, long b)
{ if (a == 0)
return b;
return gcd(b % a, a);
} // Recursive function to return (x ^ n) % m static long modexp( long x, long n)
{ if (n == 0) {
return 1;
}
else if (n % 2 == 0) {
return modexp((x * x) % m, n / 2);
}
else {
return (x * modexp((x * x) % m, (n - 1) / 2) % m);
}
} // Function to return the fraction modulo mod static long getFractionModulo( long a, long b)
{ long c = gcd(a, b);
a = a / c;
b = b / c;
// (b ^ m-2) % m
long d = modexp(b, m - 2);
// Final answer
long ans = ((a % m) * (d % m)) % m;
return ans;
} // Driver code static public void Main (){
long a = 2, b = 6;
Console.WriteLine(getFractionModulo(a, b));
}
} |
<script> // javascript implementation of the approach var m = 100000007;
// Function to return the GCD of given numbers
function gcd(a , b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
// Recursive function to return (x ^ n) % m
function modexp(x , n) {
if (n == 0) {
return 1;
} else if (n % 2 == 0) {
return modexp((x * x) % m, n / 2);
} else {
return (x * modexp((x * x) % m, (n - 1) / 2) % m);
}
}
// Function to return the fraction modulo mod
function getFractionModulo(a , b) {
var c = gcd(a, b);
a = a / c;
b = b / c;
// (b ^ m-2) % m
var d = modexp(b, m - 2);
// Final answer
var ans = ((a % m) * (d % m)) % m;
return ans;
}
// Driver code
var a = 2, b = 6;
document.write(getFractionModulo(a, b));
// This code is contributed by umadevi9616 </script> |
<?php // PHP implementation of the approach // Function to return the GCD of // given numbers function abc( $a , $b )
{ if ( $a == 0)
return $b ;
return abc( $b % $a , $a );
} // Recursive function to return (x ^ n) % m function modexp( $x , $n )
{ $m = 1000000007;
if ( $n == 0)
{
return 1;
}
else if ( $n % 2 == 0)
{
return modexp(( $x * $x ) % $m , $n / 2);
}
else
{
return ( $x * modexp(( $x * $x ) % $m ,
( $n - 1) / 2) % $m );
}
} // Function to return the fraction // modulo mod function getFractionModulo( $a , $b )
{ $m = 1000000007;
$c = abc( $a , $b );
$a = $a / $c ;
$b = $b / $c ;
// (b ^ m-2) % m
$d = modexp( $b , $m - 2);
// Final answer
$ans = (( $a % $m ) * ( $d % $m )) % $m ;
return $ans ;
} // Driver code $a = 2;
$b = 6;
echo (getFractionModulo( $a , $b )) ;
// This code is contributed // by Shivi_Aggarwal ?> |
333333336
Time Complexity: O(log(min(a, b) + logm)
Auxiliary Space: O(log(min(a, b) + logm)
Approach#2: Using fermat’s little
This approach computes the value of (A/B) % m using Fermat’s Little Theorem to calculate the modular inverse of B.
Algorithm
1. Define a function inverse_modulo(a, m) to compute the inverse of a modulo m using Fermat’s Little Theorem.
2. Define a function fraction_to_natural_modulo(A, B, m) to compute the value of (A/B) % m, where A, B, and m are given integers.
3. Inside the fraction_to_natural_modulo function, calculate the inverse of B modulo m using the inverse_modulo function.
4. Multiply A and the inverse of B modulo m, and take modulo m to get the result.
5. Return the result
#include <iostream> using namespace std;
// Function to compute modular exponentiation (a^b % mod) long long power( long long base, long long exp , long long mod) {
if ( exp == 0) return 1;
if ( exp % 2 == 0) {
long long half_pow = power(base, exp / 2, mod);
return (half_pow * half_pow) % mod;
} else {
return (base * power(base, exp - 1, mod)) % mod;
}
} // Function to compute the modular inverse of 'a' modulo 'm' using Fermat's Little Theorem long long inverse_modulo( long long a, long long m) {
return power(a, m - 2, m);
} // Function to compute the value of (A/B) % m, where A, B, and m are given integers long long fraction_to_natural_modulo( long long A, long long B, long long m) {
// Calculate the modular inverse of B
long long inverse_B = inverse_modulo(B, m);
// Compute (A * inverse_B) % m
long long result = (A * inverse_B) % m;
return result;
} int main() {
long long A = 2;
long long B = 6;
long long m = 1000000007;
long long natural_number = fraction_to_natural_modulo(A, B, m);
// Print the result
cout << natural_number << endl;
return 0;
} |
public class Main {
// Function to compute modular exponentiation (a^b % mod)
static long power( long base, long exp, long mod) {
if (exp == 0 ) return 1 ;
if (exp % 2 == 0 ) {
long halfPow = power(base, exp / 2 , mod);
return (halfPow * halfPow) % mod;
} else {
return (base * power(base, exp - 1 , mod)) % mod;
}
}
// Function to compute the modular inverse of 'a' modulo 'm' using Fermat's Little Theorem
static long inverseModulo( long a, long m) {
return power(a, m - 2 , m);
}
// Function to compute the value of (A/B) % m, where A, B, and m are given integers
static long fractionToNaturalModulo( long A, long B, long m) {
// Calculate the modular inverse of B
long inverseB = inverseModulo(B, m);
// Compute (A * inverseB) % m
long result = (A * inverseB) % m;
return result;
}
public static void main(String[] args) {
long A = 2 ;
long B = 6 ;
long m = 1000000007 ;
long naturalNumber = fractionToNaturalModulo(A, B, m);
// Print the result
System.out.println(naturalNumber);
}
} // This code is contributed by akshitaguprzj3 |
def inverse_modulo(a, m):
"""
Computes the inverse of a modulo m using Fermat's Little Theorem
"""
return pow (a, m - 2 , m)
def fraction_to_natural_modulo(A, B, m):
"""
Computes the value of (A/B) % m, where A, B and m are given integers
"""
inverse_B = inverse_modulo(B, m)
result = (A * inverse_B) % m
return result
# Example usage A = 2
B = 6
m = 1000000007
natural_number = fraction_to_natural_modulo(A, B, m)
print (natural_number)
|
using System;
class Program
{ // Function to compute modular exponentiation (a^b % mod)
static long Power( long baseNum, long exp, long mod)
{
if (exp == 0) return 1;
if (exp % 2 == 0)
{
long halfPow = Power(baseNum, exp / 2, mod);
return (halfPow * halfPow) % mod;
}
else
{
return (baseNum * Power(baseNum, exp - 1, mod)) % mod;
}
}
// Function to compute the modular inverse of 'a' modulo 'm' using Fermat's Little Theorem
static long InverseModulo( long a, long m)
{
return Power(a, m - 2, m);
}
// Function to compute the value of (A/B) % m, where A, B, and m are given integers
static long FractionToNaturalModulo( long A, long B, long m)
{
// Calculate the modular inverse of B
long inverseB = InverseModulo(B, m);
// Compute (A * inverseB) % m
long result = (A * inverseB) % m;
return result;
}
static void Main( string [] args)
{
long A = 2;
long B = 6;
long m = 1000000007;
long naturalNumber = FractionToNaturalModulo(A, B, m);
// Print the result
Console.WriteLine(naturalNumber);
}
} |
// Function to compute modular exponentiation (a^b % mod) function power(base, exp, mod) {
if (exp === 0) return 1;
if (exp % 2 === 0) {
let halfPow = power(base, exp / 2, mod);
return (halfPow * halfPow) % mod;
} else {
return (base * power(base, exp - 1, mod)) % mod;
}
} // Function to compute the modular inverse of 'a' modulo 'm' using the Extended Euclidean Algorithm function extendedGCD(a, b) {
if (a === 0) {
return [b, 0, 1];
} else {
let [gcd, x1, y1] = extendedGCD(b % a, a);
let x = y1 - Math.floor(b / a) * x1;
let y = x1;
return [gcd, x, y];
}
} function inverseModulo(a, m) {
let [gcd, x, y] = extendedGCD(a, m);
if (gcd !== 1) {
// Modular inverse does not exist
return null ;
} else {
return (x % m + m) % m;
}
} // Function to compute the value of (A/B) % m, where A, B, and m are given integers function fractionToNaturalModulo(A, B, m) {
// Calculate the modular inverse of B
let inverseB = inverseModulo(B, m);
if (inverseB === null ) {
// Modular inverse does not exist
return null ;
}
// Compute (A * inverseB) % m
let result = (A * inverseB) % m;
return result;
} // Test values let A = 2; let B = 6; let m = 1000000007; let naturalNumber = fractionToNaturalModulo(A, B, m); // Print the result console.log(naturalNumber); |
333333336
Time complexity:
The time complexity of this code is O(log m) because it uses the pow() function to compute the inverse modulo.
Auxiliary Space:
The space complexity of this code is O(1) because it only stores a few integers in memory.