Encuentre los cuadrados perfectos pares e impares más cercanos de elementos de array pares e impares respectivamente

Dada una array arr[ ] de tamaño N , la tarea de cada elemento de la array es imprimir el cuadrado perfecto más cercano que tenga la misma paridad.

Ejemplos:

Entrada : arr[ ] = {6, 3, 2, 15}
Salida : 4 1 4 9
Explicación :
El cuadrado perfecto par más cercano de arr[0] (= 6) es 4.
El cuadrado perfecto impar más cercano de arr[1] (= 3) es 1.
El cuadrado perfecto par más cercano de arr[2] (= 2) es 4
El cuadrado perfecto impar más cercano de arr[3] (= 15) es 9.

Entrada : arr[ ] = {31, 18, 64}
Salida : 25 16 64

Enfoque: siga los pasos a continuación para resolver el problema:

• Recorra la array y realice las siguientes operaciones:
  • Encuentre la raíz cuadrada del elemento de array actual y guárdelo en una variable, digamos sr .
  • Si sr tiene la misma paridad que arr[i] , entonces sr*sr es el cuadrado perfecto más cercano .
  • De lo contrario, (sr + 1) ² es el cuadrado perfecto más cercano .
  • Imprime el cuadrado perfecto más cercano obtenido en el paso anterior.

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

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the nearest even and odd
// perfect squares for even and odd array elements
void nearestPerfectSquare(int arr[], int N)
{
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Calculate square root of
        // current array element
        int sr = sqrt(arr[i]);
 
        // If both are of same parity
        if ((sr & 1) == (arr[i] & 1))
            cout << sr * sr << " ";
 
      // Otherwise
        else {
            sr++;
            cout << sr * sr << " ";
        }
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 6, 3, 2, 15 };
    int N = sizeof(arr) / sizeof(arr[0]);
    nearestPerfectSquare(arr, N);
    return 0;
}

// Java program to implement
// the above approach
import java.util.*;
 
class GFG
{
 
// Function to find the nearest even and odd
// perfect squares for even and odd array elements
static void nearestPerfectSquare(int arr[], int N)
{
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Calculate square root of
        // current array element
        int sr = (int)Math.sqrt(arr[i]);
 
        // If both are of same parity
        if ((sr & 1) == (arr[i] & 1))
            System.out.print((sr * sr) + " ");
 
      // Otherwise
        else {
            sr++;
            System.out.print((sr * sr) + " ");
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 6, 3, 2, 15 };
    int N = arr.length;
    nearestPerfectSquare(arr, N);
}
}
 
// This code is contributed by souravghosh0416.

# Python3 program for the above approach
import math
 
# Function to find the nearest even and odd
# perfect squares for even and odd array elements
def nearestPerfectSquare(arr, N) :
 
    # Traverse the array
    for i in range(N):
 
        # Calculate square root of
        # current array element
        sr = int(math.sqrt(arr[i]))
 
        # If both are of same parity
        if ((sr & 1) == (arr[i] & 1)) :
            print(sr * sr, end = " ")
 
      # Otherwise
        else :
            sr += 1
            print(sr * sr, end = " ")
         
# Driver Code
arr = [ 6, 3, 2, 15 ]
N = len(arr)
nearestPerfectSquare(arr, N)
 
# This code is contributed by sanjoy_62.

// C# program for the above approach
using System;
 
class GFG{
 
  // Function to find the nearest even and odd
  // perfect squares for even and odd array elements
  static void nearestPerfectSquare(int[] arr, int N)
  {
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
      // Calculate square root of
      // current array element
      int sr = (int)Math.Sqrt(arr[i]);
 
      // If both are of same parity
      if ((sr & 1) == (arr[i] & 1))
        Console.Write((sr * sr) + " ");
 
      // Otherwise
      else {
        sr++;
        Console.Write((sr * sr) + " ");
      }
    }
  }
   
  // Driver Code
  static public void Main()
  {
    int[] arr = { 6, 3, 2, 15 };
    int N = arr.Length;
    nearestPerfectSquare(arr, N);
  }
}
 
// This code is contributed by splevel62.

<script>
 
// Javascript program to implement
// the above approach
 
// Function to find the nearest even and odd
// perfect squares for even and odd array elements
function nearestPerfectSquare(arr, N)
{
     
    // Traverse the array
    for(let i = 0; i < N; i++)
    {
         
        // Calculate square root of
        // current array element
        let sr = Math.floor(Math.sqrt(arr[i]));
 
        // If both are of same parity
        if ((sr & 1) == (arr[i] & 1))
            document.write((sr * sr) + " ");
 
        // Otherwise
        else
        {
            sr++;
            document.write((sr * sr) + " ");
        }
    }
}
 
// Driver code
     
// Given array
let arr = [ 6, 3, 2, 15 ];
let N = arr.length;
 
nearestPerfectSquare(arr, N);
 
// This code is contributed by target_2
 
</script>

4 1 4 9

Complejidad de Tiempo: O(N * M)
Espacio Auxiliar: O(1)