[Question]
  [
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.
  
[Answer]
**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`
![enter image description here](https://i.stack.imgur.com/aAxiZ.png)
**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`
![enter image description here](https://i.stack.imgur.com/PiWSa.png)
**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`
![enter image description here](https://i.stack.imgur.com/29e5y.png)
**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`
![enter image description here](https://i.stack.imgur.com/zdpQB.png)
**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`
![enter image description here](https://i.stack.imgur.com/ddypJ.png)
[Answer]
## Mathematica, 40 - 25% = 30
```
ListPolarPlot[r&~Array~n]/.PointPolygon
```
![enter image description here](https://i.stack.imgur.com/j6FRP.png)
[Answer]
## 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();
    }
}
```
Input is arguments [radius] [sides]:
```
java D 300 7
```
Output:
![a polygon!](https://i.stack.imgur.com/HmXLF.png)
[Answer]
# 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"
```
> 
> ![Triangle](https://i.stack.imgur.com/pAD6z.png)
> 
> 
> 
```
pdftex "\def\r{1}\def\n{5}\input polygon"
```
> 
> ![Polygon](https://i.stack.imgur.com/j8wZm.png)
> 
> 
> 
```
pdftex "\def\r{1}\def\n{8}\input polygon"
```
> 
> ![Octagon](https://i.stack.imgur.com/xCbNU.png)
> 
> 
> 
```
pdftex "\def\r{1}\def\n{12}\input polygon"
```
> 
> ![Dodecagon](https://i.stack.imgur.com/1BgKU.png)
> 
> 
> 
**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.
[Answer]
## [Geogebra](http://www.geogebra.org), 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 *c*2 = *a*2 + *b*2 – 2 *a b* cos *C* to calculate the side length from the given radius.
Sample output for `s`=7, `r`=5
![enter image description here](https://i.stack.imgur.com/P2osv.png)
[Answer]
# 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).
```
                 ######
               ###    ###
            ####        ####
          ###              ###
        ###                  ####
     ###                        ###
     #                            #
     #                            ##
    #                              #
    #                              #
   ##                              ##
   #                                #
  ##                                ##
  #                                  #
  #                                  #
 ##                                  ##
 #                                    #
##                                    ##
#                                      #
#                                      #
#                                      #
#                                      #
##                                    ##
 #                                    #
 ##                                  ##
  #                                  #
  #                                  #
  ##                                ##
   #                                #
   ##                              ##
    #                              #
    #                              #
     #                            ##
     #                            #
     ###                        ###
        ###                  ####
          ###              ###
            ###         ####
               ###    ###
                 ######
```
[Answer]
# 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);}
```
(r is radius of incircle)
Please run in ANSI terminal
[![](https://i.stack.imgur.com/uPP2f.png "Hosted by imgur.com")](https://i.stack.imgur.com/YlVLm.jpg)
### Edit:
* take ace's suggestion
* use old variables (or #define) as input
* use circumcircle radius now
```
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
```
[Answer]
## 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:
![enter image description here](https://i.stack.imgur.com/9YNc2.png)
[Answer]
# 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 RADIUS = 100;
    var SIDES_COUNT = 10;
    var canvas = document.currentScript.parentNode;
    canvas.width = canvas.height = RADIUS * 2;
    var context = canvas.getContext("2d");
    context.moveTo(RADIUS * 2, RADIUS);
    for(i = 1 ; i <= SIDES_COUNT ; i++) {
        var angle = Math.PI * 2 * (i / SIDES_COUNT);
        context.lineTo(
            RADIUS + Math.cos(angle) * RADIUS,
            RADIUS + Math.sin(angle) * RADIUS
        );
    }
    context.stroke();
</script>
```
[Answer]
## 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.
[Answer]
## [Sage](http://www.sagemath.org/), 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
![enter image description here](https://i.stack.imgur.com/IU8RC.png)
`s`=5, `r`=6
![enter image description here](https://i.stack.imgur.com/PzDG1.png)
`s`=12, `r`=5
![enter image description here](https://i.stack.imgur.com/5QPfs.png)
[Answer]
# 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:
![enter image description here](https://i.stack.imgur.com/PPR7r.png)
[Answer]
**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:
![Output in Chrome](https://i.stack.imgur.com/2BJ0H.png)
*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)
{
alert("no roots!");
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.
[Answer]
## 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;`
![](https://i.stack.imgur.com/RFokO.png)
`$r=100; $p=6;`
![](https://i.stack.imgur.com/kcCZg.png)
`$r=100; $p=7;`
![](https://i.stack.imgur.com/lQKUW.png)
`$r=100; $p=50;`
![](https://i.stack.imgur.com/UxG5u.png)
[Answer]
# HTML + JavaScript, 12 + 127 = 139 bytes
```
<canvas id=c
```
```
s=>r=>(g=n=>n?g(n-1,d.lineTo(r+r*M.cos(x=M.PI*2*n/s),r+r*M.sin(x))):d.fill())(s,c.width=c.height=r+r,d=c.getContext`2d`,M=Math)
```
[Try it on Codepen](https://codepen.io/PeterShaggyNoble/pen/rNLMgwN)
# HTML (SVG) + JavaScript, 20 + 140 = 160 bytes
```
<svg id=c><path id=p
```
```
s=>r=>p.setAttribute(`d`,`M${M=Math,v=c.style,v.width=v.height=r+r},`+r+(g=n=>n?`L${r+r*M.cos(x=M.PI*2*n/s)},`+(r+r*M.sin(x))+g(n-1):``)(s))
```
[Try it on Codepen](https://codepen.io/PeterShaggyNoble/pen/ExyNxEo)
[Answer]
# [R](https://www.r-project.org/), 42 bytes -25% = 31.5
```
function(n,r,p=r*1i^(4/n*0:n))plot(p,,"l")
```
[Try it at rdrr.io](https://rdrr.io/snippets/embed/?code=regular_polygon%3D%0Afunction(n%2Cr%2Cp%3Dr*1i%5E(4%2Fn*0%3An))plot(p%2C%2C%22l%22)%0Aregular_polygon(7%2C3))
Calculates coordinates of vertices in the complex plane as `r` times a power-series of the (4/n)th-root of `i`.
Example output of `regular_polygon(7,3)`:
[![enter image description here](https://i.stack.imgur.com/UcuML.png)](https://i.stack.imgur.com/UcuML.png)
[Answer]
# TI-80 BASIC, 25 bytes - 25% = 18.75
```
PARAM
2π/ANS->TSTEP
"COS T->X1ᴛ
"SIN T->Y1ᴛ
DISPGRAPH
```
Assumes all settings are set to the default values.
Run the program like `5:PRGM_POLYGON` (for a pentagon)
It works by drawing a circle with a very low number of steps. For example, a pentagon would have steps of 2π/5 radians.
The window settings are good enough by default, and `TMIN` and `TMAX` are set to `0` and `2π`, so all we need to change is `TSTEP`.
[Answer]
# SmileBASIC 3, 183 159 - 25% = 119.25 bytes
Takes the sides and radius from `INPUT`, calculates and stores the points, and then draws them by using `GLINE`. I feel like this could be shorter but it's like 1 AM, whatever. Assumes a clean and default display env, so you might need to `ACLS` when running it from DIRECT.
```
INPUT S,R
DIM P[S,2]FOR I=0TO S-1
A=RAD(I/S*360)P[I,0]=COS(A)*R+200P[I,1]=SIN(A)*R+120NEXT
FOR I=0TO S-1GLINE P[I,0],P[I,1],P[(I+1)MOD S,0],P[(I+1)MOD S,1]NEXT
```
![screenshot](https://d3esbfg30x759i.cloudfront.net/ss/WVW69kDxWKkzfISzUV)
[Answer]
## OpenSCAD: 31 less 25% = 23.25
```
module p(n,r){circle(r,$fn=n);}
```
First post here! I know I'm late to the party, but this seemed like as good a question as any to start with. Call using `p(n,r)`.
[Answer]
## [APL (dzaima/APL)](https://github.com/dzaima/APL), ~~50 - 12.5 = 37.5~~ 37 - 9.25 = 27.75 bytes
```
P5.draw←{P5.G.ln ↑r+r×2 1○ᑈs÷⍨2×○0…s}
```
Shortened heavily with the help of [The APL Orchard.](https://chat.stackexchange.com/transcript/message/55402353#55402353)
### Explanation:
```
P5.draw←{P5.G.ln ↑r+r×2 1○ᑈs÷⍨2×○0…s}
P5.draw←{                           } Draw the following on the canvas every frame:
         P5.G.ln                      Draw a line using array(x1,y1,x2,y2...)
                                 0…s  Range from 0 to number of sides
                              2×○     times 2π
                           s÷⍨        divided by number of sides
                      2 1○ᑈ           Take cos and sin of each of the values from the left
                 ↑r+r×                Multiply the list by r and add r to center it, 
                                      then mix the values of the list together
```
Previous version:
```
p←(2×○⍳s+1)÷s
P5.draw←{P5.G.ln r+r×⍉(2○p)↑⍤⍮(1○p)}
```
Takes input as variables `r` and `s`, draws polygon with center at \$(r,r)\$.
Made with the help of the formula used [here.](https://www.openprocessing.org/sketch/738106)
### Outputs:
`100 3`
[![enter image description here](https://i.stack.imgur.com/Tf4Vl.png)](https://i.stack.imgur.com/Tf4Vl.png)
`100 5`
[![enter image description here](https://i.stack.imgur.com/lRpIW.png)](https://i.stack.imgur.com/lRpIW.png)
`200 7`
[![enter image description here](https://i.stack.imgur.com/8o1km.png)](https://i.stack.imgur.com/8o1km.png)
To execute the program, use the setup [here,](https://tio.run/##SyzI0U2pSszMTfxf9KhtAlcxiAgw1SvOrEoFMo0e9W4xPjy96H8BkKNhdHj6o@ndj3o3F2sbah7eXgxSmFKUWA6UqwYy3fVy8hSKtIuAqno7NYyASgs0H7VNfNS75FHvOg1DML/2/38A "APL (dzaima/APL) – Try It Online") for a full view of the drawn polygon.
[Answer]
**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)
```
[Answer]
## C# in LINQPAD
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()
{
// Usage: (sides, radius)
    DrawSomething(4, 50);
}
void DrawSomething(int sides, int radius)
{
    var points = new Point[sides];
    var bmpSize = radius*sides;
    var bmp = new Bitmap(bmpSize,bmpSize);
    using (Graphics g = Graphics.FromImage(bmp))
    {   
        var o = radius+30;
        for(var i=0; i < points.Length; i++)
        {
            // math thanks to Geobits
            double w = Math.PI*2*i/sides;
            points[i].X = (int)(Math.Cos(w)*radius+o);
            points[i].Y = (int)(Math.Sin(w)*radius+o);
        }
        g.DrawPolygon(new Pen(Color.Red), points);
    }
    Console.Write(bmp);
}
```
![enter image description here](https://i.stack.imgur.com/BROut.jpg)
[Answer]
# Matlab 58 bytes - 25% = 43.5
Saw no Matlab solution, so here is one which is pretty straightforward:
```
f=@(n,r) plot(r*cos(0:2*pi/n:2*pi),r*sin(0:2*pi/n:2*pi));
```
You can shave off some bytes if **r** and **n** are already in the workspace.
Example call:
```
f(7,8)
```
[![7-gon with radius 8](https://i.stack.imgur.com/WMbi1.jpg)](https://i.stack.imgur.com/WMbi1.jpg)
[Answer]
# Python 2, 222 bytes
```
from math import*
def f(s,r):
 r*=cos(pi/s)
 v,R=2*pi/s,[(2*t)/98.-1for t in range(99)]
 print"P1 99 99 "+" ".join(["0","1"][all(w*(w-x)+z*(z-y)>0for w,z in[(r*cos(a*v),r*sin(a*v))for a in range(s)])]for x in R for y in R)
```
Checks if a pixel is on the inner side of all hyperplanes (lines) of the polygon. The radius is touched because actually the apothem is used.
[![enter image description here](https://i.stack.imgur.com/BlSX8.png)](https://i.stack.imgur.com/BlSX8.png)
[![enter image description here](https://i.stack.imgur.com/U71Rn.png)](https://i.stack.imgur.com/U71Rn.png)
[Answer]
# Mathematica 27 ( = 36 - 25%)
```
Graphics[Polygon[CirclePoints[r, n]]]
```
When we submit Mathematica code we often forget about new functions that keep getting built into the language, with current language vocabulary amassing around [5000 core functions](http://reference.wolfram.com/language/). Large and expanding language vocabulary is btw quite handy for code-golfing. [CirclePoints](http://reference.wolfram.com/language/ref/CirclePoints.html) were introduced in the current version 11.X. A specific example of 7-sided radius 5 is:
[![enter image description here](https://i.stack.imgur.com/ADqii.png)](http://reference.wolfram.com/language/ref/CirclePoints.html)
Also you just need to enter angle parameter to control orientation of your polygon:
```
Graphics[Polygon[CirclePoints[{1, 2}, 5]]]
```
[![enter image description here](https://i.stack.imgur.com/y48xR.png)](https://i.stack.imgur.com/ADqii.png)
[Answer]
# Python 2, 74 bytes - 25% = 55.5
Input is in the variables `r,n`. If included in the count, it would be `r,n=input()`, for 12 bytes more.
```
import math,turtle as t
exec"t.fd(2*r*math.sin(180/n));t.rt(360/n);"*n
```
[**Try it online**](https://trinket.io/python/83cd17e68a) - *(uses different code since `exec` is not implemented in the online interpreter)*
[Answer]
# SmileBASIC, ~~85~~ 75 - 25% = 56.25 bytes
```
FOR I=0TO S
A=I/S*6.28N=X
M=Y
X=R+R*COS(A)Y=R+R*SIN(A)GLINE N,M,X,Y,-I
NEXT
```
Variables S and R are used for input.
Explained:
```
FOR I=0 TO Sides        'Draw n+1 sides (since 0 is skip)
 Angle=I/Sides*6.28     'Get angle in radians
 OldX=X:OldY=Y          'Store previous x/y values
 X=Radius+Radius*COS(A) 'Calculate x and y
 Y=Radius+Radius*SIN(A)
 GLINE OldX,OldY,X,Y,-I 'Draw line. Skip if I is 0 (since old x and y aren't set then)
NEXT
```
The sides are drawn using the color `-I`, which is usually close to -1 (&HFFFFFFFF white) (except when `I` is 0, when it's transparent).
You can also draw a filled polygon by using `GTRI N,M,X,Y,R,R,-I` instead of `GLINE...`
[Answer]
# Tikz, 199 bytes
```
\documentclass[tikz]{standalone}\usetikzlibrary{shapes.geometric}\begin{document}\tikz{\def\p{regular polygo}\typein[\n]{}\typein[\r]{}\node[draw,minimum size=\r,\p n,\p n sides=\n]{}}\end{document}
```
This solution uses the tikz library `shapes.geometric`.
Here is what a polygon with `5` sides and radius `8in` looks like when viewed in [evince](https://wiki.gnome.org/Apps/Evince).
[![Obligatory Picture](https://i.stack.imgur.com/xxSTf.png)](https://i.stack.imgur.com/xxSTf.png)
[Answer]
# MATLAB/Octave, 26.25 bytes (35 bytes-25%)
```
@(n,r)polar((0:n)/n*2*pi,r+(0:n)*0)
```
Can be tested on [octave-online](https://octave-online.net/).  
@ptev already posted a MATLAB answer but mine uses far less bytes and isn't distorted.  
We can save up another 6 bytes (or 4.5 including bonus) if we assume input can be given as variables `r`&`n` already existing in workspace - then just calling `polar((0:n)/n*2*pi,r+(0:n)*0)` is enough.
Also, example output (`n=5`,`r=3`):  
[![enter image description here](https://i.stack.imgur.com/zqECj.png)](https://i.stack.imgur.com/zqECj.png)
]