Minimice las operaciones para convertir A en B sumando cualquier número impar o restando cualquier número par

Dados dos enteros positivos A y B . La tarea es encontrar el número mínimo de operaciones requeridas para convertir el número A en B. En un movimiento, se puede aplicar cualquiera de las siguientes operaciones sobre el número A :

• Seleccione cualquier entero impar x (x>0) y agréguelo a A, es decir (A+x) ;
• O bien, seleccione cualquier número entero par y (y>0) y réstelo de A, es decir (Ay) .

Ejemplos:

Entrada: A = 2, B = 3
Salida: 1
Explicación: Sume impar x = 1 a A para obtener B (1 + 2 = 3).

Entrada: A = 7, B = 4
Salida: 2
Explicación:  Se requieren dos operaciones:
restar y = 4 de A (7 – 4 = 3).
Suma x = 1 para obtener B (3 + 1 = 4).

Enfoque: Este es un problema basado en la implementación. Siga los pasos a continuación para resolver el problema dado.

• Almacene la diferencia absoluta de AB en la variable diff .
• Comprueba si A es igual a B. Como los dos enteros son iguales, el número total de operaciones será 0 .
• De lo contrario, compruebe si A < B .
  • En caso afirmativo, compruebe si su diferencia es par o impar.
    • Si diff es impar, la operación A+x se aplica una vez ( x es un entero impar igual a diff ). El número total de operaciones es 1 .
    • De lo contrario, diff es par, aplique la operación A +x dos veces , en primer lugar, donde x es diff -1 (impar) y, en segundo lugar, donde x es 1 . O bien, la operación A+x puede ir seguida de la operación Ay . En cualquier caso, el número total de operaciones será 2.
• De lo contrario, si A> B , se aplica el conjunto opuesto de operaciones, es decir
  • Si diff es par, la operación Ay se aplica una vez.
  • De lo contrario , se puede aplicar la operación Ay seguida de la operación A+x . O bien, la operación Ay se puede aplicar dos veces .

Por lo tanto, el número de operaciones siempre será 0, 1 o 2.

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

// C++ program for the given approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find
// minimum number of operations
int minOperations(int A, int B)
{
    // Variable to store
    // difference of A and B
    int diff;
 
    if (A == B)
        return 0;
    else if (A < B) {
 
        // A+x operation first
        diff = B - A;
        if (diff % 2 != 0)
            return 1;
        return 2;
    }
    else {
 
        // A-y operation first
        diff = A - B;
        if (diff % 2 == 0)
            return 1;
        return 2;
    }
}
 
// Driver code
int main()
{
    // Declaring integers A and B
    int A, B;
 
    // Initialising
    A = 7;
    B = 4;
 
    // Function call
    int ans = minOperations(A, B);
 
    // Displaying the result
    cout << ans;
    return 0;
}

// Java program for the given approach
import java.util.*;
class GFG{
 
// Function to find
// minimum number of operations
static int minOperations(int A, int B)
{
   
    // Variable to store
    // difference of A and B
    int diff;
 
    if (A == B)
        return 0;
    else if (A < B) {
 
        // A+x operation first
        diff = B - A;
        if (diff % 2 != 0)
            return 1;
        return 2;
    }
    else {
 
        // A-y operation first
        diff = A - B;
        if (diff % 2 == 0)
            return 1;
        return 2;
    }
}
 
// Driver code
public static void main(String[] args)
{
   
    // Declaring integers A and B
    int A, B;
 
    // Initialising
    A = 7;
    B = 4;
 
    // Function call
    int ans = minOperations(A, B);
 
    // Displaying the result
    System.out.print(ans);
}
}
 
// This code is contributed by 29AjayKumar

# Python code for the above approach
 
# Function to find
# minimum number of operations
def minOperations(A, B):
 
    # Variable to store
    # difference of A and B
    diff = None
 
    if (A == B):
        return 0;
    elif (A < B):
 
        # A+x operation first
        diff = B - A;
        if (diff % 2 != 0):
            return 1;
        return 2;
    else:
 
        # A-y operation first
        diff = A - B;
        if (diff % 2 == 0):
            return 1;
        return 2;
     
# Driver code
 
# Initialising A and B
A = 7;
B = 4;
 
# Function call
ans = minOperations(A, B);
 
# Displaying the result
print(ans);
 
# This code is contributed by gfgking

// C# program for the given approach
using System;
class GFG{
 
// Function to find
// minimum number of operations
static int minOperations(int A, int B)
{
   
    // Variable to store
    // difference of A and B
    int diff;
 
    if (A == B)
        return 0;
    else if (A < B) {
 
        // A+x operation first
        diff = B - A;
        if (diff % 2 != 0)
            return 1;
        return 2;
    }
    else {
 
        // A-y operation first
        diff = A - B;
        if (diff % 2 == 0)
            return 1;
        return 2;
    }
}
 
// Driver code
public static void Main()
{
   
    // Declaring integers A and B
    int A, B;
 
    // Initialising
    A = 7;
    B = 4;
 
    // Function call
    int ans = minOperations(A, B);
 
    // Displaying the result
    Console.Write(ans);
}
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
      // JavaScript code for the above approach
 
      // Function to find
      // minimum number of operations
      function minOperations(A, B)
      {
       
          // Variable to store
          // difference of A and B
          let diff;
 
          if (A == B)
              return 0;
          else if (A < B) {
 
              // A+x operation first
              diff = B - A;
              if (diff % 2 != 0)
                  return 1;
              return 2;
          }
          else {
 
              // A-y operation first
              diff = A - B;
              if (diff % 2 == 0)
                  return 1;
              return 2;
          }
      }
 
      // Driver code
 
      // Declaring integers A and B
      let A, B;
 
      // Initialising
      A = 7;
      B = 4;
 
      // Function call
      let ans = minOperations(A, B);
 
      // Displaying the result
      document.write(ans);
 
       // This code is contributed by Potta Lokesh
  </script>

2

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