# Draw a regular polygon

The goal of this code golf is to draw a regular polygon (one with equal side lengths) given the number of sides and radius (distance from center to vertex).

• The number of sides and the radius can be entered via a file, STDIN, or just a plain old variable. Use whatever is shorter in your language.
• -25% of total characters/bytes if the image is actually drawn instead of ASCII art.
-
What is the radius of a polygon? The radius of its incircle? Its outcircle? –  Peter Taylor Apr 16 '14 at 7:25
There. I fixed it. Sorry about that :P. –  Taconut Apr 16 '14 at 13:49
@PeterTaylor The radius of a regular polygon is the distance to any vertex (radius outcircle or circumradius). The incircle's radius(or distance to sides) is called the apothem. This shouldn't be "unclear what you're asking", since it has an easily found definition (#1 result for "radius of a polygon" on google). –  Bigtoes Apr 16 '14 at 13:57
@Geobits I agree, but I still edited it anyway. –  Taconut Apr 16 '14 at 14:03
@PeterTaylor I'll tag it as both then :I –  Taconut Apr 16 '14 at 14:03

LOGO 37 - 25% = 27.75 (with variables)

REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


LOGO 49 - 25% = 36.75 (as a function)

TO P:R:S REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]END


Triangle

Called with variables

Make "R 100
Make "S 3
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


Used as a function P 100 3

Square

Called with variables

Make "R 100
Make "S 4
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


Used as a function P 100 4

Pentagon

Called with variables

Make "R 100
Make "S 5
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


Used as a function P 100 5

Decagon

Called with variables

Make "R 100
Make "S 10
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


Used as a function P 100 10

Circle

Called with variables

Make "R 100
Make "S 360
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]


Used as a function P 100 360

-
Can you post a screen shot? –  Gabe Apr 16 '14 at 12:22
To my eye the polygons have the same side, not radius. –  Ross Millikan Apr 16 '14 at 16:06
@RossMillikan: The Images were not to scale. I just updated the images –  Abhijit Apr 16 '14 at 16:10

## Mathematica, 40 - 25% = 30

ListPolarPlot[r&~Array~n]/.PointPolygon


-
+1 Very clever! –  Martin Büttner Apr 16 '14 at 18:26
Great. That beat what I tried with Graphics. –  David Carraher Apr 17 '14 at 0:04
No fair! Too easy! –  SuperScript Apr 17 '14 at 0:38
Nicely done, this would never have occurred to me. –  Michael Stern Apr 17 '14 at 15:11

# TeX/TikZ (60 – 80.25)

File polygon.tex:

\input tikz \tikz\draw(0:\r)\foreach\!in{1,...,\n}{--(\!*360/\n:\r)}--cycle;\bye


(80 bytes)

The radius and number of sides are provided as variables/macros \r and \n. Any TeX unit can be given for the radius. Without unit, the default unit cm is used. Examples:

\def\r{1}\def\n{5}    % pentagon with radius 1cm
\def\r{10mm}\def\n{8} % octagon with radius 10mm


(16 bytes without values)

If the page number should be suppressed, then it can be done by

\footline{}


(11 bytes)

Examples for generating PDF files:

pdftex "\def\r{1}\def\n{3}\input polygon"


pdftex "\def\r{1}\def\n{5}\input polygon"


pdftex "\def\r{1}\def\n{8}\input polygon"


pdftex "\def\r{1}\def\n{12}\input polygon"


Score:

It is not clear to, what needs counting. The range for the score would be:

• The base code is 80 bytes minus 25% = 60

• Or all inclusive (input variable definitions, no page number): (80 + 16 + 11) minus 25% = 80.25

• If the connection between the first and last point do not need to be smooth, then --cycle could be removed, saving 7 bytes.

-

## Java 8 : 533 322 - 25% = 241.5

Well, it's Java :/ Just draws lines, point to point. Should work for any arbitrarily sized polygon. Cut it down quite a bit from original size. Huge credit to Vulcan (in comments) for the golf lesson.

import java.awt.*;class D{public static void main(String[]v){new Frame(){public void paint(Graphics g){int i=0,r=Short.valueOf(v[0]),s=Short.valueOf(v[1]),o=r+30,x[]=new int[s],y[]=x.clone();for(setSize(o*2,o*2);i<s;x[i]=(int)(Math.cos(6.28*i/s)*r+o),y[i]=(int)(Math.sin(6.28*i++/s)*r+o));g.drawPolygon(x,y,s);}}.show();}}


Line Breaks:

import java.awt.*;
class D{
public static void main(String[]v){
new Frame(){
public void paint(Graphics g){
int i=0,r=Short.valueOf(v[0]),s=Short.valueOf(v[1]),o=r+30,x[]=new int[s],y[]=x.clone();
for(setSize(o*2,o*2);i<s;x[i]=(int)(Math.cos(6.28*i/s)*r+o),y[i]=(int)(Math.sin(6.28*i++/s)*r+o));
g.drawPolygon(x,y,s);
}
}.show();
}
}


java D 300 7


Output:

-
Eliminate 12 bytes by importing java.awt.image.* instead of java.awt.image.BufferedImage –  Vulcan Apr 16 '14 at 15:32
I've reduced it to 500 bytes using a few tricks. 1) Use Short.valueOf instead of Integer.valueOf to save four bytes, as input should never exceed the range of shorts. 2) y[]=x.clone() saves one byte over y[]=new int[s]. 3) Use the deprecated f.show(); instead of f.setVisible(1>0); to save an addition nine bytes. 4) Use 6.28 instead of Math.PI*2, as the estimation is accurate enough for this purpose, saving three bytes. 5) Declare Graphics g instead of Graphics2D g when creating the graphics instance to save two bytes. –  Vulcan Apr 16 '14 at 22:15
@Vulcan I got it down another 120 (mainly by trashing the BufferedImage and Graphics altogether and just throwing everything in paint()). It did change the color of the image, though it still looks good IMO. Thanks for making me take another look at this :) –  Bigtoes Apr 16 '14 at 23:26
@Geobits Great improvements. Working off of your reduced version, I've cut it down further to 349 bytes by eliminating the Frame as a local variable, removing the d integer, and using/abusing the for-loop to save a few characters, mainly semicolons. Here's a version with whitespace as well. –  Vulcan Apr 17 '14 at 2:37
Reduced to 325 bytes by using drawPolygon instead of drawLine. Whitespace version. –  Vulcan Apr 17 '14 at 4:25

## Geogebra, 42 – 25% = 31.5 bytes

If you count in characters instead of bytes, this would be 41 – 25% = 30.75 characters.

(That is, if you consider Geogebra a language...)

Assumes the radius is stored in the variable r and the number of sides stored in the variable s.

Polygon[(0,0),(sqrt(2-2cos(2π/s))r,0),s]


This uses the cosine theorem c2 = a2 + b2 – 2 a b cos C to calculate the side length from the given radius.

Sample output for s=7, r=5

-

# C, 359 Chars

My first attempt at golfing. At least it beats the Java solution ;-)

int r,n,l,g,i,j,x,y;char* b;float a,c,u,z,p,q,s,t;main(int j,char**v){r=atoi(v[1]);b=malloc(g=(l=r*2+1)*r*2+1);memset(b,32,g);for(j=g-2;j>0;j-=l){b[j]='\n';}b[g-1]=0;a=2*3.14/(n=atoi(v[2]));for(;i<=n;i++,p=s,q=t){c=i*a;s=sin(c)*r+r;t=cos(c)*r+r;if(i>0){u=(s-p)/r,z=(t-q)/r;for(j=0;j<r;j++){x=p+u*j;y=q+z*j;if(x>=0&&y>=0&&y<r*2&&x<l-1)b[y*l+x]='#';}}}puts(b);}


ungolfed:

int r,n,l,g,i,j,x,y;
char* b;
float a,c,u,z,p,q,s,t;
main(int j,char**v){
r=atoi(v[1]);
b=malloc(g=(l=r*2+1)*r*2+1);
memset(b,32,g);
for(j=g-2;j>0;j-=l){b[j]='\n';}
b[g-1]=0;
a=2*3.14/(n=atoi(v[2]));
for(;i<=n;i++,p=s,q=t){
c=i*a;s=sin(c)*r+r;t=cos(c)*r+r;
if(i>0){
u=(s-p)/r,z=(t-q)/r;
for(j=0;j<r;j++){
x=p+u*j;y=q+z*j;
if(x>=0&&y>=0&&y<r*2&&x<l-1)b[y*l+x]='#';
}
}
}
puts(b);
}


And it's the only program that outputs the polygon in ASCII instead of drawing it. Because of this and some floating point rounding issues, the output doesn't look particularly pretty (ASCII Chars are not as high as wide).

                 ######
###    ###
####        ####
###              ###
###                  ####
###                        ###
#                            #
#                            ##
#                              #
#                              #
##                              ##
#                                #
##                                ##
#                                  #
#                                  #
##                                  ##
#                                    #
##                                    ##
#                                      #
#                                      #
#                                      #
#                                      #
##                                    ##
#                                    #
##                                  ##
#                                  #
#                                  #
##                                ##
#                                #
##                              ##
#                              #
#                              #
#                            ##
#                            #
###                        ###
###                  ####
###              ###
###         ####
###    ###
######

-
The first int can be removed since they are assumed to be int by the compiler. Also, the last for loop can be changed to for(j=0;j<r;){x=p+u*j;y=q+z*j++;//... –  ace Apr 16 '14 at 15:02
The if(i<0) could be changed to if(i). Which is still only needed in one iteration, but couldn't find an efficient way to take it out :( –  Allbeert Apr 16 '14 at 19:10

## Mathematica, 54 * 75% = 40.5

Graphics@Polygon@Table[r{Cos@t,Sin@t},{t,0,2Pi,2Pi/n}]


I don't even think there's a point for an ungolfed version. It would only contain more whitespace.

Expects the radius in variable r and number of sides in variable n. The radius is a bit meaningless without displaying axes, because Mathematica scales all images to fit.

Example usage:

-
Graphics@Polygon@Array[r{Sin@#,Cos@#}&,n+1,{0,2π}] –  chyaong Jun 15 '14 at 8:19
@chyaong ah, I tend to forget about Array . –  Martin Büttner Jun 15 '14 at 8:24

# C: 229 180

#include<stdio.h>
#include<math.h>
main(){float n=5,r=10,s=tan(1.57*(1.-(n-2.)/n))*r*2.,i=0,j,x,c,t;int u,v;for(;i<n;i++)for(j=0;j<s;j++)x=i*6.28/n,c=cos(x),t=sin(x),x=j-s/2.,u=c*r+t*x+r*2.,v=-t*r+c*x+r*2,printf("\e[%d;%dH*",v,u);}


### Edit:

• take ace's suggestion
• use old variables (or #define) as input
u;main(v){float p=3.14,r=R*cos(p/n),s=tan(p/n)*r*2,i=0,j,x,c,t;for(;i++<n;)for(j=0;j<s;)x=i*p/n*2,c=cos(x),t=sin(x),x=j++-s/2,u=c*r+t*x+r*2,v=c*x-t*r+r*2,printf("\e[%d;%dH*",v,u);}


compile:

gcc -opoly poly.c -Dn=sides -DR=radius -lm

-
When you use gcc you can actually omit the #includes. Also, you can declare v as global outside main, and declare u as a parameter of main, then you don't need int (i.e. v;main(u){//...). Finally, you can change the last for loop into for(j=0;j<s;)/*...*/x=j++-s/2.,//... –  ace Apr 16 '14 at 15:07

## Postscript 156 - 25% = 117

translate exch 1 exch dup dup scale div currentlinewidth mul setlinewidth
1 0 moveto dup{360 1 index div rotate 1 0 lineto}repeat closepath stroke showpage


Pass the radius, number of sides, and center point on the command line

gs -c "100 9 300 200" -- polyg.ps


or prepend to the source

echo 100 9 300 200 | cat - polyg.ps | gs -


Translate to the center, scale up to the radius, move to (1,0); then repeat n times: rotate by 360/n, draw line to (1,0); draw final line, stroke and emit the page.

-

## Sage, 44 - 25% = 33

Assumes the number of sides is stored in the s variable and the radius is stored in the r variable.

polytopes.regular_polygon(s).show(figsize=r)


Sample output:

s=5, r=3

s=5, r=6

s=12, r=5

-
The scaling of the axes is misleading. Is that fixable? (e.g first point at (0,3) when radius=3, instead of (0,1)) –  Maria Tidal Tug Apr 17 '14 at 15:30
@DigitalTrauma My program basically generates the "standard" regular polygon, then enlarges the image by a scale factor. As far as I know the regular_polygon function always generates polygons with the first vertex at (0,1). A fix would be to not show the axes with an additional 7 bytes (,axes=0 after figsize=r) –  ace Apr 17 '14 at 17:45

# HTML/JavaScript : 215 - 25% = 161.25, 212 - 25% = 159

<canvas><script>R=100;i=S=10;c=document.currentScript.parentNode;c.width=c.height=R*2;M=Math;with(c.getContext("2d")){moveTo(R*2,R);for(;i-->0;){a=M.PI*2*(i/S);lineTo(R+M.cos(a)*R,R+M.sin(a)*R)}stroke()}</script>


Ungolfed version :

<canvas><script>
var SIDES_COUNT = 10;
var canvas = document.currentScript.parentNode;
canvas.width = canvas.height = RADIUS * 2;
var context = canvas.getContext("2d");
for(i = 1 ; i <= SIDES_COUNT ; i++) {
var angle = Math.PI * 2 * (i / SIDES_COUNT);
context.lineTo(
);
}
context.stroke();
</script>

-
Save 4 chars by i=S=5; and for(;i-->0;). –  Matt Apr 17 '14 at 1:06
@Matt Thank you ! I didn't know this syntax, and can't find any information about it. How is it called ? –  sebcap26 Apr 17 '14 at 14:49
@sebcap26 Do you mean the i-->0 part? It's the same as i-- > 0. Some people also call it the arrow operator or the goes to operator ;) –  ComFreek Apr 17 '14 at 19:19
No worries :) As @sebcap26 said, it's just decrementing every time the for loop evaluates the condition. –  Matt Apr 18 '14 at 2:45

# bc + ImageMagick + xview + bash, 104.25 (139 bytes - 25%)

This challenge would be incomplete without an ImageMagick answer...

convert -size $[$2*2]x$[$2*2] xc: -draw "polygon bc -l<<Q
for(;i++<$1;){t=6.28*i/$1;print s(t)*$2+$2,",";c(t)*$2+$2}
Q" png:-|xview stdin


For example, ./polygon.sh 8 100 produces this image:

-

## Python 2.75 - ??

Simple GUI for drawing a polygon given a radius, number of sides and an optional offset. It can be golfed to hell and back but I haven't tried yet. The window is fully resizeable.

import Tkinter as gui
import ttk as tgui
from math import pi, radians, sin, cos

BOARD_WIDTH = 600
BOARD_HEIGHT = 600
POLYGON_TAG = 'shape'
DEFAULT_SIDES = 5
DEFAULT_OFFSET = 0

class configvar:
def __init__(self, master, name, defaultVal=0):
self.var = gui.StringVar(value=defaultVal)
self.lbl = tgui.Label(master, text=name)
self.fld = tgui.Entry(window, textvariable=self.var)

def arrange(self, srow, scol):
self.lbl.grid(row=srow, column=scol, sticky=gui.W)
self.fld.grid(row=srow, column=scol+1, sticky=(gui.W, gui.E))

def getFloatValue(self, previous=0.0):
try:
return float(self.var.get())
except ValueError:
return previous

def drawPolygon(canvas, r, s, o):
radius, sides, offset = (i.getFloatValue() for i in (r,s,o))
cx, cy = canvas.winfo_width()/2, canvas.winfo_height()/2

step = 2*pi/sides
range(int(sides)+1) ]

canvas.delete(POLYGON_TAG)
canvas.create_line(*points, tags=(POLYGON_TAG))

root = gui.Tk()
root.title("Draw a Regular Polygon")
window.grid(sticky=(gui.N, gui.E, gui.S, gui.W))

board = gui.Canvas(window, width=BOARD_WIDTH,height=BOARD_HEIGHT)

sides = configvar(window, "Number of Sides:", DEFAULT_SIDES)
offset = configvar(window, "Offset:", DEFAULT_OFFSET)

draw = tgui.Button(window, text="Draw",

board.grid(row=1, column=1, columnspan=7, sticky=(gui.N, gui.E, gui.S, gui.W))

sides.arrange(2, 3)
offset.arrange(2, 5)
draw.grid(row=2, column=7)

window.rowconfigure(1, weight=1)
for column in (2,4,6):
window.columnconfigure(column, weight=1)
root.rowconfigure(0, weight=1)
root.columnconfigure(0, weight=1)

root.mainloop()

-
2.75? Wow, I thought Python 2.8 wasn't even going to be a thing –  Nick T Apr 16 '14 at 21:49

JavaScript 584 (867 ungolfed)

This code uses N Complex Roots of unity and translates the angles to X,Y points. Then the origin is moved to centre of the canvas.

Golfed

function createPolygon(c,r,n){
c.width=3*r;
c.height=3*r;
var t=c.getContext("2d");
var m=c.width/2;
t.beginPath();
t.lineWidth="5";
t.strokeStyle="green";
var q=C(r, n);
var p=pts[0];
var a=p.X+m;
var b=p.Y+m;
t.moveTo(a,b);
for(var i=1;i<q.length;i++)
{
p=q[i];
t.lineTo(p.X+m,p.Y+m);
t.stroke();
}
t.lineTo(a,b);
t.stroke();
}
function P(x,y){
this.X=x;
this.Y=y;
}
function C(r,n){
var p=Math.PI;
var x,y,i;
var z=[];
var k=n;
var a;
for(i=0;i<k;i++)
{
a = 2*i*p/n;
x = r*Math.cos(a);
y = r*Math.sin(a);
z.push(new P(x,y));
}
return z;
}


Sample output:

Ungolfed

function createPolygon(c,r,n) {
c.width = 3*r;
c.height = 3*r;
var ctx=c.getContext("2d");
var mid = c.width/2;
ctx.beginPath();
ctx.lineWidth="5";
ctx.strokeStyle="green";
var pts = ComplexRootsN(r, n);
if(null===pts || pts.length===0)
{
return;
}
var p=pts[0];
var x0 = p.X + mid;
var y0 = p.Y + mid;
ctx.moveTo(x0,y0);
for(var i=1;i<pts.length;i++)
{
p=pts[i];
console.log(p.X +"," + p.Y);
ctx.lineTo(p.X + mid, p.Y + mid);
ctx.stroke();
}
ctx.lineTo(x0,y0);
ctx.stroke();
}

function Point(x,y){
this.X=x;
this.Y=y;
}

function ComplexRootsN(r, n){
var pi = Math.PI;
var x,y,i;
var arr = [];
var k=n;
var theta;
for(i=0;i<k;i++)
{
theta = 2*i*pi/n;
console.log('theta: ' + theta);
x = r*Math.cos(theta);
y = r*Math.sin(theta);
console.log(x+","+y);
arr.push(new Point(x,y));
}
return arr;
}


This code requires HTML5 canvas element, c is canvas object, r is radius and n is # of sides.

-
+1 for "N Complex Roots of unity" –  Maria Tidal Tug Apr 17 '14 at 15:32

## PHP 140 - 25% = 105

<?
for(;$i++<$p;$a[]=$r-cos($x)*$r)$a[]=$r-sin($x+=2*M_PI/$p)*$r; imagepolygon($m=imagecreatetruecolor($r*=2,$r),$a,$p,0xFFFFFF);
imagepng($m);  Assumes two predefined variables: $p the number of points, and $r the radius in pixels. Alternatively, one could prepend list(,$r,$p)=$argv; and use command line arguments instead. Output will be a png, which should be piped to a file.

### Output

$r=100;$p=5;

$r=100;$p=6;

$r=100;$p=7;

$r=100;$p=50;

-

ActionScript 1, Flash Player 6: 92 - 25% = 69

n=6
r=100
M=Math
P=M.PI*2
lineStyle(1)
moveTo(r,0)
while((t+=P/n)<=P)lineTo(M.cos(t)*r,M.sin(t)*r)

-

Credit for the math part goes to Geobits (I hope you don't mind!) with the Java answer. I'm hopeless at math :)

I did this in LINQPAD as it's got a built in output window. So essentially you can drag and drop the following in to it and it'll draw the polygon. Just switch it to 'C# Program', and import the System.Drawing lib into the query properties.

//using System.Drawing;

void Main()
{
DrawSomething(4, 50);
}

{
var points = new Point[sides];
var bmp = new Bitmap(bmpSize,bmpSize);
using (Graphics g = Graphics.FromImage(bmp))
{
for(var i=0; i < points.Length; i++)
{
// math thanks to Geobits
double w = Math.PI*2*i/sides;