Open In App
Related Articles

Find smallest values of x and y such that ax – by = 0

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given two values ‘a’ and ‘b’ that represent coefficients in “ax – by = 0”, find the smallest values of x and y that satisfy the equation. It may also be assumed that x > 0, y > 0, a > 0 and b > 0.
 

Input: a = 25, b = 35
Output: x = 7, y = 5


 


A Simple Solution is to try every possible value of x and y starting from 1, 1 and stop when the equation is satisfied.
A Direct Solution is to use Least Common Multiple (LCM). LCM of ‘a’ and ‘b’ represents the smallest value that can make both sides equal. We can find LCM using below formula. 
 

   LCM(a, b) = (a * b) / GCD(a, b) 


Greatest Common Divisor (GCD) can be computed using Euclid’s algorithm.
 

C++

// C++ program to find the smallest values of x and y that
// satisfy "ax - by = 0"
#include <iostream>
using namespace std;
 
// To find GCD using Euclid's algorithm
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return (gcd(b, a % b));
}
 
// Prints smallest values of x and y that
// satisfy "ax - by = 0"
void findSmallest(int a, int b)
{
    // Find LCM
    int lcm = (a * b) / gcd(a, b);
 
    cout << "x = " << lcm / a
         << "\ny = " << lcm / b;
}
 
// Driver program
int main()
{
    int a = 25, b = 35;
    findSmallest(a, b);
    return 0;
}

                    

Java

// Java program to find the smallest values of
// x and y that satisfy "ax - by = 0"
class GFG {
 
    // To find GCD using Euclid's algorithm
    static int gcd(int a, int b)
    {
 
        if (b == 0)
            return a;
        return (gcd(b, a % b));
    }
 
    // Prints smallest values of x and y that
    // satisfy "ax - by = 0"
    static void findSmallest(int a, int b)
    {
 
        // Find LCM
        int lcm = (a * b) / gcd(a, b);
 
        System.out.print("x = " + lcm / a
                         + "\ny = " + lcm / b);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a = 25, b = 35;
        findSmallest(a, b);
    }
}
 
// This code is contributed by Anant Agarwal.

                    

Python3

# Python program to find the
# smallest values of x and y that
# satisfy "ax - by = 0"
 
# To find GCD using Euclid's algorithm
def gcd(a, b):
    if (b == 0):
        return a
    return(gcd(b, a % b))
 
# Prints smallest values of x and y that
# satisfy "ax - by = 0"
def findSmallest(a, b):
 
    # Find LCM
    lcm = (a * b)/gcd(a, b)
    print("x =", lcm / a, "\ny = ", lcm / b)
 
# Driver code
a = 25
b = 35
findSmallest(a, b)
 
# This code is contributed
# by Anant Agarwal.

                    

C#

// C# program to find the smallest
// values of x and y that
// satisfy "ax - by = 0"
using System;
 
class GFG {
 
    // To find GCD using
    // Euclid's algorithm
    static int gcd(int a, int b)
    {
 
        if (b == 0)
            return a;
        return (gcd(b, a % b));
    }
 
    // Prints smallest values of x and
    // y that satisfy "ax - by = 0"
    static void findSmallest(int a, int b)
    {
 
        // Find LCM
        int lcm = (a * b) / gcd(a, b);
 
        Console.Write("x = " + lcm / a + "\ny = " + lcm / b);
    }
 
    // Driver code
    public static void Main()
    {
        int a = 25, b = 35;
        findSmallest(a, b);
    }
}
 
// This code is contributed by Sam007.

                    

PHP

<?php
// PHP program to find the
// smallest values of x
// and y that satisfy
// "ax - by = 0"
 
// To find GCD using
// Euclid's algorithm
function gcd($a, $b)
{
    if ($b == 0)
    return $a;
    return(gcd($b, $a % $b));
}
 
// Prints smallest values
// of x and y that
// satisfy "ax - by = 0"
function findSmallest($a, $b)
{
     
    // Find LCM
    $lcm = ($a * $b) / gcd($a, $b);
 
    echo "x = ", $lcm/$a, "\ny = ", $lcm/$b;
}
 
    // Driver Code
    $a = 25;
    $b = 35;
    findSmallest($a, $b);
     
// This code is contributed by ajit
?>

                    

Javascript

<script>
 
    // Javascript program to find the smallest
    // values of x and y that
    // satisfy "ax - by = 0"
     
    // To find GCD using
    // Euclid's algorithm
    function gcd(a, b)
    {
   
        if (b == 0)
            return a;
        return (gcd(b, a % b));
    }
   
    // Prints smallest values of x and
    // y that satisfy "ax - by = 0"
    function findSmallest(a, b)
    {
   
        // Find LCM
        let lcm = parseInt((a * b) / gcd(a, b), 10);
   
        document.write("x = " + parseInt(lcm / a, 10) +
        "</br>y = " + parseInt(lcm / b, 10));
    }
     
    let a = 25, b = 35;
      findSmallest(a, b);
     
</script>

                    

Output:

x = 7
y = 5


The above code for findSmallest() can be reduced: 
 

Since ax - by = 0,
ax = by, which means x/y = b/a
So we can calculate gcd and directly do as -

Value of x = b / gcd;
Value of y = a / gcd; 


 

C++

// Prints smallest values of x and y that
// satisfy "ax - by = 0"
void findSmallest(int a, int b)
{
    // Find GCD
    int g = gcd(a, b);
    cout << "x = " << b / g << endl
         << "y = " << a / g << endl;
}

                    

C

// Prints smallest values of x and y that
// satisfy "ax - by = 0"
void findSmallest(int a, int b)
{
    // Find GCD
    int g = gcd(a, b);
 
    cout << "x = " << b / g
         << "\ny = " << a / g;
}

                    

Java

// Java program to implement
// the above approach
 
import java.util.*;
 
class GFG {
 
    // Recursive function to return
    // gcd of a and b
    static int gcd(int a, int b)
    {
 
        // Everything divides 0
        if (a == 0)
            return b;
        if (b == 0)
            return a;
 
        // base case
        if (a == b)
            return a;
 
        // a is greater
        if (a > b)
            return gcd(a - b, b);
 
        return gcd(a, b - a);
    }
 
    // Prints smallest values of x and y that
    // satisfy "ax - by = 0"
    static void findSmallest(int a, int b)
    {
        // Find GCD
        int g = gcd(a, b);
 
        System.out.println("x = " + b / g + "y = " + a / g);
    }
}
 
// This code is contributed by phasing17.

                    

Python3

# Prints smallest values of x and y that
# satisfy "ax - by = 0"
 
def gcd(a, b):
    if (b == 0):
        return a
    return gcd(b, a % b)
 
def findSmallest(a, b):
    # Find GCD
    g = gcd(a, b)
    print("x =", int(b / g), "\ny =", int(a / g))
 
findSmallest(25, 35);
 
# This code is contributed by phasing17

                    

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
     
    // Recursive function to return
    // gcd of a and b
    static int gcd(int a, int b)
    {
          
        // Everything divides 0
        if (a == 0)
          return b;
        if (b == 0)
          return a;
      
        // base case
        if (a == b)
            return a;
      
        // a is greater
        if (a > b)
            return gcd(a - b, b);
              
        return gcd(a, b - a);
    }
     
// Prints smallest values of x and y that
// satisfy "ax - by = 0"
static void findSmallest(int a, int b)
{
    // Find GCD
    int g = gcd(a, b);
  
    Console.Write( "x = " + b / g
         + "y = " + a / g);
}
}
 
// This code is contributed by code_hunt.

                    

Javascript

// Prints smallest values of x and y that
// satisfy "ax - by = 0"
 
function gcd(a, b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
function findSmallest(a, b)
{
    // Find GCD
    let g = gcd(a, b);
    console.log("x =", b / g, "\ny =", a / g);
}
 
// This code is contributed by phasing17

                    



 



Last Updated : 03 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads