Convierta A en B aumentando o disminuyendo 1, 2 o 5 cualquier número de veces

Dados dos números enteros A y B , la tarea es encontrar el número mínimo de movimientos necesarios para hacer que A sea igual a B incrementando o disminuyendo A en 1 , 2 o 5 cualquier número de veces.

Ejemplos:

Entrada: A = 4, B = 0
Salida: 2
Explicación:
Realice la operación de la siguiente manera:

1. Disminuyendo el valor de A por 2, modifica el valor de A a (4 – 2) = 2.
2. Disminuir el valor de A en 2 modifica el valor de A a (2 – 2) = 0. Lo que es igual a B.

Por lo tanto, el número de movimientos necesarios es 2.

Entrada: A = 3, B = 9
Salida: 2

Enfoque: el problema dado se puede resolver utilizando el enfoque codicioso . La idea es encontrar primero el incremento o decremento de 5 , luego 2 y luego 1 que se necesita para convertir A en B . Siga los pasos a continuación para resolver el problema: 

• Actualice el valor de A como la diferencia absoluta entre A y B .
• Ahora, imprima el valor de (A/5) + (A%5)/2 + (A%5)%2 como el número mínimo de incrementos o decrementos de 1 , 2 o 5 para convertir A en B.

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

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum number of
// moves required to convert A into B
int minimumSteps(int a, int b)
{
    // Stores the minimum number of
    // moves required
    int cnt = 0;
 
    // Stores the absolute
    // difference
    a = abs(a - b);
 
    // FInd the number of moves
    cnt = (a / 5) + (a % 5) / 2 + (a % 5) % 2;
 
    // Return cnt
    return cnt;
}
 
// Driver Code
int main()
{
    // Input
    int A = 3, B = 9;
    // Function call
    cout << minimumSteps(A, B);
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG
{
   
    // Function to find minimum number of
    // moves required to convert A into B
    static int minimumSteps(int a, int b)
    {
       
        // Stores the minimum number of
        // moves required
        int cnt = 0;
 
        // Stores the absolute
        // difference
        a = Math.abs(a - b);
 
        // FInd the number of moves
        cnt = (a / 5) + (a % 5) / 2 + (a % 5) % 2;
 
        // Return cnt
        return cnt;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Input
        int A = 3, B = 9;
        // Function call
        System.out.println(minimumSteps(A, B));
    }
}
 
 // This code is contributed by Potta Lokesh

# python program for the above approach
 
# Function to find minimum number of
# moves required to convert A into B
def minimumSteps(a, b):
   
    # Stores the minimum number of
    # moves required
    cnt = 0
 
    # Stores the absolute
    # difference
    a = abs(a - b)
 
    # FInd the number of moves
    cnt = (a//5) + (a % 5)//2 + (a % 5) % 2
     
    # Return cnt
    return cnt
 
 
# Driver Code
# Input
A = 3
B = 9
 
# Function call
print(minimumSteps(A, B))
 
# This code is contributed by amreshkumar3.

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find minimum number of
// moves required to convert A into B
static int minimumSteps(int a, int b)
{
     
    // Stores the minimum number of
    // moves required
    int cnt = 0;
 
    // Stores the absolute
    // difference
    a = Math.Abs(a - b);
 
    // FInd the number of moves
    cnt = (a / 5) + (a % 5) / 2 + (a % 5) % 2;
 
    // Return cnt
    return cnt;
}
 
// Driver Code
public static void Main()
{
     
    // Input
    int A = 3, B = 9;
     
    // Function call
    Console.Write(minimumSteps(A, B));
}
}
 
// This code is contributed by SURENDRA_GANGWAR

<script>
        // JavaScript program for the above approach
 
        // Function to find minimum number of
        // moves required to convert A into B
        function minimumSteps(a, b)
        {
         
            // Stores the minimum number of
            // moves required
            let cnt = 0;
 
            // Stores the absolute
            // difference
            a = Math.abs(a - b);
 
            // FInd the number of moves
            cnt = Math.floor(a / 5) + Math.floor((a % 5) / 2) + (a % 5) % 2;
 
            // Return cnt
            return cnt;
        }
 
        // Driver Code
 
        // Input
        let A = 3, B = 9;
        // Function call
        document.write(minimumSteps(A, B));
 
 
    // This code is contributed by Potta Lokesh
 
    </script>

2

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)