Número de círculos más pequeños que se pueden inscribir en un círculo más grande

Posted on by Rudeus Greyrat

Dados dos números enteros positivos R1 y R2 , donde R1 y R2 representan el radio de los círculos más grande y más pequeño respectivamente, la tarea es encontrar el número de círculos más pequeños que se pueden colocar dentro del círculo más grande de modo que el círculo más pequeño toque el límite. del círculo mayor.

Ejemplos:

Entrada: R1 = 3, R2 = 1
Salida: 6
Explicación: Los radios de los círculos son 3 y 1. Por lo tanto, el círculo de radio 1 se puede inscribir en el círculo de radio 3.

De la representación anterior, el número total de círculos más pequeños que se pueden inscribir tocando el límite del círculo más grande es 6.

Entrada: R1 = 5, R2 = 4
Salida: 1

 

Enfoque: El problema dado se puede resolver encontrando el ángulo que forma el círculo más pequeño de radio R2 en el centro del círculo con radio R1 y luego dividiéndolo por 360 grados . 
Siga los pasos a continuación para resolver el problema dado:

  • Si el valor de R1 es menor que R2 , entonces es imposible inscribir un solo círculo. Por lo tanto, imprima 0 .
  • Si el valor de R1 es menor que 2 * R2 , es decir, si el diámetro del círculo más pequeño es mayor que el radio del círculo más grande, entonces solo se puede inscribir un círculo. Por lo tanto, imprima 1 .
  • De lo contrario, encuentre el ángulo formado por el círculo más pequeño en el centro del círculo más grande usando la fórmula a continuación y luego, divida por 360 grados para obtener el número total de círculos que se pueden inscribir e imprima ese valor.

\frac{1}{\pi}{|sin^{-1}(\frac{R2}{R1-R2}) * 180|}

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

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count number of smaller
// circles that can be inscribed in
// the larger circle touching its boundary
int countInscribed(int R1, int R2)
{
    // If R2 is greater than R1
    if (R2 > R1)
        return 0;
 
    // Stores the angle made
    // by the smaller circle
    double angle;
 
    // Stores the ratio
    // of R2 / (R1 - R2)
    double ratio;
 
    // Stores the count of smaller
    // circles that can be inscribed
    int number_of_circles = 0;
 
    // Stores the ratio
    ratio = R2 / (double)(R1 - R2);
 
    // If the diameter of smaller
    // circle is greater than the
    // radius of the larger circle
    if (R1 < 2 * R2) {
        number_of_circles = 1;
    }
 
    // Otherwise
    else {
 
        // Find the angle using formula
        angle = abs(asin(ratio) * 180)
                / 3.14159265;
 
        // Divide 360 with angle
        // and take the floor value
        number_of_circles = 360
                            / (2
                               * floor(angle));
    }
 
    // Return the final result
    return number_of_circles;
}
 
// Driver Code
int main()
{
    int R1 = 3;
    int R2 = 1;
 
    cout << countInscribed(R1, R2);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
  
// Function to count number of smaller
// circles that can be inscribed in
// the larger circle touching its boundary
static int countInscribed(int R1, int R2)
{
     
    // If R2 is greater than R1
    if (R2 > R1)
        return 0;
 
    // Stores the angle made
    // by the smaller circle
    double angle;
 
    // Stores the ratio
    // of R2 / (R1 - R2)
    double ratio;
 
    // Stores the count of smaller
    // circles that can be inscribed
    int number_of_circles = 0;
 
    // Stores the ratio
    ratio = R2 / (double)(R1 - R2);
 
    // If the diameter of smaller
    // circle is greater than the
    // radius of the larger circle
    if (R1 < 2 * R2)
    {
        number_of_circles = 1;
    }
 
    // Otherwise
    else
    {
         
        // Find the angle using formula
        angle = Math.abs(Math.asin(ratio) * 180) /
                3.14159265;
 
        // Divide 360 with angle
        // and take the floor value
        number_of_circles = (int)(360 /
        (2 * Math.floor(angle)));
    }
     
    // Return the final result
    return number_of_circles;
}
 
// Driver Code
public static void main(String args[])
{
    int R1 = 3;
    int R2 = 1;
     
    System.out.println(countInscribed(R1, R2));
}
}
 
// This code is contributed by ipg2016107

Python3

# Python3 program for the above approach
import math
 
# Function to count number of smaller
# circles that can be inscribed in
# the larger circle touching its boundary
def countInscribed(R1, R2):
     
    # If R2 is greater than R1
    if (R2 > R1):
        return 0
 
    # Stores the angle made
    # by the smaller circle
    angle = 0
 
    # Stores the ratio
    # of R2 / (R1 - R2)
    ratio = 0
 
    # Stores the count of smaller
    # circles that can be inscribed
    number_of_circles = 0
 
    # Stores the ratio
    ratio = R2 / (R1 - R2)
 
    # If the diameter of smaller
    # circle is greater than the
    # radius of the larger circle
    if (R1 < 2 * R2):
        number_of_circles = 1
     
    # Otherwise
    else:
 
        # Find the angle using formula
        angle = (abs(math.asin(ratio) * 180) /
                 3.14159265)
        
        # Divide 360 with angle
        # and take the floor value
        number_of_circles = (360 / (2 *
               math.floor(angle)))
     
    # Return the final result
    return number_of_circles
 
# Driver Code
if __name__ == "__main__":
 
    R1 = 3
    R2 = 1
 
    print (int(countInscribed(R1, R2)))
 
# This code is contributed by ukasp

C#

// C# program for the above approach
using System;
 
class GFG{
  
// Function to count number of smaller
// circles that can be inscribed in
// the larger circle touching its boundary
static int countInscribed(int R1, int R2)
{
     
    // If R2 is greater than R1
    if (R2 > R1)
        return 0;
 
    // Stores the angle made
    // by the smaller circle
    double angle;
 
    // Stores the ratio
    // of R2 / (R1 - R2)
    double ratio;
 
    // Stores the count of smaller
    // circles that can be inscribed
    int number_of_circles = 0;
 
    // Stores the ratio
    ratio = R2 / (double)(R1 - R2);
 
    // If the diameter of smaller
    // circle is greater than the
    // radius of the larger circle
    if (R1 < 2 * R2)
    {
        number_of_circles = 1;
    }
 
    // Otherwise
    else
    {
         
        // Find the angle using formula
        angle = Math.Abs(Math.Asin(ratio) * 180) /
                3.14159265;
 
        // Divide 360 with angle
        // and take the floor value
        number_of_circles = (int)(360 /
        (2 * Math.Floor(angle)));
    }
     
    // Return the final result
    return number_of_circles;
}
 
// Driver Code
public static void Main()
{
    int R1 = 3;
    int R2 = 1;
     
    Console.WriteLine(countInscribed(R1, R2));
}
}
 
// This code is contributed by mohit kumar 29

Javascript

<script>
 
        // Javascript program for the above approach
 
        // Function to count number of smaller
        // circles that can be inscribed in
        // the larger circle touching its boundary
        function countInscribed(R1, R2)
        {
            // If R2 is greater than R1
            if (R2 > R1)
                return 0;
 
            // Stores the angle made
            // by the smaller circle
            let angle;
 
            // Stores the ratio
            // of R2 / (R1 - R2)
            let ratio;
 
            // Stores the count of smaller
            // circles that can be inscribed
            let number_of_circles = 0;
 
            // Stores the ratio
            ratio = R2 / (R1 - R2);
 
            // If the diameter of smaller
            // circle is greater than the
            // radius of the larger circle
            if (R1 < 2 * R2) {
                number_of_circles = 1;
            }
 
            // Otherwise
            else {
 
                // Find the angle using formula
                angle = Math.abs(Math.asin(ratio) * 180)
                    / 3.14159265;
 
                // Divide 360 with angle
                // and take the floor value
                number_of_circles = 360
                    / (2
                        * Math.floor(angle));
            }
 
            // Return the final result
            return number_of_circles;
        }
 
        // Driver Code
 
        let R1 = 3;
        let R2 = 1;
 
        document.write(countInscribed(R1, R2))
 
        // This code is contributed by Hritik
         
    </script>
Producción: 

6

 

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

Publicación traducida automáticamente

Artículo escrito por thakurabhaysingh445 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *