Dibujar un círculo sin aritmética de punto flotante – Part 1

Dado el radio de un círculo, dibuje el círculo sin usar la aritmética de coma flotante.
El siguiente programa utiliza un concepto simple. Sea el radio del círculo r. Considere un cuadrado de tamaño (2r+1)*(2r+1) alrededor del círculo a dibujar. Ahora camina por todos los puntos dentro del cuadrado. Para cada punto (x,y), si (x, y) se encuentra dentro del círculo (o x 2 + y 2 < r 2 ), entonces imprímalo, de lo contrario imprima espacio.
 

Acercarse: 

1. dibuja el rectángulo

2. comprueba si el punto está dentro o sobre el círculo usando la fórmula x 2 + y 2 < r 2 .

3. Si cumple la condición, imprima la estrella; de lo contrario, imprima un espacio en blanco.

Algoritmo: 

Paso 1 : Tome la entrada de radio

Paso 2 : Calcular el tamaño del rectángulo

Paso 3 : Dibuja el rectángulo usando el bucle for anidado

Paso 4 : Coordenadas de inicio desde la esquina más a la izquierda

Paso 5 : compruebe si las coordenadas se encuentran dentro del círculo, si es así, imprima la estrella; de lo contrario, imprima un espacio en blanco.

C++

// C++ code to demonstrate to draw
// circle without floating
// point arithmetic
#include <stdio.h>
 
void drawCircle(int r)
{
    // Consider a rectangle of size N*N
    int N = 2*r+1;
 
    int x, y;  // Coordinates inside the rectangle
 
    // Draw a square of size N*N.
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            // Start from the left most corner point
            x = i-r;
            y = j-r;
 
            // If this point is inside the circle, print it
            if (x*x + y*y <= r*r+1 )
                printf(".");
            else // If outside the circle, print space
                printf(" ");
            printf(" ");
        }
        printf("\n");
    }
}
 
// Driver Program to test above function
int  main()
{
    drawCircle(8);
    return 0;
}

Java

// Java code to demonstrate to draw
// circle without floating
// point arithmetic
 
class GFG
{
static void drawCircle(int r)
{
    // Consider a rectangle of size N*N
    int N = 2*r+1;
 
    int x, y; // Coordinates inside the rectangle
 
    // Draw a square of size N*N.
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            // Start from the left most corner point
            x = i-r;
            y = j-r;
 
            // If this point is inside the circle, print it
            if (x*x + y*y <= r*r+1 )
                System.out.print(".");
            else
                // If outside the circle, print space
                System.out.print(" ");
 
            System.out.print(" ");
        }
 
        System.out.println();
    }
}
 
// Driver Program to test above function
public static void main(String arg[])
{
    drawCircle(8);
}
}
 
// This code is contributed
// by Anant Agarwal.

Python3

# Python3 code to demonstrate to draw
# circle without floating
# point arithmetic
 
def drawCircle(r):
 
    # Consider a rectangle of size N*N
    N = 2 * r + 1
 
    # Draw a square of size N*N.
    for i in range(N):
        for j in range(N):
 
            # Start from the left most corner point
            x = i - r
            y = j - r
 
            # If this point is inside the circle,
            # print it
            if x * x + y * y <= r * r + 1:
                print(".", end = " ")
                 
            # If outside the circle, print space
            else:
                print(" ", end = " ")
        print()
 
# Driver Code
if __name__ == "__main__":
    drawCircle(8)
 
# This code is contributed
# by vibhu4agarwal

C#

// C# code to demonstrate to draw
// circle without floating
// point arithmetic
using System;
 
public class GFG{
    static void drawCircle(int r)
{
    // Consider a rectangle of size N*N
    int N = 2*r+1;
 
    int x, y; // Coordinates inside the rectangle
 
    // Draw a square of size N*N.
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            // Start from the left most corner point
            x = i-r;
            y = j-r;
 
            // If this point is inside the circle, print it
            if (x*x + y*y <= r*r+1 )
                Console.Write(".");
            else
                // If outside the circle, print space
                Console.Write(" ");
 
            Console.Write(" ");
        }
 
        Console.WriteLine();
    }
}
 
// Driver Program to test above function
    static public void Main (){
        drawCircle(8);
     
      
    }
// This code is contributed
// by ajit.
}

PHP

<?php
// PHP code to demonstrate to draw circle
// without floating point arithmetic
 
function drawCircle($r)
{
    // Consider a rectangle of size N*N
    $N = 2 * $r + 1;
 
    $y; // Coordinates inside the rectangle
 
    // Draw a square of size N*N.
    for ($i = 0; $i < $N; $i++)
    {
        for ( $j = 0; $j < $N; $j++)
        {
            // Start from the left most
            // corner point
            $x = $i - $r;
            $y = $j - $r;
 
            // If this point is inside the
            // circle, print it
            if ($x * $x + $y * $y <= $r * $r + 1)
                echo (".");
            else // If outside the circle,
                 // print space
                echo (" ");
            echo (" ");
        }
    echo "\n";
    }
}
 
// Driver Code
drawCircle(8);
 
// This code is contributed by akt_mit
?>

Javascript

<script>
 
function drawCircle(r)
{
    // Consider a rectangle of size N*N
    let N = 2*r+1;
   
    let x, y; // Coordinates inside the rectangle
   
    // Draw a square of size N*N.
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < N; j++)
        {
            // Start from the left most corner point
            x = i - r;
            y = j - r;
   
            // If this point is inside the circle, print it
            if (x * x + y * y <= r * r + 1 )
                document.write(".");
            else
                // If outside the circle, print space
                document.write("  ");
   
            document.write("  ");
        }
   
        document.write("<br>");
    }
}
 
drawCircle(8);
// This code is contributed by avanitrachhadiya2155
</script>

Producción: 
 

Complejidad del tiempo: O(N 2 )

Complejidad espacial: O(N 2 )
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 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 *