Número de círculos más grandes que se pueden inscribir en un rectángulo

Dados dos números enteros L y B que representan el largo y el ancho de un rectángulo , la tarea es encontrar el número máximo de círculos más grandes posibles que se pueden inscribir en el rectángulo dado sin superponerse.

Ejemplos:

Entrada: L = 3, B = 8
Salida: 2
Explicación:

De la figura anterior se puede ver claramente que el círculo más grande con un diámetro de 3 cm se puede inscribir en el rectángulo dado.
Por lo tanto, la cuenta de tales círculos es 2.

Entrada: L = 2, B = 9
Salida: 4

Enfoque: El problema dado se puede resolver con base en las siguientes observaciones:

• El círculo más grande que se puede inscribir en un rectángulo tendrá un diámetro igual al lado más pequeño del rectángulo.
• Por lo tanto, el número máximo posible de tales círculos más grandes es igual a (Longitud del lado más grande) / (Longitud del lado más pequeño) .

Por lo tanto, a partir de la observación anterior, simplemente imprima el valor de (Longitud del lado más grande) / (Longitud del lado más pequeño) como el resultado requerido.

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

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// largest circles in a rectangle
int totalCircles(int L, int B)
{
    // If length exceeds breadth
    if (L > B) {
 
        // Swap to reduce length
        // to smaller than breadth
        int temp = L;
        L = B;
        B = temp;
    }
 
    // Return total count
    // of circles inscribed
    return B / L;
}
 
// Driver Code
int main()
{
    int L = 3;
    int B = 8;
    cout << totalCircles(L, B);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to count the number of
  // largest circles in a rectangle
  static int totalCircles(int L, int B)
  {
    // If length exceeds breadth
    if (L > B) {
 
      // Swap to reduce length
      // to smaller than breadth
      int temp = L;
      L = B;
      B = temp;
    }
 
    // Return total count
    // of circles inscribed
    return B / L;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int L = 3;
    int B = 8;
    System.out.print(totalCircles(L, B));
  }
}
 
// This code is contributed by susmitakundugoaldanga.

# Python3 program for the above approach
 
# Function to count the number of
# largest circles in a rectangle
def totalCircles(L, B) :
     
    # If length exceeds breadth
    if (L > B) :
 
        # Swap to reduce length
        # to smaller than breadth
        temp = L
        L = B
        B = temp
     
    # Return total count
    # of circles inscribed
    return B // L
 
# Driver Code
L = 3
B = 8
print(totalCircles(L, B))
 
# This code is contributed by splevel62.

// C# program to implement
// the above approach
using System;
public class GFG
{
 
  // Function to count the number of
  // largest circles in a rectangle
  static int totalCircles(int L, int B)
  {
    // If length exceeds breadth
    if (L > B) {
 
      // Swap to reduce length
      // to smaller than breadth
      int temp = L;
      L = B;
      B = temp;
    }
 
    // Return total count
    // of circles inscribed
    return B / L;
  }
 
 
  // Driver Code
  public static void Main(String[] args)
  {
    int L = 3;
    int B = 8;
    Console.Write(totalCircles(L, B));
  }
}
 
// This code is contributed by souravghosh0416.

<script>
 
// javascript program to implement
// the above approach
 
  
  // Function to count the number of
  // largest circles in a rectangle
   
  function  totalCircles( L,  B)
  {
    // If length exceeds breadth
    if (L > B) {
  
      // Swap to reduce length
      // to smaller than breadth
       
      var temp = L;
      L = B;
      B = temp;
    }
  
    // Return total count
    // of circles inscribed
    return B / L;
  }
  
  
  // Driver Code
 
    var L = 3;
    var B = 8;
    document.write(totalCircles(L, B).toString().split('.')[0]);
   
 
</script>

2

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