Encuentre un punto que se encuentre exactamente dentro de K cuadrados dados

Dado un entero K y una array arr , cada uno de cuyos elementos x representa un cuadrado con dos de sus vértices como (0, 0) y (x, x) . La tarea es encontrar un punto que se encuentre exactamente en K cuadrados.
Ejemplos: 
 

Entrada: arr[] = {1, 2, 3, 4}, K = 2 
Salida: (3, 3) 
El punto (3, 3) se encuentra dentro del tercer y cuarto cuadrado solamente.
Entrada: arr[] = {8, 1, 55, 90}, K = 3 
Salida: (8, 8) 
 

Enfoque: dado que todos los cuadrados tienen un punto de esquina común (0, 0), cualquier punto que se encuentre en cualquier cuadrado también se encontrará en cualquier cuadrado más grande. Por lo tanto, podemos simplemente imprimir la otra esquina del K-ésimo cuadrado más grande.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
int PointInKSquares(int n, int a[], int k)
{
    sort(a, a + n);
    return a[n - k];
}
 
// Driver Program to test above function
int main()
{
    int k = 2;
    int a[] = { 1, 2, 3, 4 };
    int n = sizeof(a) / sizeof(a[0]);
 
    int x = PointInKSquares(n, a, k);
    cout << "(" << x << ", " << x << ")";
}

// Java implementation of the approach
 
import java.io.*;
import java.util.*;
class GFG {
 
 
static int PointInKSquares(int n, int a[], int k)
{
    Arrays.sort(a);
    return a[n - k];
}
 
// Driver Program to test above function
 
    public static void main (String[] args) {
            int k = 2;
    int []a = { 1, 2, 3, 4 };
    int n = a.length;
 
    int x = PointInKSquares(n, a, k);
    System.out.println( "(" + x + ", " + x +")");
 
     
    }
}
// This code is contributed by anuj_67..

# Python 3 implementation of the
# above approach
def PointInKSquares(n, a, k) :
     
    a.sort()
    return a[n - k]
 
# Driver Code
if __name__ == "__main__" :
     
    k = 2
    a = [1, 2, 3, 4]
    n = len(a)
     
    x = PointInKSquares(n, a, k)
    print("(", x, ",", x, ")")
 
# This code is contributed by Ryuga

// C# implementation of the approach
using System;
class GFG
{
 
static int PointInKSquares(int n,
                           int []a, int k)
{
    Array.Sort(a);
    return a[n - k];
}
 
// Driver Code
public static void Main (String[] args)
{
    int k = 2;
    int []a = { 1, 2, 3, 4 };
    int n = a.Length;
     
    int x = PointInKSquares(n, a, k);
    Console.WriteLine("(" + x + ", " + x +")");
}
}
 
// This code is contributed
// by Arnab Kundu

<?php
// PHP implementation of the approach
 
function PointInKSquares($n, $a, $k)
{
    sort($a);
    return $a[$n - $k];
}
 
// Driver Code
$k = 2;
$a = array(1, 2, 3, 4);
$n = sizeof($a);
 
$x = PointInKSquares($n, $a, $k);
echo "(" . $x . ", " . $x . ")";
 
// This code is contributed
// by Akanksha Rai
?>

<script>
 
// Javascript implementation of the approach
 
 
function PointInKSquares(n, a, k)
{
    a.sort();
    return a[n - k];
}
 
// Driver Program to test above function
  
    let k = 2;
    let a = [ 1, 2, 3, 4 ];
    let n = a.length;
 
    let x = PointInKSquares(n, a, k);
    document.write("(" + x + ", " + x + ")");
 
// This code is contributed by Mayank Tyagi
 
</script>

(3, 3)

Complejidad de Tiempo: O(nlog(n)), ya que para ordenar los elementos del arreglo, el mejor algoritmo toma (n * log n) tiempo.
Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.