Das Ziel dieses Codegolfs ist es, ein regelmäßiges Polygon (eines mit gleichen Seitenlängen) zu zeichnen, das die Anzahl der Seiten und den Radius (Abstand von der Mitte zum Scheitelpunkt) angibt.

• Die Anzahl der Seiten und der Radius können über eine Datei, STDIN oder einfach eine alte Variable eingegeben werden. Verwenden Sie, was in Ihrer Sprache kürzer ist.
• -25% aller Zeichen / Bytes, wenn das Bild tatsächlich anstelle von ASCII-Grafiken gezeichnet wird.

LOGO 37 - 25% = 27,75 (mit Variablen)

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

LOGO 49 - 25% = 36,75 (als Funktion)

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

Dreieck

Wird mit Variablen aufgerufen

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

Wird als Funktion verwendet P 100 3

Platz

Wird mit Variablen aufgerufen

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

Wird als Funktion verwendet P 100 4

Pentagon

Wird mit Variablen aufgerufen

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

Wird als Funktion verwendet P 100 5

Zehneck

Wird mit Variablen aufgerufen

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

Wird als Funktion verwendet P 100 10

Kreis

Wird mit Variablen aufgerufen

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

Wird als Funktion verwendet P 100 360

Mathematica, 40 - 25% = 30

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

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

Nun, es ist Java: / Zeichnet nur Linien, Punkt zu Punkt. Sollte für ein beliebig großes Polygon funktionieren. Schneiden Sie es ziemlich weit von der Originalgröße ab. Wir danken Vulcan (in Kommentaren) für die Golfstunde.

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

Zeilenumbrüche:

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

Eingabe ist Argumente [Radius] [Seiten]:

java D 300 7

Ausgabe:

TeX / TikZ (60 - 80,25)

Datei polygon.tex:

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

(80 Bytes)

Der Radius und die Anzahl der Seiten werden als Variablen / Makros \rund angegeben \n. Für den Radius kann eine beliebige TeX-Einheit angegeben werden. Ohne Einheit wird die Standardeinheit cmverwendet. Beispiele:

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

(16 Bytes ohne Werte)

Wenn die Seitenzahl unterdrückt werden soll, kann dies mit erfolgen

\footline{}

(11 Bytes)

Beispiele zum Generieren von PDF-Dateien:

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"

Ergebnis:

Es ist nicht klar, was gezählt werden muss. Der Bereich für die Punktzahl wäre:

• Der Basiscode ist 80 Bytes minus 25% = 60

• Oder alles inklusive (Definition der Eingabevariablen, keine Seitenzahl): (80 + 16 + 11) minus 25% = 80,25

• Wenn die Verbindung zwischen dem ersten und dem letzten Punkt nicht glatt sein muss, --cyclekann sie entfernt werden, wodurch 7 Byte eingespart werden.

Geogebra , 42 - 25% = 31,5 Bytes

Wenn Sie anstelle von Bytes Zeichen eingeben, sind dies 41 - 25% = 30,75 Zeichen.

(Das heißt, wenn Sie Geogebra als eine Sprache betrachten ...)

Angenommen, der Radius ist in der Variablen rund die Anzahl der Seiten in der Variablen gespeichert s.

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

Dies verwendet den Cosinussatz c ² = a ² + b ² - 2 ab cos C , um die Seitenlänge aus dem gegebenen Radius zu berechnen.

Beispielausgabe für 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 ist der Radius des Kreises)

Bitte laufen in ANSI-Terminal

Bearbeiten:

• nimm den Vorschlag von Ass an
• Verwenden Sie alte Variablen (oder #define) als Eingabe
• Verwenden Sie jetzt den Umkreisradius

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

kompilieren:

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

C 359 Zeichen

Mein erster Golfversuch. Zumindest schlägt es die Java-Lösung ;-)

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

Und es ist das einzige Programm, das das Polygon in ASCII ausgibt, anstatt es zu zeichnen. Aufgrund dieser und einiger Gleitkomma-Rundungsprobleme sieht die Ausgabe nicht besonders hübsch aus (ASCII-Zeichen sind nicht so hoch wie breit).

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

Mathematica, 54 * 75% = 40,5

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

Ich glaube nicht einmal, dass es einen Sinn für eine ungolfed Version gibt. Es würde nur mehr Leerzeichen enthalten.

Erwartet den Radius in Variable rund die Anzahl der Seiten in Variable n. Der Radius ist ein bisschen bedeutungslos, ohne dass Achsen angezeigt werden, da Mathematica alle Bilder so skaliert, dass sie passen.

Anwendungsbeispiel:

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>

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

Übergeben Sie den Radius, die Anzahl der Seiten und den Mittelpunkt in der Befehlszeile

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

oder der Quelle voranstellen

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

In die Mitte verschieben, auf den Radius skalieren und auf (1,0) verschieben. dann n-mal wiederholen: um 360 / n drehen, Linie auf (1,0) zeichnen; Letzte Linie zeichnen, streichen und die Seite ausgeben.

Salbei , 44 - 25% = 33

Angenommen, die Anzahl der Seiten ist in der sVariablen und der Radius in der rVariablen gespeichert .

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

Beispielausgabe:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

Diese Herausforderung wäre ohne eine ImageMagick-Antwort unvollständig ...

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

Beispiel: ./polygon.sh 8 100Erzeugt das folgende Bild:

JavaScript 584 (867 ungolfed)

Dieser Code verwendet N komplexe Wurzeln der Einheit und übersetzt die Winkel in X-, Y-Punkte. Dann wird der Ursprung in die Mitte der Leinwand verschoben.

Golf gespielt

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

Beispielausgabe:

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

Für diesen Code ist ein HTML5-Zeichenflächenelement erforderlich, c ist ein Zeichenflächenobjekt, r ist der Radius und n ist die Anzahl der Seiten.

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

Nimmt zwei vordefinierte Variablen an: $pdie Anzahl der Punkte und $rden Radius in Pixel. Alternativ könnte man auch voranstellenlist(,$r,$p)=$argv; stattdessen Befehlszeilenargumente und verwenden. Die Ausgabe ist ein PNG, das an eine Datei weitergeleitet werden soll.

Ausgabe

$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

Angenommen, alle Einstellungen werden auf die Standardwerte gesetzt. Führen Sie das Programm wie folgt aus5:PRGM_POLYGON folgt aus (für ein Fünfeck)

Es funktioniert durch Zeichnen eines Kreises mit einer sehr geringen Anzahl von Schritten. Zum Beispiel würde ein Fünfeck Schritte von 2π / 5 Radiant haben.

Die Fenstereinstellungen sind standardmäßig gut genug, und TMINund TMAXsind auf 0und eingestellt 2π. Alles, was wir ändern müssen, ist TSTEP.

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

Nimmt die Seiten und den Radius ab INPUT, berechnet und speichert die Punkte und zeichnet sie dann mit GLINE. Ich denke, das könnte kürzer sein, aber es ist wie 1 Uhr morgens, egal was. Es wird eine saubere und standardmäßige Anzeigeumgebung vorausgesetzt, daher müssen Sie diese möglicherweise ausführen, ACLSwenn Sie sie in DIRECT ausführen.

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 abzüglich 25% = 23,25

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

Erster Beitrag hier! Ich weiß, dass ich zu spät zur Party komme, aber das schien mir eine gute Frage zu sein. Mit anrufen 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

Der mathematische Teil geht mit der Java-Antwort an Geobits (ich hoffe, es macht Ihnen nichts aus!). Ich bin in Mathe hoffnungslos :)

Ich habe das in LINQPAD gemacht, da es ein eingebautes Ausgabefenster hat. Sie können also im Wesentlichen die folgenden Elemente ziehen und ablegen, um das Polygon zu zeichnen. Wechseln Sie einfach zu "C # -Programm" und importieren Sie die System.Drawing-Bibliothek in die Abfrageeigenschaften.

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

Ich habe keine Matlab-Lösung gesehen, daher hier eine, die ziemlich einfach ist:

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

Sie können einige Bytes abschneiden, wenn r und n bereits im Arbeitsbereich befinden.

Beispielaufruf:

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)

Überprüft, ob sich ein Pixel auf der Innenseite aller Hyperebenen (Linien) des Polygons befindet. Der Radius wird berührt, weil tatsächlich das Apothem verwendet wird.

Mathematica 27 (= 36 - 25%)

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

Wenn wir Mathematica-Code einreichen, vergessen wir häufig neue Funktionen, die immer wieder in die Sprache integriert werden. Das aktuelle Sprachvokabular umfasst rund 5000 Kernfunktionen . Ein umfangreiches und erweitertes Sprachvokabular ist übrigens sehr praktisch für das Code-Golfen. CirclePoints wurden in der aktuellen Version 11.X eingeführt. Ein spezielles Beispiel für den 7-seitigen Radius 5 ist:

Außerdem müssen Sie nur den Winkelparameter eingeben, um die Ausrichtung Ihres Polygons zu steuern:

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

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

Die Eingabe erfolgt in den Variablen r,n. Wenn in der Zählung enthalten, wäre es r,n=input()für 12 Bytes mehr.

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

Probieren Sie es online aus - (verwendet einen anderen Code, da dieser execnicht im Online-Interpreter implementiert ist)

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

Die Variablen S und R werden zur Eingabe verwendet.

Erklärt:

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

Die Seiten werden mit der Farbe gezeichnet -I, die normalerweise in der Nähe von -1 liegt (& HFFFFFFFF weiß) (außer wennI 0 ist, wenn es transparent ist).

Sie können auch ein gefülltes Polygon zeichnen, indem Sie GTRI N,M,X,Y,R,R,-Ianstelle von verwendenGLINE...

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}

Diese Lösung verwendet die Tikz-Bibliothek shapes.geometric.

So sieht ein Polygon mit 5Seiten und Radius 8inaus, wenn es in Evince angezeigt wird .