Dada la longitud L y la anchura B de una hoja de papel, la tarea es encontrar el número máximo de rectángulos con la longitud l y la anchura b dadas que se pueden cortar de esta hoja de papel.
Ejemplos:
Entrada: L = 5, B = 2, l = 14, b = 3
Salida: 0
La hoja es más pequeña que el rectángulo requerido. Por lo tanto, ningún rectángulo de la dimensión dada se puede cortar de la hoja.
Entrada: L = 10, B = 7, l = 4, b = 3
Salida: 4
Acercarse:
- Intente cortar los rectángulos horizontalmente, es decir, la longitud del rectángulo se alinea con la longitud de la hoja y el ancho del rectángulo se alinea con el ancho de la hoja y almacene la cantidad de rectángulos posibles en horizontal .
- Repita lo mismo con la alineación vertical, es decir, cuando la longitud del rectángulo esté alineada con el ancho de la hoja y el ancho del rectángulo esté alineado con la longitud de la hoja y almacene el resultado en vertical . Imprime max(horizontal, vertical) como resultado.
A continuación se muestra la implementación del enfoque anterior:
C++
// CPP implementation of the approach
#include<bits/stdc++.h>
using namespace std;
// Function to return the maximum rectangles possible
int maxRectangles(int L, int B, int l, int b)
{
int horizontal = 0, vertical = 0;
// Cut rectangles horizontally if possible
if (l <= L && b <= B)
{
// One rectangle is a single cell
int columns = B / b;
int rows = L / l;
// Total rectangles = total cells
horizontal = rows * columns;
}
// Cut rectangles vertically if possible
if (l <= B && b <= L)
{
int columns = L / b;
int rows = B / l;
vertical = rows * columns;
}
// Return the maximum possible rectangles
return max(horizontal, vertical);
}
// Driver code
int main()
{
int L = 10, B = 7, l = 4, b = 3;
cout << (maxRectangles(L, B, l, b)) << endl;
}
// This code is contributed by
// Sanjit_Prasad
Java
// Java implementation of the approach
class GFG {
// Function to return the maximum rectangles possible
static int maxRectangles(int L, int B, int l, int b)
{
int horizontal = 0, vertical = 0;
// Cut rectangles horizontally if possible
if (l <= L && b <= B) {
// One rectangle is a single cell
int columns = B / b;
int rows = L / l;
// Total rectangles = total cells
horizontal = rows * columns;
}
// Cut rectangles vertically if possible
if (l <= B && b <= L) {
int columns = L / b;
int rows = B / l;
vertical = rows * columns;
}
// Return the maximum possible rectangles
return Math.max(horizontal, vertical);
}
// Driver code
public static void main(String[] args)
{
int L = 10, B = 7, l = 4, b = 3;
System.out.print(maxRectangles(L, B, l, b));
}
}
Python3
# Python3 implementation of the approach # Function to return the maximum # rectangles possible def maxRectangles(L, B, l, b): horizontal, vertical = 0, 0 # Cut rectangles horizontally if possible if l <= L and b <= B: # One rectangle is a single cell columns = B // b rows = L // l # Total rectangles = total cells horizontal = rows * columns # Cut rectangles vertically if possible if l <= B and b <= L: columns = L // b rows = B // l vertical = rows * columns # Return the maximum possible rectangles return max(horizontal, vertical) # Driver code if __name__ == "__main__": L, B, l, b = 10, 7, 4, 3 print(maxRectangles(L, B, l, b)) # This code is contributed by Rituraj Jain
C#
// C# implementation of the above approach
using System;
class GFG
{
// Function to return the
// maximum rectangles possible
static int maxRectangles(int L, int B,
int l, int b)
{
int horizontal = 0, vertical = 0;
// Cut rectangles horizontally if possible
if (l <= L && b <= B)
{
// One rectangle is a single cell
int columns = B / b;
int rows = L / l;
// Total rectangles = total cells
horizontal = rows * columns;
}
// Cut rectangles vertically if possible
if (l <= B && b <= L)
{
int columns = L / b;
int rows = B / l;
vertical = rows * columns;
}
// Return the maximum possible rectangles
return Math.Max(horizontal, vertical);
}
// Driver code
public static void Main()
{
int L = 10, B = 7, l = 4, b = 3;
Console.WriteLine(maxRectangles(L, B, l, b));
}
}
// This code is contributed by Ryuga
PHP
<?php
// PHP implementation of the approach
// Function to return the maximum
// rectangles possible
function maxRectangles($L, $B, $l, $b)
{
$horizontal = 0;
$vertical = 0;
// Cut rectangles horizontally if possible
if ($l <= $L && $b <= $B)
{
// One rectangle is a single cell
$columns = (int)($B / $b);
$rows = (int)($L / $l);
// Total rectangles = total cells
$horizontal = $rows * $columns;
}
// Cut rectangles vertically if possible
if ($l <= $B && $b <= $L)
{
$columns = (int)($L / $b);
$rows = (int)($B / $l);
$vertical = $rows * $columns;
}
// Return the maximum possible rectangles
return max($horizontal, $vertical);
}
// Driver code
$L = 10;
$B = 7;
$l = 4;
$b = 3;
print(maxRectangles($L, $B, $l, $b));
// This code is contributed by mits
?>
Javascript
<script>
// Javascript implementation of the approach
// Function to return the maximum
// rectangles possible
function maxRectangles(L, B, l, b)
{
var horizontal = 0, vertical = 0;
// Cut rectangles horizontally
// if possible
if (l <= L && b <= B)
{
// One rectangle is a single cell
var columns = parseInt(B / b);
var rows = parseInt(L / l);
// Total rectangles = total cells
horizontal = rows * columns;
}
// Cut rectangles vertically if possible
if (l <= B && b <= L)
{
var columns = parseInt(L / b);
var rows = parseInt(B / l);
vertical = rows * columns;
}
// Return the maximum possible rectangles
return Math.max(horizontal, vertical);
}
// Driver Code
var L = 10, B = 7, l = 4, b = 3;
document.write(maxRectangles(L, B, l, b));
// This code is contributed by kirti
</script>
Producción:
4
Complejidad de Tiempo: O(1), ya que solo hay una operación aritmética básica que toma tiempo constante.
Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.
Publicación traducida automáticamente
Artículo escrito por Vivek.Pandit y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA