El mayor número menor o igual a Z que deja un residuo X cuando se divide por Y

Dados tres enteros x, y, z , la tarea es encontrar el mayor número no negativo menor o igual a z que deje un resto x cuando se divide por y (Dado x < y). Si no existe tal número, la salida será -1.

Ejemplos: 

Input: x = 1, y = 5, z = 8
Output: 6
Explanation:
6 is the largest number less than 8 
which when divided by 5 
leaves a remainder 1.

Input: x = 4, y = 6, z = 3
Output: -1
Explanation:
Since no such number exists the output is -1

Enfoque: para resolver el problema mencionado anteriormente, la primera observación es si x > z , entonces la respuesta no será posible, por lo que la salida será -1. 
Sea p el número requerido . Las siguientes son las dos ecuaciones para resolver el problema:  

• p * y + x = 0
• p * y <= (z – x)

Para encontrar la respuesta, necesitamos encontrar el valor de p . Asi que, 

p = (z - x) / y

Después de calcular p , simplemente podemos encontrar la respuesta que es  

p * y + x

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

// C++ implementation to Find the
// largest non-negative number that
// is less than or equal to integer Z
// and leaves a remainder X when divided by Y
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to get the number
int get(int x, int y, int z)
{
 
    // remainder can't be larger
    // than the largest number,
    // if so then answer doesn't exist.
    if (x > z)
        return -1;
 
    // reduce number by x
    int val = z - x;
 
    // finding the possible
    // number that is divisible by y
    int div = (z - x) / y;
 
    // this number is always <= x
    // as we calculated over z - x
    int ans = div * y + x;
 
    return ans;
}
 
// Driver Code
int main()
{
    // initialise the three integers
    int x = 1, y = 5, z = 8;
 
    cout << get(x, y, z) << "\n";
 
    return 0;
}

// Java implementation to Find the
// largest non-negative number that
// is less than or equal to integer Z
// and leaves a remainder X when divided by Y
class GFG{
  
// Function to get the number
static int get(int x, int y, int z)
{
  
    // remainder can't be larger
    // than the largest number,
    // if so then answer doesn't exist.
    if (x > z)
        return -1;
  
    // reduce number by x
    int val = z - x;
  
    // finding the possible
    // number that is divisible by y
    int div = (z - x) / y;
  
    // this number is always <= x
    // as we calculated over z - x
    int ans = div * y + x;
  
    return ans;
}
  
// Driver Code
public static void main(String[] args)
{
    // initialise the three integers
    int x = 1, y = 5, z = 8;
  
    System.out.print(get(x, y, z)+ "\n");
}
}
 
// This code is contributed by sapnasingh4991

# Python implementation to Find the
# largest non-negative number that
# is less than or equal to integer Z
# and leaves a remainder X when divided by Y
 
# Function to get the number
def get(x, y, z):
     
    # remainder can't be larger
    # than the largest number,
    # if so then answer doesn't exist.
    if (x > z):
        return -1
         
    # reduce number by x
    val = z - x
     
    # finding the possible
    # number that is divisible by y
    div = (z - x) // y
     
     
    # this number is always <= x
    # as we calculated over z - x
    ans = div * y + x
     
    return ans
 
 
# Driver Code
# initialise the three integers
x = 1
y = 5
z = 8
 
print(get(x, y, z))
 
# This code is contributed by shubhamsingh10

// C# implementation to Find the
// largest non-negative number that
// is less than or equal to integer Z
// and leaves a remainder X when divided by Y
using System;
 
class GFG{
   
// Function to get the number
static int get(int x, int y, int z)
{
   
    // remainder can't be larger
    // than the largest number,
    // if so then answer doesn't exist.
    if (x > z)
        return -1;
   
    // reduce number by x
    int val = z - x;
   
    // finding the possible
    // number that is divisible by y
    int div = (z - x) / y;
   
    // this number is always <= x
    // as we calculated over z - x
    int ans = div * y + x;
   
    return ans;
}
   
// Driver Code
public static void Main(String[] args)
{
    // initialise the three integers
    int x = 1, y = 5, z = 8;
   
    Console.Write(get(x, y, z)+ "\n");
}
}
 
// This code is contributed by sapnasingh4991

<script>
 
// Javascript implementation to Find the
// largest non-negative number that
// is less than or equal to integer Z
// and leaves a remainder X when divided by Y
 
// Function to get the number
function get(x, y, z)
{
   
    // remainder can't be larger
    // than the largest number,
    // if so then answer doesn't exist.
    if (x > z)
        return -1;
   
    // reduce number by x
    let val = z - x;
   
    // finding the possible
    // number that is divisible by y
    let div = Math.floor((z - x) / y);
   
    // this number is always <= x
    // as we calculated over z - x
    let ans = div * y + x;
   
    return ans;
}
 
// Driver Code
 
    // initialise the three integers
    let x = 1, y = 5, z = 8;
   
    document.write(get(x, y, z)+ "\n");
 
</script>

6

Complejidad de tiempo: O(1 )

Espacio Auxiliar: O(1)