El menor número que se debe sumar o restar de N para convertirlo en un cuadrado perfecto

Dado un número N , encuentre el número mínimo que se debe sumar o restar de N para convertirlo en un cuadrado perfecto . Si el número se va a sumar, imprímalo con un signo +, de lo contrario, si el número se va a restar, imprímalo con un signo -.

Ejemplos:  

Entrada: N = 14 
Salida: 2 
El cuadrado perfecto más cercano antes de 14 = 9 
El cuadrado perfecto más cercano después de 14 = 16 
Por lo tanto, es necesario sumar 2 a 14 para obtener el cuadrado perfecto más cercano.

Entrada: N = 18 
Salida: -2 
Cuadrado perfecto más cercano antes de 18 = 16 
Cuadrado perfecto más cercano después de 18 = 25 
Por lo tanto, es necesario restar 2 de 18 para obtener el cuadrado perfecto más cercano.  

Enfoque :  

1. Consigue el número.
2. Encuentra la raíz cuadrada del número y convierte el resultado en un número entero.
3. Después de convertir el valor doble a un número entero, contendrá la raíz del cuadrado perfecto sobre N, es decir, piso (raíz cuadrada (N)) .
4. Luego encuentra el cuadrado de este número, que será el cuadrado perfecto antes de N.
5. Encuentre la raíz del cuadrado perfecto después de N, es decir, el ceil(square root(N)) .
6. Luego encuentra el cuadrado de este número, que será el cuadrado perfecto después de N.
7. Compruebe si el cuadrado del valor del suelo es el más cercano a N o al valor del techo.
8. Si el cuadrado del valor del piso es el más cercano a N, imprima la diferencia con un signo -. De lo contrario, imprima la diferencia entre el cuadrado del valor del techo y N con un signo +.

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

// C++ implementation of the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the Least number
int nearest(int n)
{
 
    // Get the perfect square
    // before and after N
    int prevSquare = sqrt(n);
    int nextSquare = prevSquare + 1;
    prevSquare = prevSquare * prevSquare;
    nextSquare = nextSquare * nextSquare;
 
    // Check which is nearest to N
    int ans
        = (n - prevSquare) < (nextSquare - n)
              ? (prevSquare - n)
              : (nextSquare - n);
 
    // return the result
    return ans;
}
 
// Driver code
int main()
{
    int n = 14;
    cout << nearest(n) << endl;
 
    n = 16;
    cout << nearest(n) << endl;
 
    n = 18;
    cout << nearest(n) << endl;
 
    return 0;
}

// Java implementation of the approach
class GFG {
         
    // Function to return the Least number
    static int nearest(int n)
    {
     
        // Get the perfect square
        // before and after N
        int prevSquare = (int)Math.sqrt(n);
        int nextSquare = prevSquare + 1;
        prevSquare = prevSquare * prevSquare;
        nextSquare = nextSquare * nextSquare;
     
        // Check which is nearest to N
        int ans = (n - prevSquare) < (nextSquare - n)? (prevSquare - n): (nextSquare - n);
     
        // return the result
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int n = 14;
        System.out.println(nearest(n));
     
        n = 16;
        System.out.println(nearest(n)) ;
     
        n = 18;
        System.out.println(nearest(n)) ;
     
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the approach
from math import sqrt
 
# Function to return the Least number
def nearest(n) :
 
    # Get the perfect square
    # before and after N
    prevSquare = int(sqrt(n));
    nextSquare = prevSquare + 1;
    prevSquare = prevSquare * prevSquare;
    nextSquare = nextSquare * nextSquare;
 
    # Check which is nearest to N
    ans    = (prevSquare - n) if (n - prevSquare) < (nextSquare - n) else (nextSquare - n);
 
    # return the result
    return ans;
 
# Driver code
if __name__ == "__main__" :
 
    n = 14;
    print(nearest(n)) ;
 
    n = 16;
    print(nearest(n));
 
    n = 18;
    print(nearest(n));
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
 
class GFG {
         
    // Function to return the Least number
    static int nearest(int n)
    {
     
        // Get the perfect square
        // before and after N
        int prevSquare = (int)Math.Sqrt(n);
        int nextSquare = prevSquare + 1;
        prevSquare = prevSquare * prevSquare;
        nextSquare = nextSquare * nextSquare;
     
        // Check which is nearest to N
        int ans = (n - prevSquare) < (nextSquare - n)? (prevSquare - n): (nextSquare - n);
     
        // return the result
        return ans;
    }
     
    // Driver code
    public static void Main (string[] args)
    {
        int n = 14;
        Console.WriteLine(nearest(n));
     
        n = 16;
        Console.WriteLine(nearest(n)) ;
     
        n = 18;
        Console.WriteLine(nearest(n)) ;
     
    }
}
 
// This code is contributed by AnkitRai01

<script>
// Javascript implementation of the above approach
 
// Function to return the Least number
function nearest( n)
{
    // Get the perfect square
    // before and after N
    var prevSquare = parseInt(Math.sqrt(n));
    var nextSquare = prevSquare + 1;
    prevSquare = prevSquare * prevSquare;
    nextSquare = nextSquare * nextSquare;
 
    // Check which is nearest to N
     if((n - prevSquare) < (nextSquare - n))
     {
       ans = parseInt((prevSquare - n));
     }
     else
       ans = parseInt((nextSquare - n));
 
    // return the result
    return ans;
}
 
var  n = 14;
document.write( nearest(n) + "<br>");
 
n = 16;
document.write(  nearest(n)  + "<br>");
 
n = 18;
document.write(  nearest(n)  + "<br>");
 
 
// This code is contributed by SoumikMondal
</script>

2
0
-2

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