Find the Side of the smallest Square that can contain given 4 Big Squares
Last Updated :
08 May, 2023
Given sides of four small squares. You have to find the side of the smallest square such that it can contain all given 4 squares without overlapping. The side of a square can be up to 10^16.
Examples:
Input: side1 = 2, side2 = 2, side3 = 2, side4 = 2
Output: 4
Input: side1 = 100000000000000, side2 = 123450000000000,
side3 = 987650000000000, side4 = 987654321000000
Output: 1975304321000000
Approach:
It is given that no two squares will overlap. Therefore to find the side of the smallest suitable square, we will find all four sides, when squares will be put in 2 x 2 manner. That is 2 squares will be side by side and rest 2 will be put together.
So we calculate all four side and select one that will be maximum.
Example: When all small squares are of same side.
-
-
-
Example: When all small squares are of different side.
-
-
-
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long long int max( long long a, long long b)
{
if (a > b)
return a;
else
return b;
}
long long int smallestSide( long long int a[])
{
sort(a, a + 4);
long long side1, side2, side3, side4,
side11, side12, sideOfSquare;
side1 = a[0] + a[3];
side2 = a[1] + a[2];
side3 = a[0] + a[1];
side4 = a[2] + a[3];
side11 = max(side1, side2);
side12 = max(side3, side4);
sideOfSquare = max(side11, side12);
return sideOfSquare;
}
int main()
{
long long int side[4];
cout << "Test Case 1\n" ;
side[0] = 2;
side[1] = 2;
side[2] = 2;
side[3] = 2;
cout << smallestSide(side) << endl;
cout << "\nTest Case 2\n" ;
side[0] = 100000000000000;
side[1] = 123450000000000;
side[2] = 987650000000000;
side[3] = 987654321000000;
cout << smallestSide(side) << endl;
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static long max( long a, long b)
{
if (a > b)
return a;
else
return b;
}
static long smallestSide( long a[])
{
Arrays.sort(a);
long side1, side2, side3, side4,
side11, side12, sideOfSquare;
side1 = a[ 0 ] + a[ 3 ];
side2 = a[ 1 ] + a[ 2 ];
side3 = a[ 0 ] + a[ 1 ];
side4 = a[ 2 ] + a[ 3 ];
side11 = max(side1, side2);
side12 = max(side3, side4);
sideOfSquare = max(side11, side12);
return sideOfSquare;
}
public static void main(String[] args)
{
long side[] = new long [ 4 ];
System.out.println( "Test Case 1" );
side[ 0 ] = 2 ;
side[ 1 ] = 2 ;
side[ 2 ] = 2 ;
side[ 3 ] = 2 ;
System.out.println(smallestSide(side));
System.out.println( "\nTest Case 2" );
side[ 0 ] = 100000000000000L;
side[ 1 ] = 123450000000000L;
side[ 2 ] = 987650000000000L;
side[ 3 ] = 987654321000000L;
System.out.println(smallestSide(side));
}
}
|
Python3
def max (a, b):
if (a > b):
return a
else :
return b
def smallestSide(a):
a.sort(reverse = False )
side1 = a[ 0 ] + a[ 3 ]
side2 = a[ 1 ] + a[ 2 ]
side3 = a[ 0 ] + a[ 1 ]
side4 = a[ 2 ] + a[ 3 ]
side11 = max (side1, side2)
side12 = max (side3, side4)
sideOfSquare = max (side11, side12)
return sideOfSquare
if __name__ = = '__main__' :
side = [ 0 for i in range ( 4 )]
print ( "Test Case 1" )
side[ 0 ] = 2
side[ 1 ] = 2
side[ 2 ] = 2
side[ 3 ] = 2
print (smallestSide(side))
print ( "\n" , end = "")
print ( "Test Case 2" )
side[ 0 ] = 100000000000000
side[ 1 ] = 123450000000000
side[ 2 ] = 987650000000000
side[ 3 ] = 987654321000000
print (smallestSide(side))
|
C#
using System;
class GFG
{
static long max( long a, long b)
{
if (a > b)
return a;
else
return b;
}
static long smallestSide( long []a)
{
Array.Sort(a);
long side1, side2, side3, side4,
side11, side12, sideOfSquare;
side1 = a[0] + a[3];
side2 = a[1] + a[2];
side3 = a[0] + a[1];
side4 = a[2] + a[3];
side11 = max(side1, side2);
side12 = max(side3, side4);
sideOfSquare = max(side11, side12);
return sideOfSquare;
}
public static void Main(String[] args)
{
long []side = new long [4];
Console.WriteLine( "Test Case 1" );
side[0] = 2;
side[1] = 2;
side[2] = 2;
side[3] = 2;
Console.WriteLine(smallestSide(side));
Console.WriteLine( "\nTest Case 2" );
side[0] = 100000000000000L;
side[1] = 123450000000000L;
side[2] = 987650000000000L;
side[3] = 987654321000000L;
Console.WriteLine(smallestSide(side));
}
}
|
PHP
<?php
function max1( $a , $b )
{
if ( $a > $b )
return $a ;
else
return $b ;
}
function smallestSide( $a )
{
sort( $a , 0);
$side1 = $a [0] + $a [3];
$side2 = $a [1] + $a [2];
$side3 = $a [0] + $a [1];
$side4 = $a [2] + $a [3];
$side11 = max1( $side1 , $side2 );
$side12 = max1( $side3 , $side4 );
$sideOfSquare = max1( $side11 , $side12 );
return $sideOfSquare ;
}
$side = array ();
echo "Test Case 1\n" ;
$side [0] = 2;
$side [1] = 2;
$side [2] = 2;
$side [3] = 2;
echo smallestSide( $side ) . "\n" ;
echo "\nTest Case 2\n" ;
$side [0] = 100000000000000;
$side [1] = 123450000000000;
$side [2] = 987650000000000;
$side [3] = 987654321000000;
echo smallestSide( $side ) . "\n" ;
?>
|
Javascript
<script>
function max(a , b)
{
if (a > b)
return a;
else
return b;
}
function smallestSide(a)
{
a.sort();
var side1, side2, side3, side4,
side11, side12, sideOfSquare;
side1 = a[0] + a[3];
side2 = a[1] + a[2];
side3 = a[0] + a[1];
side4 = a[2] + a[3];
side11 = max(side1, side2);
side12 = max(side3, side4);
sideOfSquare = max(side11, side12);
return sideOfSquare;
}
var side = Array.from({length: 4}, (_, i) => 0);
document.write( "Test Case 1<br>" );
side[0] = 2;
side[1] = 2;
side[2] = 2;
side[3] = 2;
document.write(smallestSide(side));
document.write( "<br>Test Case 2<br>" );
side[0] = 100000000000000;
side[1] = 123450000000000;
side[2] = 987650000000000;
side[3] = 987654321000000;
document.write(smallestSide(side));
</script>
|
Output:
Test Case 1
4
Test Case 2
1975304321000000
Time Complelxity: O(n log n)
Space Complexity: O(1)
Share your thoughts in the comments
Please Login to comment...