L'obiettivo di questo codice golf è disegnare un poligono regolare (uno con uguale lunghezza dei lati) dato il numero di lati e raggio (distanza dal centro al vertice).

• Il numero di lati e il raggio possono essere inseriti tramite un file, STDIN o semplicemente una vecchia variabile semplice. Usa ciò che è più corto nella tua lingua.
• -25% del totale dei caratteri / byte se l'immagine è effettivamente disegnata al posto della grafica ASCII.

LOGO 37 - 25% = 27.75 (con variabili)

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

LOGO 49 - 25% = 36.75 (come funzione)

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

Triangolo

Chiamato con variabili

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

Usato come una funzione P 100 3

Piazza

Chiamato con variabili

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

Usato come una funzione P 100 4

Pentagono

Chiamato con variabili

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

Usato come una funzione P 100 5

Decagono

Chiamato con variabili

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

Usato come una funzione P 100 10

Cerchio

Chiamato con variabili

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

Usato come una funzione P 100 360

Mathematica, 40-25% = 30

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

Java 8: 533 322 - 25% = 241.5

Bene, è Java: / Disegna solo linee, punto per punto. Dovrebbe funzionare per qualsiasi poligono di dimensioni arbitrarie. Riducilo un po 'dalle dimensioni originali. Enorme merito a Vulcano (nei commenti) per la lezione di 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();}}

Interruzioni di riga:

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

L'input è argomenti [raggio] [lati]:

java D 300 7

Produzione:

TeX / TikZ (60-80,25)

File polygon.tex:

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

(80 byte)

Il raggio e il numero di lati sono forniti come variabili / macro \re \n. È possibile fornire qualsiasi unità TeX per il raggio. Senza unità, cmviene utilizzata l'unità predefinita . Esempi:

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

(16 byte senza valori)

Se il numero di pagina deve essere soppresso, è possibile farlo

\footline{}

(11 byte)

Esempi per la generazione di file 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"

Punto:

Non è chiaro a cosa bisogna contare. L'intervallo per il punteggio sarebbe:

• Il codice di base è 80 byte meno il 25% = 60

• O tutto compreso (definizione delle variabili di input, nessun numero di pagina): (80 + 16 + 11) meno 25% = 80,25

• Se non è necessario che la connessione tra il primo e l'ultimo punto sia fluida, è --cyclepossibile rimuoverla, risparmiando 7 byte.

Geogebra , 42-25 % = 31,5 byte

Se conti in caratteri anziché in byte, questo sarebbe 41 - 25% = 30.75 caratteri.

(Cioè, se consideri Geogebra una lingua ...)

Presuppone che il raggio sia memorizzato nella variabile re il numero di lati memorizzati nella variabile s.

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

Questo utilizza il teorema del coseno c ² = a ² + b ² - 2 ab cos C per calcolare la lunghezza laterale dal raggio dato.

Uscita campione per 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 è il raggio di incircle)

Si prega di eseguire nel terminale ANSI

Modificare:

• prendi il consiglio dell'asso
• usa le vecchie variabili (o #define) come input
• usa il raggio del cerchio ora

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

compilare:

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

C, 359 caratteri

Il mio primo tentativo di giocare a golf. Almeno batte la soluzione 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);}

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

Ed è l'unico programma che genera il poligono in ASCII invece di disegnarlo. A causa di questo e di alcuni problemi di arrotondamento in virgola mobile, l'output non sembra particolarmente bello (i caratteri ASCII non sono così alti).

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

Mathematica, 54 * 75% = 40.5

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

Non penso nemmeno che ci sia un punto per una versione non giocata. Conterrebbe solo più spazi bianchi.

Prevede il raggio in variabile re il numero di lati in variabile n. Il raggio è un po 'insignificante senza visualizzare gli assi, poiché Mathematica ridimensiona tutte le immagini per adattarle.

Esempio di utilizzo:

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>

Versione non golfata:

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

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

Passa il raggio, il numero di lati e il punto centrale sulla riga di comando

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

o anteporre alla fonte

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

Trasla al centro, scala fino al raggio, sposta a (1,0); quindi ripetere n volte: ruotare di 360 / n, disegnare la linea su (1,0); disegna la linea finale, traccia ed emette la pagina.

Salvia , 44-25% = 33

Presuppone che il numero di lati sia memorizzato nella svariabile e il raggio sia memorizzato nella rvariabile.

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

Uscita campione:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

bc + ImageMagick + xview + bash, 104,25 (139 byte - 25%)

Questa sfida sarebbe incompleta senza una risposta 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

Ad esempio, ./polygon.sh 8 100produce questa immagine:

JavaScript 584 (867 ungolfed)

Questo codice utilizza N Radici complesse di unità e traduce gli angoli in punti X, Y. Quindi l'origine viene spostata al centro dell'area di disegno.

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

Uscita campione:

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

Questo codice richiede l'elemento canvas HTML5, c è oggetto canvas, r è raggio e n è # di lati.

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

Presuppone due variabili predefinite: $pil numero di punti e $ril raggio in pixel. In alternativa, è possibile anteporre list(,$r,$p)=$argv;e utilizzare gli argomenti della riga di comando. L'output sarà un png, che dovrebbe essere reindirizzato a un file.

Produzione

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

TI-80 BASIC, 25 byte - 25% = 18,75

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

Presuppone che tutte le impostazioni siano impostate sui valori predefiniti. Esegui il programma come 5:PRGM_POLYGON(per un pentagono)

Funziona disegnando un cerchio con un numero molto basso di passaggi. Ad esempio, un pentagono avrebbe passi di 2π / 5 radianti.

Le impostazioni della finestra sono buone abbastanza per impostazione predefinita e TMINe TMAXsono impostati 0e 2π, in modo che tutti abbiamo bisogno di cambiare è TSTEP.

SmileBASIC 3, 183 159-25 % = 119,25 byte

Prende i lati e il raggio da INPUT, calcola e memorizza i punti, quindi li disegna usando GLINE. Sento che questo potrebbe essere più breve ma è come l'una del mattino, qualunque cosa. Presuppone un ambiente di visualizzazione pulito e predefinito, quindi potrebbe essere necessario ACLSeseguirlo da 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

OpenSCAD: 31 in meno 25% = 23,25

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

Primo post qui! So di essere in ritardo alla festa, ma questa sembrava una domanda tanto valida quanto una qualsiasi per cominciare. Chiama 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 # in LINQPAD

Il merito della parte matematica va a Geobits (spero non ti dispiaccia!) Con la risposta Java. Sono senza speranza in matematica :)

L'ho fatto in LINQPAD in quanto ha una finestra di output integrata. Quindi essenzialmente puoi trascinare e rilasciare quanto segue e disegnerà il poligono. Basta passare a 'Programma C #' e importare la libreria System.Drawing nelle proprietà della query.

//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 byte - 25% = 43,5

Non ho visto la soluzione Matlab, quindi eccone una abbastanza semplice:

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

È possibile radere alcuni byte se r e n sono già nell'area di lavoro.

Esempio di chiamata:

f(7,8)

Python 2, 222 byte

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)

Verifica se un pixel si trova sul lato interno di tutti gli iperpiani (linee) del poligono. Il raggio viene toccato perché in realtà viene usato l'apotema.

Mathematica 27 (= 36-25%)

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

Quando inviamo il codice Mathematica spesso ci dimentichiamo delle nuove funzioni che continuano ad essere integrate nella lingua, con il vocabolario della lingua corrente che accumula circa 5000 funzioni principali . Vocabolario linguistico ampio e in espansione è molto utile per giocare a golf. CirclePoints sono stati introdotti nell'attuale versione 11.X. Un esempio specifico di raggio a 7 facce 5 è:

Inoltre, devi solo inserire il parametro angolo per controllare l'orientamento del poligono:

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

Python 2, 74 byte - 25% = 55,5

L'input è nelle variabili r,n. Se incluso nel conteggio, sarebbe r,n=input(), per 12 byte in più.

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

Provalo online - (utilizza un codice diverso poiché execnon è implementato nell'interprete online)

SmileBASIC, 85 75-25 % = 56,25 byte

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

Le variabili S e R sono utilizzate per l'input.

Ha spiegato:

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

I lati sono disegnati usando il colore -I , che di solito è vicino a -1 (& bianco HFFFFFFFF) (tranne quandoI è 0, quando è trasparente).

Puoi anche disegnare un poligono riempito usando GTRI N,M,X,Y,R,R,-Iinvece diGLINE...

Tikz, 199 byte

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

Questa soluzione utilizza la libreria tikz shapes.geometric .

Ecco come appare un poligono con 5lati e raggio 8inse visto in evince .