Área mínima del cuadrado que contiene dos rectángulos idénticos

Dada la longitud L y la anchura B de dos rectángulos idénticos, la tarea es encontrar el área mínima de un cuadrado en el que se pueden incrustar los dos rectángulos idénticos con dimensiones L × B.
Ejemplos: 
 

Entrada: L = 7, B = 4 
Salida: 64 
Explicación: Dos rectángulos con lados 7 x 4 pueden encajar en un cuadrado con lado 8. Al colocar dos rectángulos con lado 4 uno sobre el otro y la longitud del contacto es 7.
Entrada: L = 1, B = 3 
Salida: 9 
Explicación: Dos rectángulos con lados 1 x 3 pueden encajar en un cuadrado con lado 3. Colocando dos rectángulos con lado 1 uno sobre el otro y un espacio de 1 entre los 2 rectángulos. 
 

Acercarse: 
 

• Si un lado del rectángulo es menor o igual a la mitad de la longitud del otro lado, entonces el lado del cuadrado es el lado más largo del rectángulo.
• Si el doble de la longitud del lado menor es mayor que el lado mayor, entonces el lado del cuadrado es el doble de la longitud del lado menor del rectángulo.

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

// C++ program for the above problem
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// area of the square
int areaSquare(int L, int B)
{
    // Larger side of rectangle
    int large = max(L, B);
 
    // Smaller side of the rectangle
    int small = min(L, B);
 
    if (large >= 2 * small)
        return large * large;
    else
        return (2 * small) * (2 * small);
}
 
// Driver code
int main()
{
    int L = 7;
    int B = 4;
    cout << areaSquare(L, B);
    return 0;
}

// Java implementation of the above approach
import java.io.*;
 
class GFG{
 
// Function to find the
// area of the square
static int areaSquare(int L, int B)
{
     
    // Larger side of rectangle
    int large = Math.max(L, B);
 
    // Smaller side of the rectangle
    int small = Math.min(L, B);
 
    if (large >= 2 * small)
    {
        return large * large;
    }
    else
    {
        return (2 * small) * (2 * small);
    }
}
 
// Driver code
public static void main(String[] args)
{
    int L = 7;
    int B = 4;
     
    System.out.println(areaSquare(L, B));
}
}
 
// This code is contributed by offbeat

# Python3 program for the above problem
 
# Function to find the
# area of the square
def areaSquare(L, B):
 
    # Larger side of rectangle
    large = max(L, B)
 
    # Smaller side of the rectangle
    small = min(L, B)
 
    if(large >= 2 * small):
        return large * large
    else:
        return (2 * small) * (2 * small)
         
# Driver code
if __name__ == '__main__':
 
    L = 7
    B = 4
     
    print(areaSquare(L, B))
 
# This code is contributed by Shivam Singh

// C# program for the above problem
using System;
 
class GFG{
 
// Function to find the
// area of the square
public static int areaSquare(int L, int B)
{
     
    // Larger side of rectangle
    int large = Math.Max(L, B);
 
    // Smaller side of the rectangle
    int small = Math.Min(L, B);
 
    if (large >= 2 * small)
    {
        return large * large;
    }
    else
    {
        return (2 * small) * (2 * small);
    }
}
 
// Driver code
public static void Main()
{
    int L = 7;
    int B = 4;
     
    Console.Write(areaSquare(L, B));
}
}
 
// This code is contributed by Code_Mech

<script>
 
// Javascript implementation of the above approach
 
// Function to find the
// area of the square
function areaSquare(L, B)
{
       
    // Larger side of rectangle
    let large = Math.max(L, B);
   
    // Smaller side of the rectangle
    let small = Math.min(L, B);
   
    if (large >= 2 * small)
    {
        return large * large;
    }
    else
    {
        return (2 * small) * (2 * small);
    }
}
  
  // Driver Code
     
    let L = 7;
    let B = 4;
       
    document.write(areaSquare(L, B));
      
</script>

64

Complejidad de Tiempo: O(1) 
Complejidad de Espacio Auxiliar: O(1)