Altura de la pirámide formada con caja rectangular dada

Dada una array de bloques rectangulares con dimensiones {l, b} de longitud m . podemos dar forma a cada bloque rectangular en un solo bloque cuadrado recortando una de sus dimensiones o ambas. Con estos bloques cuadrados se forma una pirámide. Nuestra tarea es encontrar la altura máxima de la pirámide que se puede formar. 
Nota: 
una pirámide se construye colocando un bloque cuadrado, digamos N * N, en la base, colocando otro bloque cuadrado N-1 * N-1 encima de eso, un bloque cuadrado de N-2 * N-2 en la parte superior de eso, y así sucesivamente, terminando con un bloque 1*1 en la parte superior. La altura de tal pirámide es N.

Ejemplos: 

Entrada: n = 4, arr[] = {{8, 8}, {2, 8}, {4, 2}, {2, 1}} 
Salida: la altura de la pirámide es 3 
Explicación: 
{8, 8} bloques se puede recortar a {3, 3} 
{2, 8} bloque se puede recortar a {2, 2} o {4, 2} bloque se puede recortar a {2, 2} 
{2, 1} bloque se puede recortar a {1, 1} 
entonces la altura de la pirámide es 3

Entrada: n = 5, arr[] = {{9, 8}, {7, 4}, {8, 1}, {4, 4}, {2, 1}} 
Salida: la altura de la pirámide es 4 

Acercarse: 

• Tenemos que hacer dimensiones para cada bloque como

l * l or b * b

• Como solo podemos recortar pero no unir, elegimos las dimensiones del bloque cuadrado como min(l, b)
• Cree una array a con el MIN (l, b) en cada bloque rectangular
• ordenar la array a e inicializar la altura a 0
• Recorra la array a si el elemento de la array es mayor que la altura + 1 
  , luego incremente el valor de la altura en 1.
• altura de retorno

#include <bits/stdc++.h>
#include <iostream>
 
using namespace std;
 
// Function to return
// The height of pyramid
int pyramid(int n, int arr[][2])
{
    vector<int> a;
    int height = 0;
    for (int i = 0; i < n; i++) {
        // For every ith array
        // append the minimum value
        // between two elements
        a.push_back(min(arr[i][0], arr[i][1]));
    }
    sort(a.begin(), a.end());
    for (int i = 0; i < a.size(); i++) {
        // if the element in array is
        // greater than height then
        // increment the value the
        // value of height by 1
        if (a[i] > height)
            height++;
    }
    return height;
}
 
// Driver code
int main()
{
    int n = 4;
    int arr[][2] = { { 8, 8 },
                     { 8, 2 },
                     { 4, 2 },
                     { 2, 1 } };
    cout << "Height of pyramid is "
         << pyramid(n, arr);
}

import java.util.*;
 
public class Gfg {
 
    static int pyramid(int n, int arr[][])
    {
        int[] a = new int[n];
        int height = 0;
 
        for (int i = 0; i < n; i++) {
 
            // For every ith array
            // append the minimum value
            // between two elements
            a[i] = arr[i][0] < arr[i][1]
                       ? arr[i][0]
                       : arr[i][1];
        }
 
        // sorting the array
        Arrays.sort(a);
        for (int i = 0; i < n; i++) {
 
            // if the element in array is
            // greater than height then
            // increment the value the
            // value of height by 1
            if (a[i] > height)
                height++;
        }
        return height;
    }
    public static void main(String[] args)
    {
        int n = 4;
        int arr[][] = { { 8, 8 },
                        { 8, 2 },
                        { 4, 2 },
                        { 2, 1 } };
        System.out.println("Height of pyramid is "
                           + pyramid(n, arr));
    }
}

# Function to return
# The height of pyramid
def pyramid(n, arr):
    # Empty array
    a = []
    height = 0
    for i in arr:
        # For every ith array
        # append the minimum value
        # between two elements
        a.append(min(i))
    # Sort the array
    a.sort()
    # Traverse through the array a
    for i in range(len(a)):
        # if the element in array is
        # greater than height then
        # increment the value the
        # value of height by 1
        if a[i] > height:
            height = height + 1
 
    return height
# Driver code
if __name__ == '__main__':
    n = 4
    arr = [[8, 8], [2, 8], [4, 2], [2, 1]]
    print("Height of pyramid is", pyramid(n, arr))

using System;
 
class Gfg
{
 
    static int pyramid(int n, int [,]arr)
    {
        int[] a = new int[n];
        int height = 0;
 
        for (int i = 0; i < n; i++)
        {
 
            // For every ith array
            // append the minimum value
            // between two elements
            a[i] = arr[i, 0] < arr[i, 1]
                    ? arr[i, 0]
                    : arr[i, 1];
        }
 
        // sorting the array
        Array.Sort(a);
        for (int i = 0; i < n; i++)
        {
 
            // if the element in array is
            // greater than height then
            // increment the value the
            // value of height by 1
            if (a[i] > height)
                height++;
        }
        return height;
    }
     
    // Driver code
    public static void Main()
    {
        int n = 4;
        int [,]arr = { { 8, 8 },
                        { 8, 2 },
                        { 4, 2 },
                        { 2, 1 } };
         
        Console.WriteLine("Height of pyramid is "
                        + pyramid(n, arr));
    }
}
 
// This code is contributed by AnkitRai01

<script>
// Function to return
// The height of pyramid
function pyramid(n, arr) {
    let a = new Array();
    let height = 0;
    for (let i = 0; i < n; i++) {
        // For every ith array
        // append the minimum value
        // between two elements
        a.push(Math.min(arr[i][0], arr[i][1]));
    }
    a.sort((a, b) => a - b);
    for (let i = 0; i < a.length; i++) {
        // if the element in array is
        // greater than height then
        // increment the value the
        // value of height by 1
        if (a[i] > height)
            height++;
    }
    return height;
}
 
// Driver code
 
let n = 4;
let arr = [[8, 8],
[8, 2],
[4, 2],
[2, 1]];
document.write("Height of pyramid is " + pyramid(n, arr));
 
</script>

Height of pyramid is  3

Complejidad de tiempo: O(n * log n)

Espacio Auxiliar: O(n)