Encuentre que todos los pares elevados a la potencia K difieren exactamente en N

Dados dos enteros positivos X y K , la tarea es encontrar todos los pares de enteros posibles (A, B) tales que la diferencia entre el par de enteros elevado a la potencia K sea el entero X dado . Si no existe tal par, imprima “-1” . 
Nota: El valor de K es al menos 5 y X es como máximo 10 ¹⁸ .

Ejemplos:

Entrada: X = 33, K = 5
Salida:
(1, -2)
(2, -1)
Explicación: Todos los pares posibles son los siguientes:

1. (1, -2): El valor de (1 ⁵ – (-2) ⁵ ) = 33, que es igual a X(= 33).
2. (2, -1): El valor de (2 ⁵ – (-1) ⁵ ) = 33, que es igual a X(= 33).

Por lo tanto, el número total de pares es 2.

Entrada: X = 10, K = 5
Salida: 0

Enfoque: El problema dado puede resolverse basándose en la observación de que el valor máximo posible de X puede ser 10 ¹⁸ . Por lo tanto, el valor del par de enteros (A, B) estará en el rango [-1000, 1000] . Siga los pasos a continuación para resolver el problema:

• Inicialice una variable, digamos count as 0 , para contar el número de pares que satisfacen las condiciones dadas.
• Genere todos los pares posibles (A, B) en el rango [-1000, 1000] y si el valor de (A ^K – B ^K ) es X , imprima el par correspondiente e incremente el conteo en 1 .
• Después de completar los pasos anteriores, si el valor de la cuenta es 0 , imprima «-1» .

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 print pairs whose
// difference raised to the power K is X
void ValidPairs(int X, int K)
{
    // Stores the count of valid pairs
    long long int count = 0;
 
    // Iterate over the range [-1000, 1000]
    for (int A = -1000; A <= 1000; A++) {
 
        // Iterate over the range [-1000, 1000]
        for (int B = -1000; B <= 1000; B++) {
 
            // If the current pair satisfies
            // the given condition
            if (pow(A, K) - pow(B, K) == X) {
 
                // Increment the count by 1
                count++;
                cout << A << " " << B << endl;
            }
        }
    }
 
    // If no such pair exists
    if (count == 0) {
        cout << "-1";
    }
}
 
// Driver Code
int main()
{
    long long int X = 33;
    int K = 5;
    ValidPairs(X, K);
 
    return 0;
}

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to print pairs whose
// difference raised to the power K is X
static void ValidPairs(int X, int K)
{
     
    // Stores the count of valid pairs
    int count = 0;
 
    // Iterate over the range [-1000, 1000]
    for(int A = -1000; A <= 1000; A++)
    {
         
        // Iterate over the range [-1000, 1000]
        for(int B = -1000; B <= 1000; B++)
        {
             
            // If the current pair satisfies
            // the given condition
            if (Math.pow(A, K) - Math.pow(B, K) == X)
            {
                 
                // Increment the count by 1
                count++;
                System.out.println(A + " " + B );
            }
        }
    }
 
    // If no such pair exists
    if (count == 0)
    {
        System.out.println("-1");
    }
}
 
// Driver Code
public static void main(String args[])
{
    int X = 33;
    int K = 5;
     
    ValidPairs(X, K);
}
}
 
// This code is contributed by souravghosh0416

# Python program for the above approach
 
# Function to print pairs whose
# difference raised to the power K is X
def ValidPairs(X, K) :
     
    # Stores the count of valid pairs
    count = 0
 
    # Iterate over the range [-1000, 1000]
    for A in range(-1000, 1001, 1):
 
        # Iterate over the range [-1000, 1000]
        for B in range(-1000, 1001, 1):
 
            # If the current pair satisfies
            # the given condition
            if (pow(A, K) - pow(B, K) == X) :
 
                # Increment the count by 1
                count += 1
                print(A, B)
             
    # If no such pair exists
    if (count == 0) :
        cout << "-1"
     
# Driver Code
X = 33
K = 5
ValidPairs(X, K)
 
# This code is contributed by sanjoy_62.

// C# program for the above approach
using System;
 
class GFG{
 
// Function to print pairs whose
// difference raised to the power K is X
static void ValidPairs(int X, int K)
{
 
    // Stores the count of valid pairs
    int count = 0;
 
    // Iterate over the range [-1000, 1000]
    for(int A = -1000; A <= 1000; A++)
    {
 
        // Iterate over the range [-1000, 1000]
        for(int B = -1000; B <= 1000; B++)
        {
             
            // If the current pair satisfies
            // the given condition
            if (Math.Pow(A, K) - Math.Pow(B, K) == X)
            {
                 
                // Increment the count by 1
                count++;
                Console.WriteLine(A + " " + B);
            }
        }
    }
 
    // If no such pair exists
    if (count == 0)
    {
        Console.WriteLine("-1");
    }
}
 
// Driver Code
static public void Main()
{
    int X = 33;
    int K = 5;
 
    ValidPairs(X, K);
}
}
 
// This code is contributed by Dharanendra L V.

<script>
// javascript program for the above approach
 
    // Function to print pairs whose
    // difference raised to the power K is X
    function ValidPairs(X , K) {
 
        // Stores the count of valid pairs
        var count = 0;
 
        // Iterate over the range [-1000, 1000]
        for (A = -1000; A <= 1000; A++) {
 
            // Iterate over the range [-1000, 1000]
            for (B = -1000; B <= 1000; B++) {
 
                // If the current pair satisfies
                // the given condition
                if (Math.pow(A, K) - Math.pow(B, K) == X) {
 
                    // Increment the count by 1
                    count++;
                    document.write(A + " " + B +"<br/>");
                }
            }
        }
 
        // If no such pair exists
        if (count == 0) {
            document.write("-1<br/>");
        }
    }
 
    // Driver Code
        var X = 33;
        var K = 5;
        ValidPairs(X, K);
 
// This code is contributed by gauravrajput1
</script>

1 -2
2 -1

Complejidad de Tiempo: O(2000 * 2000)
Espacio Auxiliar: O(1)