Least common element in given two Arithmetic sequences

Given four positive numbers A, B, C, D, such that A and B are the first term and the common difference of first Arithmetic sequence respectively, while C and D represent the same for the second Arithmetic sequence respectively as shown below: 

First Arithmetic Sequence: A, A + B, A + 2B, A + 3B, …….
Second Arithmetic Sequence: C, C + D, C + 2D, C + 3D, …….

The task is to find the least common element from the above AP sequences. If no such number exists, then print -1.

Examples:

Input: A = 2, B = 20, C = 19, D = 9 
Output: 82 
Explanation:
Sequence 1: {2, 2 + 20, 2 + 2(20), 2 + 3(20), 2 + 4(20), …..} = {2, 22, 42, 62, 82, …..} 
Sequence 2: {19, 19 + 9, 19 + 2(9), 19 + 3(9), 19 + 4(9), 19 + 5(9), 19 + 6(9), 19 + 7(9) …..} = {19, 28, 37, 46, 55, 64, 73, 82, …..} 
Therefore, 82 is the smallest common element.

Input: A = 2, B = 18, C = 19, D = 9 
Output: -1

Approach:

Since any term of the given two sequences can be expressed as A + x*B and C + y*D, therefore, to solve the problem, we need to find the smallest values of x and y for which the two terms are equal. 
Follow the steps below to solve the problem: 

• In order to find the smallest value common in both the AP sequences, the idea is to find the smallest integer values of x and y satisfying the following equation: 
  

A + x*B = C + y*D

=> The above equation can be rearranged as 
x*B = C – A + y*D
=> The above equation can be further rearranged as 
x = (C – A + y*D) / B 

• Check if there exists any integer value y such that (C – A + y*D) % B is 0 or not. If it exists, then the smallest number is (C + y*D).
• Check whether (C + y*D) is the answer or not, where y will be in a range (0, B) because from i = B, B+1, …. the remainder values will be repeated.
• If no such number is obtained from the above steps, then print -1.

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the smallest element
// common in both the subsequences
long smallestCommon(long a, long b,
                    long c, long d)
{
    // If a is equal to c
    if (a == c)
        return a;

    // If a exceeds c
    if (a > c) {
        swap(a, c);
        swap(b, d);
    }

    long first_term_diff = (c - a);
    long possible_y;

    // Check for the satisfying
    // equation
    for (possible_y = 0; possible_y < b; possible_y++) {

        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b
             + possible_y * d)
                % b
            == 0) {
            break;
        }
    }

    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b) {
        return c + possible_y * d;
    }

    // If no value of possible_y
    // satisfies the given equation
    return -1;
}

// Driver Code
int main()
{
    long A = 2, B = 20, C = 19, D = 9;
    cout << smallestCommon(A, B, C, D);

    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG{

// Function to find the smallest element
// common in both the subsequences
static int smallestCommon(int a, int b,
                          int c, int d)
{
    // If a is equal to c
    if (a == c)
        return a;

    // If a exceeds c
    if (a > c)
    {
        swap(a, c);
        swap(b, d);
    }

    int first_term_diff = (c - a);
    int possible_y;

    // Check for the satisfying
    // equation
    for (possible_y = 0;
         possible_y < b; possible_y++)
    {

        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0)
        {
            break;
        }
    }

    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b)
    {
        return c + possible_y * d;
    }

    // If no value of possible_y
    // satisfies the given equation
    return -1;
}

static void swap(int x, int y)
{
      int temp = x;
      x = y;
      y = temp;
}

// Driver Code
public static void main(String[] args)
{
    int A = 2, B = 20, C = 19, D = 9;
    System.out.print(smallestCommon(A, B, C, D));
}
}

// This code is contributed by PrinciRaj1992

Python3

# Python3 program to implement
# the above approach

# Function to find the smallest element
# common in both the subsequences
def smallestCommon(a, b, c, d):

    # If a is equal to c
    if (a == c):
        return a;

    # If a exceeds c
    if (a > c):
        swap(a, c);
        swap(b, d);

    first_term_diff = (c - a);
    possible_y = 0;

    # Check for the satisfying
    # equation
    for possible_y in range(b):

        # Least value of possible_y
        # satisfying the given equation
        # will yield True in the below if
        # and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0):
            break;

    # If the value of possible_y
    # satisfying the given equation
    # lies in range [0, b]
    if (possible_y != b):
        return c + possible_y * d;

    # If no value of possible_y
    # satisfies the given equation
    return -1;

def swap(x, y):
    temp = x;
    x = y;
    y = temp;

# Driver Code
if __name__ == '__main__':
    A = 2; B = 20; C = 19; D = 9;
    print(smallestCommon(A, B, C, D));

# This code is contributed by Rajput-Ji

C#

// C# program to implement
// the above approach
using System;
class GFG{

// Function to find the smallest element
// common in both the subsequences
static int smallestCommon(int a, int b,
                          int c, int d)
{
    // If a is equal to c
    if (a == c)
        return a;

    // If a exceeds c
    if (a > c)
    {
        swap(a, c);
        swap(b, d);
    }

    int first_term_diff = (c - a);
    int possible_y;

    // Check for the satisfying
    // equation
    for (possible_y = 0;
         possible_y < b; possible_y++)
    {

        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0)
        {
            break;
        }
    }

    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b)
    {
        return c + possible_y * d;
    }

    // If no value of possible_y
    // satisfies the given equation
    return -1;
}

static void swap(int x, int y)
{
      int temp = x;
      x = y;
      y = temp;
}

// Driver Code
public static void Main(String[] args)
{
    int A = 2, B = 20, C = 19, D = 9;
    Console.Write(smallestCommon(A, B, C, D));
}
}


// This code is contributed by Rajput-Ji

Javascript

<script>
// JavaScript program for the
// above approach

// Function to find the smallest element
// common in both the subsequences
function smallestCommon(a, b, c, d)
{
    // If a is equal to c
    if (a == c)
        return a;

    // If a exceeds c
    if (a > c)
    {
        swap(a, c);
        swap(b, d);
    }

    let first_term_diff = (c - a);
    let possible_y;

    // Check for the satisfying
    // equation
    for (possible_y = 0;
         possible_y < b; possible_y++)
    {

        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0)
        {
            break;
        }
    }

    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b)
    {
        return c + possible_y * d;
    }

    // If no value of possible_y
    // satisfies the given equation
    return -1;
}

function swap(x, y)
{
      let temp = x;
      x = y;
      y = temp;
}

// Driver Code

    let A = 2, B = 20, C = 19, D = 9;
    document.write(smallestCommon(A, B, C, D));

</script>

Output:

82

Time Complexity: O(B)
Auxiliary Space: O(1)