El objetivo de este código de golf es dibujar un polígono regular (uno con lados de igual longitud) dado el número de lados y el radio (distancia del centro al vértice).

• La cantidad de lados y el radio se pueden ingresar a través de un archivo, STDIN o simplemente una variable antigua. Use lo que sea más corto en su idioma.
• -25% del total de caracteres / bytes si la imagen se dibuja realmente en lugar del arte ASCII.

LOGO 37 - 25% = 27.75 (con variables)

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

LOGOTIPO 49 - 25% = 36.75 (como una función)

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

Triángulo

Llamado con variables

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

Utilizado como una función P 100 3

Cuadrado

Llamado con variables

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

Utilizado como una función P 100 4

Pentágono

Llamado con variables

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

Utilizado como una función P 100 5

Decágono

Llamado con variables

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

Utilizado como una función P 100 10

Circulo

Llamado con variables

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

Utilizado como una función P 100 360

Mathematica, 40 - 25% = 30

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

Java 8: 533322 - 25% = 241.5

Bueno, es Java: / Solo dibuja líneas, punto a punto. Debería funcionar para cualquier polígono de tamaño arbitrario. Reducirlo un poco del tamaño original. Gran crédito a Vulcan (en comentarios) por la lección de golf.

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();}}

Saltos de línea:

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();
    }
}

La entrada es argumentos [radio] [lados]:

java D 300 7

Salida:

TeX / TikZ (60 - 80.25)

Archivo polygon.tex:

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

(80 bytes)

El radio y el número de lados se proporcionan como variables / macros \ry \n. Se puede dar cualquier unidad TeX para el radio. Sin unidad, cmse utiliza la unidad predeterminada . Ejemplos:

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

(16 bytes sin valores)

Si se debe suprimir el número de página, entonces puede hacerlo

\footline{}

(11 bytes)

Ejemplos para generar archivos PDF:

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"

Puntuación:

No está claro qué se necesita contar. El rango para la puntuación sería:

• El código base es 80 bytes menos 25% = 60

• O todo incluido (definiciones de variables de entrada, sin número de página): (80 + 16 + 11) menos 25% = 80.25

• Si la conexión entre el primer y el último punto no necesita ser suave, entonces --cyclepodría eliminarse, ahorrando 7 bytes.

Geogebra , 42-25 % = 31.5 bytes

Si cuenta en caracteres en lugar de bytes, esto sería 41 - 25% = 30.75 caracteres.

(Es decir, si considera Geogebra como un idioma ...)

Asume que el radio se almacena en la variable ry el número de lados almacenados en la variable s.

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

Utiliza el teorema del coseno c ² = a ² + b ² - 2 ab cos C para calcular la longitud del lado a partir del radio dado.

Salida de muestra para s= 7, r= 5

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 es el radio de incircle)

Por favor, ejecute en la terminal ANSI

Editar:

• toma la sugerencia de as
• usar variables antiguas (o #definir) como entrada
• use el radio circunferencial ahora

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);}

compilar:

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

C, 359 caracteres

Mi primer intento de jugar al golf. Al menos supera a la solución de Java ;-)

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);}

sin golf:

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);
}

Y es el único programa que genera el polígono en ASCII en lugar de dibujarlo. Debido a esto y algunos problemas de redondeo de punto flotante, el resultado no se ve particularmente bonito (los caracteres ASCII no son tan altos como anchos).

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

Mathematica, 54 * 75% = 40.5

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

Ni siquiera creo que haya un punto para una versión sin golf. Solo contendría más espacios en blanco.

Espera el radio en variable ry el número de lados en variable n. El radio no tiene sentido sin mostrar ejes, porque Mathematica escala todas las imágenes para que quepan.

Ejemplo de uso:

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>

Versión sin golf:

<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>

Posdata 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

Pase el radio, el número de lados y el punto central en la línea de comando

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

o anteponer a la fuente

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

Traslade al centro, escale hasta el radio, muévase a (1,0); luego repita n veces: gire 360 ​​/ n, dibuje una línea a (1,0); dibuja la línea final, traza y emite la página.

Salvia , 44 - 25% = 33

Asume que el número de lados está almacenado en la svariable y el radio está almacenado en la rvariable.

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

Salida de muestra:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

Este desafío estaría incompleto sin una respuesta de ImageMagick ...

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

Por ejemplo, ./polygon.sh 8 100produce esta imagen:

JavaScript 584 (867 sin golf)

Este código usa N Raíces complejas de unidad y traduce los ángulos a puntos X, Y. Luego, el origen se mueve al centro del lienzo.

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;
}

Salida de muestra:

Sin golf

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;
}

Este código requiere un elemento de lienzo HTML5, c es un objeto de lienzo, r es el radio yn es el número de lados.

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);

Asume dos variables predefinidas: $pel número de puntos y $rel radio en píxeles. Alternativamente, uno podría anteponer list(,$r,$p)=$argv;y usar argumentos de línea de comando en su lugar. La salida será un png, que debe canalizarse a un archivo.

Salida

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

TI-80 BASIC, 25 bytes - 25% = 18.75

PARAM
2π/ANS->TSTEP
"COS T->X1ᴛ
"SIN T->Y1ᴛ
DISPGRAPH

Asume que todas las configuraciones están establecidas en los valores predeterminados. Ejecute el programa como 5:PRGM_POLYGON(para un pentágono)

Funciona dibujando un círculo con un número muy bajo de pasos. Por ejemplo, un pentágono tendría pasos de 2π / 5 radianes.

Los ajustes de la ventana son lo suficientemente bueno por defecto, y TMINy TMAXse establecen en 0y 2π, así que todo lo que tenga que cambiar es TSTEP.

SmileBASIC 3, 183 159 - 25% = 119.25 bytes

Toma los lados y el radio de INPUT, calcula y almacena los puntos, y luego los dibuja usando GLINE. Siento que esto podría ser más corto, pero es como la 1 AM, lo que sea. Asume un entorno de visualización limpio y predeterminado, por lo que es posible que lo necesite ACLSal ejecutarlo desde DIRECTO.

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

OpenSCAD: 31 menos 25% = 23.25

module p(n,r){circle(r,$fn=n);}

¡Primera publicación aquí! Sé que llego tarde a la fiesta, pero esta parecía una pregunta tan buena como cualquier otra para empezar. Llamar usando p(n,r).

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)

C # en LINQPAD

El crédito para la parte de matemáticas va a Geobits (¡espero que no te importe!) Con la respuesta de Java. No tengo esperanza en las matemáticas :)

Hice esto en LINQPAD ya que tiene una ventana de salida incorporada. Así que esencialmente puedes arrastrar y soltar lo siguiente y dibujará el polígono. Simplemente cámbielo a 'Programa C #' e importe System.Drawing lib en las propiedades de consulta.

//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);
}

Matlab 58 bytes - 25% = 43.5

No vi ninguna solución de Matlab, así que aquí hay una que es bastante sencilla:

f=@(n,r) plot(r*cos(0:2*pi/n:2*pi),r*sin(0:2*pi/n:2*pi));

Puede eliminar algunos bytes si r y n ya están en el espacio de trabajo.

Llamada de ejemplo:

f(7,8)

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)

Comprueba si un píxel está en el lado interno de todos los hiperplanos (líneas) del polígono. Se toca el radio porque en realidad se usa la apotema.

Mathematica 27 (= 36 - 25%)

Graphics[Polygon[CirclePoints[r, n]]]

Cuando enviamos el código de Mathematica, a menudo nos olvidamos de las nuevas funciones que se siguen incorporando al lenguaje, con el vocabulario actual del lenguaje acumulando alrededor de 5000 funciones principales . El vocabulario de idiomas amplio y en expansión es, por cierto, bastante útil para el golf de códigos. CirclePoints se introdujeron en la versión actual 11.X. Un ejemplo específico del radio 5 de 7 lados es:

También solo necesita ingresar el parámetro de ángulo para controlar la orientación de su polígono:

Graphics[Polygon[CirclePoints[{1, 2}, 5]]]

Python 2, 74 bytes - 25% = 55.5

La entrada está en las variables r,n. Si se incluye en el recuento, lo sería r,n=input(), por 12 bytes más.

import math,turtle as t
exec"t.fd(2*r*math.sin(180/n));t.rt(360/n);"*n

Pruébelo en línea : (utiliza un código diferente ya execque no está implementado en el intérprete en línea)

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

Las variables S y R se utilizan para la entrada.

Explicado:

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

Los lados se dibujan usando el color -I, que generalmente está cerca de -1 (& HFFFFFFFF blanco) (excepto cuando Ies 0, cuando es transparente).

También puede dibujar un polígono relleno utilizando en GTRI N,M,X,Y,R,R,-Ilugar deGLINE...

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}

Esta solución usa la biblioteca tikz shapes.geometric.

Así es como se ve un polígono con 5lados y radio 8incuando se ve en evidencia .