Encuentra un par de cuadrados perfectos consecutivos con diferencia K

Dado un entero K , la tarea es encontrar dos cuadrados perfectos consecutivos cuya diferencia sea K . Si no existen tales pares de números, imprima -1 .

Ejemplos:

Entrada: K = 5
Salida: 4 9
Explicación :
Entonces, 4 y 9 son los dos cuadrados perfectos que difieren en 5 (= 9 – 4 = 5).

Entrada: K = 4
Salida: -1

Enfoque ingenuo: el enfoque simple para resolver el problema dado es atravesar todos los cuadrados perfectos y verificar si existen 2 de esos números cuya diferencia es K , si es cierto, luego imprimir esos pares. De lo contrario, imprima -1 .

Complejidad temporal: O(N)
Espacio auxiliar: O(1)

Enfoque eficiente: el enfoque anterior también se puede optimizar observando la diferencia entre cuadrados perfectos consecutivos como:

Cuadrados perfectos:                1 4 9 16 25 …
Diferencia consecutiva:    3 5 7 9 …

De la observación anterior, la diferencia entre cuadrados perfectos consecutivos es del orden de los números impares consecutivos . Por lo tanto, cuando la diferencia es par, entonces no existen tales pares de números, por lo tanto, imprima «-1» . De lo contrario, los dos números numéricos están dados por (K/2) ² y ((K + 1)/2) ² .

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

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to find two consecutive
// perfect square numbers whose
// difference is N
void findPrimeNumbers(int N)
{
    int a, b;
    a = (N / 2) * (N / 2);
    b = ((N + 1) / 2) * ((N + 1) / 2);
 
    if ((N % 2) == 0)
        cout << "-1";
    else
        cout << a << " " << b;
}
 
// Driver Code
int main()
{
    int K = 5;
    findPrimeNumbers(K);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG {
 
    // Function to find two consecutive
    // perfect square numbers whose
    // difference is N
    static void findPrimeNumbers(int N)
    {
        int a, b;
        a = (N / 2) * (N / 2);
        b = ((N + 1) / 2) * ((N + 1) / 2);
 
        if ((N % 2) == 0)
            System.out.println("-1");
        else
            System.out.println(a + " " + b);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int K = 5;
        findPrimeNumbers(K);
    }
}
 
// This code is contributed by Dharanendra L V.

# python program for the above approach
 
# Function to find two consecutive
# perfect square numbers whose
# difference is N
def findPrimeNumbers(N):
    a = (N // 2) * (N // 2)
    b = ((N + 1) // 2) * ((N + 1) // 2)
 
    if ((N % 2) == 0):
        print("-1")
    else:
        print(a, end=" ")
        print(b)
 
# Driver Code
if __name__ == "__main__":
    K = 5
    findPrimeNumbers(K)
     
    # This code is contributed by rakeshsahni

// C# program for the above approach
using System;
 
class GFG {
 
    // Function to find two consecutive
    // perfect square numbers whose
    // difference is N
    static void findPrimeNumbers(int N)
    {
        int a, b;
        a = (N / 2) * (N / 2);
        b = ((N + 1) / 2) * ((N + 1) / 2);
 
        if ((N % 2) == 0)
            Console.WriteLine("-1");
        else
            Console.WriteLine(a + " " + b);
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int K = 5;
        findPrimeNumbers(K);
    }
}
 
// This code is contributed by ukasp.

<script>
 
// JavaScript program for the above approach
 
// Function to find two consecutive
// perfect square numbers whose
// difference is N
function findPrimeNumbers(N)
{
    let a, b;
    a = Math.floor(N / 2) *
        Math.floor(N / 2);
    b = Math.floor((N + 1) / 2) *
        Math.floor((N + 1) / 2);
 
    if ((N % 2) == 0)
        document.write("-1");
    else
        document.write(a + " " + b);
}
 
// Driver Code
let K = 5;
 
findPrimeNumbers(K);
 
// This code is contributed by Potta Lokesh
 
</script>

4 9

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