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++
#include <bits/stdc++.h>
using namespace std;
long smallestCommon( long a, long b,
long c, long d)
{
if (a == c)
return a;
if (a > c) {
swap(a, c);
swap(b, d);
}
long first_term_diff = (c - a);
long possible_y;
for (possible_y = 0; possible_y < b; possible_y++) {
if ((first_term_diff % b
+ possible_y * d)
% b
== 0) {
break ;
}
}
if (possible_y != b) {
return c + possible_y * d;
}
return -1;
}
int main()
{
long A = 2, B = 20, C = 19, D = 9;
cout << smallestCommon(A, B, C, D);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int smallestCommon( int a, int b,
int c, int d)
{
if (a == c)
return a;
if (a > c)
{
swap(a, c);
swap(b, d);
}
int first_term_diff = (c - a);
int possible_y;
for (possible_y = 0 ;
possible_y < b; possible_y++)
{
if ((first_term_diff % b +
possible_y * d) % b == 0 )
{
break ;
}
}
if (possible_y != b)
{
return c + possible_y * d;
}
return - 1 ;
}
static void swap( int x, int y)
{
int temp = x;
x = y;
y = temp;
}
public static void main(String[] args)
{
int A = 2 , B = 20 , C = 19 , D = 9 ;
System.out.print(smallestCommon(A, B, C, D));
}
}
|
Python3
def smallestCommon(a, b, c, d):
if (a = = c):
return a;
if (a > c):
swap(a, c);
swap(b, d);
first_term_diff = (c - a);
possible_y = 0 ;
for possible_y in range (b):
if ((first_term_diff % b +
possible_y * d) % b = = 0 ):
break ;
if (possible_y ! = b):
return c + possible_y * d;
return - 1 ;
def swap(x, y):
temp = x;
x = y;
y = temp;
if __name__ = = '__main__' :
A = 2 ; B = 20 ; C = 19 ; D = 9 ;
print (smallestCommon(A, B, C, D));
|
C#
using System;
class GFG{
static int smallestCommon( int a, int b,
int c, int d)
{
if (a == c)
return a;
if (a > c)
{
swap(a, c);
swap(b, d);
}
int first_term_diff = (c - a);
int possible_y;
for (possible_y = 0;
possible_y < b; possible_y++)
{
if ((first_term_diff % b +
possible_y * d) % b == 0)
{
break ;
}
}
if (possible_y != b)
{
return c + possible_y * d;
}
return -1;
}
static void swap( int x, int y)
{
int temp = x;
x = y;
y = temp;
}
public static void Main(String[] args)
{
int A = 2, B = 20, C = 19, D = 9;
Console.Write(smallestCommon(A, B, C, D));
}
}
|
Javascript
<script>
function smallestCommon(a, b, c, d)
{
if (a == c)
return a;
if (a > c)
{
swap(a, c);
swap(b, d);
}
let first_term_diff = (c - a);
let possible_y;
for (possible_y = 0;
possible_y < b; possible_y++)
{
if ((first_term_diff % b +
possible_y * d) % b == 0)
{
break ;
}
}
if (possible_y != b)
{
return c + possible_y * d;
}
return -1;
}
function swap(x, y)
{
let temp = x;
x = y;
y = temp;
}
let A = 2, B = 20, C = 19, D = 9;
document.write(smallestCommon(A, B, C, D));
</script>
|
Time Complexity: O(B)
Auxiliary Space: O(1)
Last Updated :
07 May, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...