Le but de ce code golf est de dessiner un polygone régulier (un de même longueur de côté) étant donné le nombre de côtés et le rayon (distance du centre au sommet).

• Le nombre de côtés et le rayon peuvent être saisis via un fichier, STDIN ou simplement une ancienne variable simple. Utilisez ce qui est plus court dans votre langue.
• -25% du nombre total de caractères / octets si l'image est réellement dessinée au lieu de l'art ASCII.

LOGO 37-25% = 27,75 (avec variables)

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

LOGO 49-25% = 36,75 (en fonction)

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

Triangle

Appelé avec des variables

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

Utilisé en fonction P 100 3

Carré

Appelé avec des variables

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

Utilisé en fonction P 100 4

Pentagone

Appelé avec des variables

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

Utilisé en fonction P 100 5

Décagone

Appelé avec des variables

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

Utilisé en fonction P 100 10

Cercle

Appelé avec des variables

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

Utilisé en fonction P 100 360

Mathematica, 40 - 25% = 30

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

Java 8: 533 322 - 25% = 241,5

Eh bien, c'est Java: / Trace simplement des lignes, point à point. Devrait fonctionner pour tout polygone de taille arbitraire. Coupez-le un peu de sa taille d'origine. Un énorme crédit à Vulcan (dans les commentaires) pour la leçon 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();}}

Sauts de ligne:

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'entrée est des arguments [rayon] [côtés]:

java D 300 7

Sortie:

TeX / TikZ (60 - 80,25)

Fichier polygon.tex:

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

(80 octets)

Le rayon et le nombre de côtés sont fournis sous forme de variables / macros \ret \n. N'importe quelle unité TeX peut être donnée pour le rayon. Sans unité, l'unité par défaut cmest utilisée. Exemples:

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

(16 octets sans valeurs)

Si le numéro de page doit être supprimé, cela peut être fait par

\footline{}

(11 octets)

Exemples de génération de fichiers 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"

But:

Il n'est pas clair de savoir ce qui doit être compté. La plage de score serait:

• Le code de base est de 80 octets moins 25% = 60

• Ou tout compris (définitions des variables d'entrée, pas de numéro de page): (80 + 16 + 11) moins 25% = 80,25

• Si la connexion entre le premier et le dernier point n'a pas besoin d'être fluide, elle --cyclepourrait être supprimée, économisant 7 octets.

Géogebra , 42-25 % = 31,5 octets

Si vous comptez en caractères au lieu d'octets, ce serait 41 - 25% = 30,75 caractères.

(Autrement dit, si vous considérez Geogebra comme une langue ...)

Suppose que le rayon est stocké dans la variable ret le nombre de côtés stockés dans la variable s.

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

Celui-ci utilise le théorème de cosinus c ² = a ² + b ² - 2 ab cos C pour calculer la longueur du côté à partir du rayon donné.

Exemple de sortie pour 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 est le rayon du cercle)

Veuillez exécuter dans le terminal ANSI

Éditer:

• prendre la suggestion d'Ace
• utiliser d'anciennes variables (ou #define) en entrée
• utiliser le rayon du cercle circonscrit maintenant

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

compiler:

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

C, 359 caractères

Ma première tentative de golf. Au moins, il bat la solution 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);}

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

Et c'est le seul programme qui génère le polygone en ASCII au lieu de le dessiner. En raison de cela et de certains problèmes d'arrondi en virgule flottante, la sortie n'est pas particulièrement jolie (les caractères ASCII ne sont pas aussi hauts que larges).

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

Mathematica, 54 * 75% = 40,5

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

Je ne pense même pas qu'il y ait un point pour une version non golfée. Il ne contiendrait que plus d'espace.

Attend le rayon en variable ret le nombre de côtés en variable n. Le rayon est un peu vide de sens sans afficher les axes, car Mathematica met à l'échelle toutes les images pour les adapter.

Exemple d'utilisation:

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>

Version non golfée:

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

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

Passez le rayon, le nombre de côtés et le point central sur la ligne de commande

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

ou ajouter à la source

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

Déplacer vers le centre, agrandir le rayon, passer à (1,0); puis répétez n fois: faites une rotation de 360 ​​/ n, tracez la ligne jusqu'à (1,0); dessinez la dernière ligne, caressez et émettez la page.

Sauge , 44-25% = 33

Suppose que le nombre de côtés est stocké dans la svariable et le rayon est stocké dans la rvariable.

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

Exemple de sortie:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

Ce défi serait incomplet sans une réponse 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

Par exemple, ./polygon.sh 8 100produit cette image:

JavaScript 584 (867 non golfé)

Ce code utilise N Racines complexes d'unité et traduit les angles en X, Y points. L'origine est ensuite déplacée au centre du canevas.

Golfé

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

Exemple de sortie:

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

Ce code nécessite un élément canvas HTML5, c est un objet canvas, r est un rayon et n est un # de côtés.

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

Suppose deux variables prédéfinies: $ple nombre de points et $rle rayon en pixels. Alternativement, on pourrait ajouter à la place list(,$r,$p)=$argv;et utiliser des arguments de ligne de commande. La sortie sera un png, qui devrait être dirigé vers un fichier.

Production

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

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

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

Suppose que tous les paramètres sont définis sur les valeurs par défaut. Exécutez le programme comme 5:PRGM_POLYGON(pour un pentagone)

Cela fonctionne en dessinant un cercle avec un très petit nombre d'étapes. Par exemple, un pentagone aurait des pas de 2π / 5 radians.

Les paramètres de la fenêtre sont assez bons par défaut, et TMINet TMAXsont fixés à 0et 2π, donc tout ce que nous devons changer est TSTEP.

SmileBASIC 3, 183 159-25% = 119.25 octets

Prend les côtés et le rayon INPUT, calcule et stocke les points, puis les dessine à l'aide de GLINE. J'ai l'impression que ça pourrait être plus court mais c'est comme 1h du matin, peu importe. Suppose un environnement d'affichage propre et par défaut, de sorte que vous pourriez avoir besoin de l' ACLSexécuter à partir de 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 moins 25% = 23,25

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

Premier post ici! Je sais que je suis en retard à la fête, mais cela semblait être une bonne question pour commencer. Appelez en utilisant 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 # dans LINQPAD

Le crédit pour la partie mathématique revient aux Geobits (j'espère que cela ne vous dérange pas!) Avec la réponse Java. Je suis sans espoir en maths :)

J'ai fait cela dans LINQPAD car il a une fenêtre de sortie intégrée. Donc, essentiellement, vous pouvez faire glisser et déposer ce qui suit et il dessinera le polygone. Passez-le simplement sur 'Programme C #' et importez la bibliothèque System.Drawing dans les propriétés de la requête.

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

Je n'ai vu aucune solution Matlab, alors en voici une qui est assez simple:

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

Vous pouvez raser certains octets si r et n sont déjà dans l'espace de travail.

Exemple d'appel:

f(7,8)

Python 2, 222 octets

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)

Vérifie si un pixel se trouve à l'intérieur de tous les hyperplans (lignes) du polygone. Le rayon est touché car en fait l'apothème est utilisé.

Mathematica 27 (= 36 - 25%)

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

Lorsque nous soumettons du code Mathematica, nous oublions souvent les nouvelles fonctions qui continuent de s'intégrer dans le langage, le vocabulaire actuel du langage regroupant environ 5000 fonctions de base . Un vocabulaire linguistique étendu et en expansion est très pratique pour le golf de code. Les CirclePoints ont été introduits dans la version actuelle 11.X. Un exemple spécifique du rayon 5 à 7 côtés est:

Il vous suffit également de saisir le paramètre d'angle pour contrôler l'orientation de votre polygone:

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

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

L'entrée est dans les variables r,n. S'il était inclus dans le décompte, il le serait r,n=input()pour 12 octets de plus.

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

Essayez-le en ligne - (utilise un code différent car il execn'est pas implémenté dans l'interpréteur en ligne)

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

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

Les variables S et R sont utilisées pour l'entrée.

Expliqué:

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

Les côtés sont dessinés en utilisant la couleur -I, qui est généralement proche de -1 (& HFFFFFFFF blanc) (sauf quand Iest 0, quand il est transparent).

Vous pouvez également dessiner un polygone rempli en utilisant GTRI N,M,X,Y,R,R,-Iau lieu deGLINE...

Tikz, 199 octets

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

Cette solution utilise la bibliothèque tikz shapes.geometric.

Voici à quoi ressemble un polygone avec des 5côtés et un rayon 8inlorsqu'il est vu dans evince .