Encuentra si el número dado está presente en la secuencia infinita o no

Dados tres enteros A , B y C . En una secuencia infinita, A es el primer número , C es la diferencia común (S _i – S _{i ​​– 1} = C). La tarea es verificar si el número B aparecerá en la secuencia o no.
Ejemplos: 
 

Entrada: A = 1, B = 7, C = 3 
Salida: Sí 
La secuencia será 1, 4, 7, 10, …
Entrada: A = 1, B = -4, C = 5 
Salida: No 
 

Planteamiento: Hay dos casos: 
 

1. Cuando C = 0 , imprima Sí si A = B , de lo contrario No , ya que la secuencia consistirá solo en el número A
2. Cuando C > 0 , para cualquier número entero no negativo k , la ecuación B = A + k * C debe cumplirse, es decir , (B – A) / C debe ser un número entero no negativo.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if
// the sequence will contain B
bool doesContainB(int a, int b, int c)
{
    if (a == b)
        return true;
 
    if ((b - a) * c > 0 && (b - a) % c == 0)
        return true;
 
    return false;
}
 
// Driver code
int main()
{
    int a = 1, b = 7, c = 3;
 
    if (doesContainB(a, b, c))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}

// Java implementation of the approach
class GFG
{
 
    // Function that returns true if
    // the sequence will contain B
    static boolean doesContainB(int a, int b, int c)
    {
        if (a == b)
        {
            return true;
        }
 
        if ((b - a) * c > 0 && (b - a) % c == 0)
        {
            return true;
        }
 
        return false;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a = 1, b = 7, c = 3;
 
        if (doesContainB(a, b, c))
        {
            System.out.println("Yes");
        }
        else
        {
            System.out.println("No");
        }
    }
}
 
// This code contributed by Rajput-Ji

# Python3 implementation of the approach
 
# Function that returns true if
# the sequence will contain B
def doesContainB(a, b, c):
    if (a == b):
        return True
 
    if ((b - a) * c > 0 and (b - a) % c == 0):
        return True
 
    return False
 
# Driver code
if __name__ == '__main__':
    a, b, c = 1, 7, 3
 
    if (doesContainB(a, b, c)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by 29AjayKumar

// C# implementation of the approach
using System;
 
class GFG
{
 
    // Function that returns true if
    // the sequence will contain B
    static bool doesContainB(int a, int b, int c)
    {
        if (a == b)
        {
            return true;
        }
 
        if ((b - a) * c > 0 && (b - a) % c == 0)
        {
            return true;
        }
 
        return false;
    }
 
    // Driver code
    public static void Main()
    {
        int a = 1, b = 7, c = 3;
 
        if (doesContainB(a, b, c))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}
 
/* This code contributed by PrinciRaj1992 */

<?php
// PHP implementation of the approach
 
// Function that returns true if
// the sequence will contain B
function doesContainB($a, $b, $c)
{
    if ($a == $b)
        return true;
 
    if (($b - $a) * $c > 0 &&
        ($b - $a) % $c == 0)
        return true;
 
    return false;
}
 
// Driver code
$a = 1; $b = 7; $c = 3;
 
if (doesContainB($a, $b, $c))
    echo "Yes";
else
    echo "No";
 
// This code is contributed
// by Akanksha Rai
?>

<script>
 
// javascript program for the above approach
 
    // Function that returns true if
    // the sequence will contain B
    function doesContainB(a, b, c)
    {
        if (a == b)
        {
            return true;
        }
 
        if ((b - a) * c > 0 && (b - a) % c == 0)
        {
            return true;
        }
 
        return false;
    }
 
// Driver Code
     
    let a = 1, b = 7, c = 3;
 
        if (doesContainB(a, b, c))
        {
            document.write("Yes");
        }
        else
        {
            document.write("No");
        }
 
</script>

Yes

Complejidad de Tiempo: O(1), ya que solo hay aritmética básica que toma tiempo constante.
Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.