Skip to content
Related Articles

Related Articles

Height of Pyramid formed with given Rectangular Box

View Discussion
Improve Article
Save Article
  • Last Updated : 20 Feb, 2022
View Discussion
Improve Article
Save Article

Given an array of rectangular blocks with dimensions {l, b} of length m. we can shape each rectangular block into a single square block by trimming either one of its dimensions or both. With these square blocks, a pyramid is formed. Our task is to find the maximum height of the pyramid that can be formed. 
Note: 
A pyramid is built by placing a square block, say N * N, at the base, placing another square block N-1 * N-1 on top of that, a square block of N-2 * N-2 on top of that, and so on, ending with a 1*1 block on top. The height of such a pyramid is N.

Examples: 

Input: n = 4, arr[] = {{8, 8}, {2, 8}, {4, 2}, {2, 1}} 
Output: Height of pyramid is 3 
Explanation: 
{8, 8} blocks can be trimmed to {3, 3} 
{2, 8} block can be trimmed to {2, 2} or {4, 2} block can be trimmed to {2, 2} 
{2, 1} block can be trimmed to {1, 1} 
so the height of the pyramid is 3

Input: n = 5, arr[] = {{9, 8}, {7, 4}, {8, 1}, {4, 4}, {2, 1}} 
Output: Height of pyramid is 4 

Approach: 

  • We have to make dimensions for every block as
l * l or b * b
  • Since we can only trim but not join, we choose the dimensions of the square block as min(l, b)
  • Create an array a with the MIN(l, b) on every rectangular block
  • sort the array a and initialize the height to 0
  • Traverse through array a if the element in the array is greater than height + 1 
    then increment the value of height by 1.
  • return height

C++




#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);
}

Java




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));
    }
}

Python




# 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))

C#




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

Javascript




<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>

 
 

Output: 

Height of pyramid is  3

 

Time Complexity: O(n * log n)

Auxiliary Space: O(n)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!