Draw a circle without floating point arithmetic

Given a radius of a circle, draw the circle without using floating point arithmetic.
The following program uses a simple concept. Let the radius of the circle be r. Consider a square of size (2r+1)*(2r+1) around the circle to be drawn. Now walk through every point inside the square. For every point (x,y), if (x, y) lies inside the circle (or x^2+ y^2 < r^2), then print it, otherwise print space.

C++

// C++ program to draw a 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 program to draw a circle without
// floating point arithmetic

import java.io.*;

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[] args) {
        drawCircle(8);
    }
//This code is contributed by ajit.
}

Python3

# Python3 program to draw a 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 = "")
            else :# If outside the circle, print space
                print(" ", end = "")
            print(" ", end = "")

        print()

drawCircle(8)

# This code is contributed by divyeshrabadiya07.

C#

// C#  program to draw a 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 Sachin.
}

PHP

<?php
// PHP program to draw a circle without
// floating point arithmetic

function drawCircle($r)
{
    // Consider a rectangle
    // of size N*N
    $N = 2 * $r + 1;

    // Coordinates inside
    // the rectangle
    $x; $y;

    // 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 ".";

            // If outside the circle,
            // print space
            else
                echo " ";
            echo " ";
        }
        echo "\n";
    }
}

// Driver Code
drawCircle(8);

// This code is contributed by aj_36
?>

Javascript

<script>
// javascript program to draw a circle without
// floating point arithmetic

    function drawCircle(r) {
        // Consider a rectangle of size N*N
        var N = (2 * r + 1);

        var x, 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)
                    document.write(". ");
                else // If outside the circle, print space
                    document.write("  ");
                document.write("  ");
            }
            document.write("<br/>");
        }
    }

    // Driver Program to test above function
        drawCircle(8);

// This code is contributed by gauravrajput1
</script>

Output

              . . .               
        . . . . . . . . .         
      . . . . . . . . . . .       
    . . . . . . . . . . . . .     
  . . . . . . . . . . . . . . .   
  . . . . . . . . . . . . . . .   
  . . . . . . . . . . . . . . .   
. . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . 
  . . . . . . . . . . . . . . .   
  . . . . . . . . . . . . . . .   
  . . . . . . . . . . . . . . .   
    . . . . . . . . . . . . .     
      . . . . . . . . . . .       
        . . . . . . . . .         
              . . .               

Time complexity: O(N²)
Auxiliary space: O(1)