Bu kod golfünün amacı, taraf sayısı ve yarıçapı (merkezden köşeye olan mesafe) verilen düzenli bir çokgen (eşit kenar uzunluğunda olan) çekmektir.

• Kenarların sayısı ve yarıçap bir dosya, STDIN veya sadece eski bir değişkenle girilebilir. Dilinizde daha kısa olanı kullanın.
• Resim ASCII resmi yerine gerçekten çizilmişse, toplam karakterlerin / baytların% -25'i

LOGO 37 - 25% = 27.75 (değişkenlerle)

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

LOGO 49 - 25% = 36.75 (işlev olarak)

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

Üçgen

Değişkenlerle çağrıldı

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

İşlev olarak kullanılır P 100 3

Kare

Değişkenlerle çağrıldı

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

İşlev olarak kullanılır P 100 4

Pentagon

Değişkenlerle çağrıldı

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

İşlev olarak kullanılır P 100 5

dekagon

Değişkenlerle çağrıldı

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

İşlev olarak kullanılır P 100 10

Daire

Değişkenlerle çağrıldı

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

İşlev olarak kullanılır P 100 360

Mathematica,% 40 - 25 = 30

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

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

Şey, bu Java: / Sadece çizgiler çizer, noktadan noktaya. İsteğe bağlı herhangi bir çokgen için çalışmalıdır. Orijinal boyutundan bir miktar kesin. Golf dersi için Vulcan'a büyük yorumlar (yorumlarda).

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

Satır Sonları:

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

Girdi argümandır [yarıçap] [taraf]:

java D 300 7

Çıktı:

TeX / TikZ (60 - 80,25)

Dosya polygon.tex:

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

(80 bayt)

Yarıçap ve yan sayıları değişkenler / makrolar \rve \n. Yarıçap için herhangi bir TeX ünitesi verilebilir. Birim olmadan, varsayılan birim cmkullanılır. Örnekler:

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

(Değerleri olmayan 16 bayt)

Sayfa numarasının bastırılması gerekiyorsa,

\footline{}

(11 bayt)

PDF dosyaları oluşturmak için örnekler:

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"

Gol:

Neyin sayılması gerektiği belli değil. Puanın aralığı şöyle olacaktır:

• Temel kod 80 bayt eksi 25% = 60

• Veya herşey dahil (giriş değişkeni tanımları, sayfa numarası yok): (80 + 16 + 11) eksi% 25 = 80,25

• İlk ve son nokta arasındaki bağlantının düzgün olması gerekmiyorsa --cycle, 7 bayt tasarrufu sağlayarak çıkarılabilir.

Geogebra ,% 42 - 25 = 31,5 bayt

Bayt yerine karakter sayıyorsanız, bu 41 - 25% = 30.75 karakter olur.

(Geogebra'yı bir dil olarak düşünürseniz ...)

Yarıçapın değişkende rve değişkende saklanan taraf sayısının saklandığını varsayar s.

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

Bu , verilen yarıçaptan yan uzunluğu hesaplamak için kosinüs teoremi c ² = a ² + b ² - 2 ab cos C kullanır.

s= 7, r= 5 için örnek çıktı

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, yarıçapı yarıçapıdır)

Lütfen ANSI terminalinde çalıştırın

Düzenle:

• as'ın önerisini al
• girdi olarak eski değişkenleri (veya #define) kullanın
• Şimdi dairesel yarıçapı kullanın

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

derlemek:

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

C, 359 Karakter

Golfe ilk girişim. En azından Java çözümünü yener ;-)

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

Ve poligonu ASCII'de çizmek yerine çıkaran tek program bu. Bu ve bazı kayar nokta yuvarlama sorunları nedeniyle, çıktı özellikle hoş görünmüyor (ASCII Karakterleri kadar yüksek değil).

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

Mathematica, 54 * 75% = 40,5

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

Ungolge versiyonunun bir anlamı olduğunu sanmıyorum. Sadece daha fazla boşluk içerecektir.

Değişkende yarıçapı ve değişkende rkenar sayısını bekler n. Yarıçap, eksen görüntülemeden biraz anlamsızdır, çünkü Mathematica tüm görüntüleri sığacak şekilde ölçeklendirir.

Örnek kullanım:

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

<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

Komut satırında yarıçapı, kenar sayısını ve merkez noktasını geçin

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

veya kaynağa hazırlayın

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

Merkeze çevirin, yarıçapı ölçeklendirin, (1,0) konumuna getirin; daha sonra n kere tekrarlayın: 360 / n döndürün, çizgiyi (1,0) çizin; son çizgiyi çizin, vurun ve sayfayı yayınlayın.

Adaçayı , 44 - 25% = 33

Kenar sayısının sdeğişkende ve yarıçapın değişkende kaydedildiğini varsayar r.

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

Örnek çıktı:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

ImageMagick'in cevabı olmadan bu zorluk tam eksik olurdu ...

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

Örneğin, ./polygon.sh 8 100bu resmi üretir:

JavaScript 584 (867 ungolfed)

Bu kod, N Karmaşık Birlik Köklerini kullanır ve açıları X, Y noktalarına çevirir. Sonra orijin, tuvalin ortasına taşınır.

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

Örnek çıktı:

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

Bu kod, HTML5 canvas öğesi gerektirir, c canvas nesnesi, r yarıçapı ve n, iki taraftır.

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

Önceden tanımlanmış iki değişken varsayar: $pnokta sayısı ve $rpiksel cinsinden yarıçap. Alternatif olarak, list(,$r,$p)=$argv;bunun yerine komut satırı argümanları hazırlanabilir ve kullanılabilir. Çıktı bir dosyaya aktarılması gereken bir png olacaktır.

Çıktı

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

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

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

Tüm ayarların varsayılan değerlere ayarlandığını varsayalım. Programı 5:PRGM_POLYGONbir pentagon için çalıştırın.

Çok az adım adım olan bir daire çizerek çalışır. Örneğin, bir beşgen 2π / 5 radyanlı basamaklara sahip olacaktır.

Pencere ayarları varsayılan olarak yeterince iyi olup, TMINve TMAXayarlanır 0ve 2πdeğişime hepimiz ihtiyacıdır yüzden TSTEP.

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

Kenarları ve yarıçapı alır INPUT, noktaları hesaplar ve saklar, sonra da bunları kullanarak çizer GLINE. Bunun daha kısa olabileceğini hissediyorum ama saat 1 gibi, her neyse. Temiz ve varsayılan bir ekran env varsayar, bu nedenle DIRECT'ten ACLSçalıştırırken buna ihtiyaç duyabilirsiniz .

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 daha az% 25 = 23,25

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

Buraya ilk gönderi! Partiye geç kaldığımı biliyorum, ama bu başlangıç ​​için herhangi bir soru kadar güzel görünüyordu. Kullanarak arayın 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)

LINQPAD'deki C #

Matematik bölümünün kredisi Java cevabıyla Geobits'e (umarım sakıncası yoktur!) Gider. Ben matematikte umutsuzum :)

Bunu LINQPAD'de yaptım çünkü çıktı penceresinde bir yerleşik var. Bu yüzden, temelde aşağıdakini içine sürükleyip bırakabilirsiniz ve poligonu çizer. Sadece 'C # Programa' geçin ve System.Drawing lib dosyasını sorgu özelliklerine alın.

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

Hiçbir Matlab çözümü görmedim, bu yüzden oldukça basit bir tane var:

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

R ve n zaten çalışma alanındaysa, bazı baytları tıraş edebilirsiniz .

Örnek çağrı:

f(7,8)

Python 2,222 bayt

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)

Poligonun tüm hiper düzlemlerinin (çizgilerinin) iç tarafında bir piksel olup olmadığını kontrol eder. Yarıçapa dokunulur çünkü aslında apothem kullanılır.

Mathematica 27 (=% 36 - 25)

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

Mathematica kodunu gönderdiğimizde, dilin içine girmeye devam eden yeni işlevler hakkında sık sık unuturuz, mevcut dil kelimeleri yaklaşık 5000 temel işlevi bir araya getirir . Geniş ve genişleyen dil kelime dağarcığı btw kod golf için oldukça kullanışlıdır. CirclePoints şimdiki sürüm 11.X'te tanıtıldı. 7 taraflı yarıçapı 5'in belirli bir örneği şöyledir:

Ayrıca çokgeninizin yönünü kontrol etmek için sadece açı parametresini girmeniz gerekir:

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

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

Girdi değişkenlerde r,n. Sayıma dahil olsaydı r,n=input(), 12 bayt daha fazla olurdu .

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

Çevrimiçi deneyin - ( execçevrimiçi tercümana uygulanmadığından farklı kodlar kullanır )

SmileBASIC, 85 75 - 25% = 56.25 bayt

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

S ve R değişkenleri giriş için kullanılır.

Açıklaması:

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

Yanlar -I, genellikle -1'e yakın olan (& HFFFFFFFF beyaz) renk kullanılarak çizilir ( Işeffaf olduğunda 0 olduğunda).

Kullanarak doldurulmuş bir çokgen çizebilirsiniz GTRI N,M,X,Y,R,R,-I.GLINE...

Tikz, 199 bayt

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

Bu çözüm tikz kütüphanesini kullanır shapes.geometric.

İşte evansta bakıldığında 5kenarları ve yarıçapı olan bir çokgen nasıl 8ingörünüyor .