Tujuan dari golf kode ini adalah untuk menggambar poligon reguler (satu dengan panjang sisi yang sama) dengan jumlah sisi dan jari-jari (jarak dari pusat ke puncak).

• Jumlah sisi dan jari-jari dapat dimasukkan melalui file, STDIN, atau hanya variabel lama biasa. Gunakan apa pun yang lebih pendek dalam bahasa Anda.
• -25% dari total karakter / byte jika gambar benar-benar diambil alih-alih ASCII art.

LOGO 37 - 25% = 27,75 (dengan variabel)

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

LOGO 49 - 25% = 36,75 (sebagai fungsi)

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

Segi tiga

Disebut dengan variabel

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

Digunakan sebagai fungsi P 100 3

Kotak

Disebut dengan variabel

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

Digunakan sebagai fungsi P 100 4

Segi lima

Disebut dengan variabel

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

Digunakan sebagai fungsi P 100 5

Decagon

Disebut dengan variabel

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

Digunakan sebagai fungsi P 100 10

Lingkaran

Disebut dengan variabel

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

Digunakan sebagai fungsi P 100 360

Mathematica, 40 - 25% = 30

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

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

Yah, itu Java: / Hanya menggambar garis, titik ke titik. Harus bekerja untuk poligon berukuran sewenang-wenang. Potong sedikit dari ukuran aslinya. Penghargaan besar untuk Vulcan (dalam komentar) untuk pelajaran 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();}}

Line Breaks:

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

Input adalah argumen [radius] [sisi]:

java D 300 7

Keluaran:

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)

Jari-jari dan jumlah sisi disediakan sebagai variabel / makro \rdan \n. Setiap unit TeX dapat diberikan untuk jari-jari. Tanpa unit, unit default cmdigunakan. Contoh:

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

(16 byte tanpa nilai)

Jika nomor halaman harus ditekan, maka itu bisa dilakukan oleh

\footline{}

(11 byte)

Contoh untuk menghasilkan 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"

Skor:

Tidak jelas, apa yang perlu dihitung. Kisaran untuk skor adalah:

• Kode dasar adalah 80 byte dikurangi 25% = 60

• Atau semua inklusif (definisi variabel input, tidak ada nomor halaman): (80 + 16 + 11) minus 25% = 80,25

• Jika koneksi antara titik pertama dan terakhir tidak perlu mulus, maka --cycledapat dihapus, menghemat 7 byte.

Geogebra , 42 - 25% = 31,5 byte

Jika Anda menghitung dalam karakter daripada byte, ini akan menjadi 41 - 25% = 30,75 karakter.

(Yaitu, jika Anda menganggap Geogebra sebagai bahasa ...)

Asumsikan jari-jari disimpan dalam variabel rdan jumlah sisi yang disimpan dalam variabel s.

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

Ini menggunakan teorema cosinus c ² = a ² + b ² - 2 ab cos C untuk menghitung panjang sisi dari jari-jari yang diberikan.

Output sampel untuk 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 adalah jari-jari incircle)

Silakan jalankan di terminal ANSI

Edit:

• terima saran ace
• gunakan variabel lama (atau #define) sebagai input
• gunakan jari-jari lingkaran sekarang

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

menyusun:

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

C, 359 Chars

Upaya pertama saya bermain golf. Setidaknya itu mengalahkan solusi 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);
}

Dan itu satu-satunya program yang mengeluarkan poligon di ASCII alih-alih menggambarnya. Karena ini dan beberapa masalah pembulatan floating point, output tidak terlihat sangat cantik (ASCII Chars tidak setinggi selebar).

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

Mathematica, 54 * 75% = 40,5

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

Saya bahkan tidak berpikir ada gunanya untuk versi yang tidak serigala. Itu hanya akan berisi lebih banyak ruang putih.

Mengharapkan jari-jari dalam variabel rdan jumlah sisi dalam variabel n. Jari-jari sedikit tidak berarti tanpa menampilkan sumbu, karena Mathematica menskala semua gambar agar sesuai.

Contoh penggunaan:

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 tidak disatukan:

<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

Lewati jari-jari, jumlah sisi, dan titik tengah pada baris perintah

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

atau bergantung pada sumbernya

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

Menerjemahkan ke tengah, meningkatkan ke jari-jari, pindah ke (1,0); lalu ulangi n kali: putar 360 / n, tarik garis ke (1,0); menggambar garis akhir, usap dan keluarkan halaman.

Sage , 44 - 25% = 33

Mengasumsikan jumlah sisi disimpan dalam svariabel dan jari-jari disimpan dalam rvariabel.

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

Output sampel:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

Tantangan ini tidak akan lengkap tanpa jawaban 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

Misalnya, ./polygon.sh 8 100buat gambar ini:

JavaScript 584 (867 tidak bercak)

Kode ini menggunakan N Complex Roots of unity dan menerjemahkan sudut ke X, poin Y. Kemudian asal dipindahkan ke pusat kanvas.

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

Output sampel:

Tidak disatukan

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

Kode ini membutuhkan elemen kanvas HTML5, c adalah objek kanvas, r adalah jari-jari dan n adalah # sisi.

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

Mengasumsikan dua variabel yang telah ditentukan: $pjumlah titik, dan $rjari-jari dalam piksel. Atau, seseorang bisa menambahkan list(,$r,$p)=$argv;dan menggunakan argumen baris perintah sebagai gantinya. Output akan menjadi png, yang harus disalurkan ke file.

Keluaran

$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

Mengasumsikan semua pengaturan diatur ke nilai default. Jalankan program seperti 5:PRGM_POLYGON(untuk pentagon)

Ini bekerja dengan menggambar lingkaran dengan jumlah langkah yang sangat rendah. Misalnya, pentagon memiliki langkah 2π / 5 radian.

Pengaturan jendela yang cukup baik secara default, dan TMINdan TMAXditetapkan untuk 0dan 2π, sehingga semua kita perlu perubahan adalah TSTEP.

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

Mengambil sisi dan jari-jari dari INPUT, menghitung dan menyimpan poin, dan kemudian menariknya dengan menggunakan GLINE. Saya merasa ini bisa lebih pendek tapi seperti jam 1 pagi. Mengasumsikan env tampilan bersih dan default, jadi Anda mungkin perlu ACLSketika menjalankannya dari 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 kurang 25% = 23,25

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

Posting pertama di sini! Aku tahu aku terlambat ke pesta, tapi sepertinya ini pertanyaan yang bagus. Panggilan menggunakan 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 # di LINQPAD

Penghargaan untuk bagian matematika diberikan kepada Geobits (saya harap Anda tidak keberatan!) Dengan jawaban Java. Saya putus asa dalam matematika :)

Saya melakukan ini di LINQPAD karena punya jendela keluaran bawaan. Jadi pada dasarnya Anda dapat menarik dan melepas yang berikut ke dalamnya dan itu akan menggambar poligon. Alihkan saja ke 'C # Program', dan impor lib System.Drawing ke properti kueri.

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

Tidak melihat solusi Matlab, jadi di sini ada satu yang cukup mudah:

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

Anda dapat memotong beberapa byte jika r dan n sudah ada di ruang kerja.

Contoh panggilan:

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)

Periksa apakah sebuah piksel berada di sisi dalam semua hyperplanes (garis) poligon. Jari-jari tersentuh karena sebenarnya apothem digunakan.

Mathematica 27 (= 36 - 25%)

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

Ketika kita mengirimkan kode Mathematica kita sering lupa tentang fungsi-fungsi baru yang terus dibangun ke dalam bahasa, dengan kosakata bahasa saat ini mengumpulkan sekitar 5000 fungsi inti . Kosakata bahasa yang luas dan meluas sangat berguna untuk bermain golf kode. CirclePoints diperkenalkan di versi saat ini 11.X. Contoh spesifik jari-jari 7-sisi 5 adalah:

Anda juga hanya perlu memasukkan parameter sudut untuk mengontrol orientasi poligon Anda:

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

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

Input ada dalam variabel r,n. Jika dimasukkan dalam hitungan, itu akan menjadi r,n=input(), selama 12 byte lebih.

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

Cobalah online - (menggunakan kode yang berbeda karena exectidak diterapkan dalam juru bahasa 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

Variabel S dan R digunakan untuk input.

Dijelaskan:

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

Sisi-sisinya digambar menggunakan warna -I, yang biasanya mendekati -1 (& HFFFFFFFF putih) (kecuali bila I0, bila transparan).

Anda juga bisa menggambar poligon terisi dengan menggunakan GTRI N,M,X,Y,R,R,-Ialih-alihGLINE...

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}

Solusi ini menggunakan perpustakaan tikz shapes.geometric.

Inilah poligon dengan 5sisi dan jari-jari 8interlihat ketika dilihat di evince .