Mục tiêu của môn đánh gôn này là vẽ một đa giác thông thường (một hình có độ dài cạnh bằng nhau) với số cạnh và bán kính (khoảng cách từ tâm đến đỉnh).

• Số lượng các cạnh và bán kính có thể được nhập thông qua một tệp, STDIN hoặc chỉ là một biến cũ đơn giản. Sử dụng bất cứ điều gì ngắn hơn trong ngôn ngữ của bạn.
• -25% tổng số ký tự / byte nếu hình ảnh thực sự được vẽ thay vì nghệ thuật ASCII.

LOGO 37 - 25% = 27,75 (có biến)

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

LOGO 49 - 25% = 36,75 (dưới dạng hàm)

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

Tam giác

Được gọi với các biến

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

Được sử dụng như một chức năng P 100 3

Quảng trường

Được gọi với các biến

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

Được sử dụng như một chức năng P 100 4

Lầu năm góc

Được gọi với các biến

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

Được sử dụng như một chức năng P 100 5

Decagon

Được gọi với các biến

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

Được sử dụng như một chức năng P 100 10

Vòng tròn

Được gọi với các biến

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

Được sử dụng như một chức năng P 100 360

Toán học, 40 - 25% = 30

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

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

Chà, đó là Java: / Chỉ cần vẽ các đường, điểm tới điểm. Nên làm việc cho bất kỳ đa giác có kích thước tùy ý. Cắt nó xuống một chút so với kích thước ban đầu. Tín dụng lớn cho Vulcan (trong các bình luận) cho bài học 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();}}

Phá vỡ dòng:

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

Đầu vào là đối số [radius] [side]:

java D 300 7

Đầu ra:

TeX / TikZ (60 - 80,25)

Tập tin polygon.tex:

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

(80 byte)

Bán kính và số cạnh được cung cấp dưới dạng biến / macro \rvà \n. Bất kỳ đơn vị TeX có thể được đưa ra cho bán kính. Không có đơn vị, đơn vị mặc định cmđược sử dụng. Ví dụ:

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

(16 byte không có giá trị)

Nếu số trang phải bị loại bỏ, thì nó có thể được thực hiện bởi

\footline{}

(11 byte)

Ví dụ để tạo tệp 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"

Ghi bàn:

Nó không rõ ràng, những gì cần đếm. Phạm vi cho điểm sẽ là:

• Mã cơ sở là 80 byte trừ 25% = 60

• Hoặc bao gồm tất cả (định nghĩa biến đầu vào, không có số trang): (80 + 16 + 11) trừ 25% = 80,25

• Nếu kết nối giữa điểm đầu tiên và điểm cuối không cần phải trơn tru, thì --cyclecó thể xóa, lưu 7 byte.

Hình học , 42 - 25% = 31,5 byte

Nếu bạn tính bằng ký tự thay vì byte, đây sẽ là 41 - 25% = 30,75 ký tự.

(Đó là, nếu bạn coi Geogebra là ngôn ngữ ...)

Giả sử bán kính được lưu trữ trong biến rvà số cạnh được lưu trữ trong biến s.

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

Điều này sử dụng định lý cosin c ² = a ² + b ² - 2 ab cos C để tính độ dài cạnh từ bán kính đã cho.

Sản lượng mẫu cho 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 là bán kính của hình tròn)

Vui lòng chạy trong thiết bị đầu cuối ANSI

Chỉnh sửa:

• đề nghị của ace
• sử dụng các biến cũ (hoặc #define) làm đầu vào
• sử dụng bán kính vòng tròn bây giờ

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

biên dịch:

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

C, 359 ký tự

Nỗ lực đầu tiên của tôi tại golf. Ít nhất là nó đánh bại giải pháp 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);}

vô dụng:

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

Và đó là chương trình duy nhất đưa ra đa giác trong ASCII thay vì vẽ nó. Do vấn đề này và một số vấn đề làm tròn điểm nổi, đầu ra trông không được đẹp lắm (ASCII Chars không cao bằng chiều rộng).

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

Toán học, 54 * 75% = 40,5

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

Tôi thậm chí không nghĩ rằng có một điểm cho một phiên bản không có căn cứ. Nó sẽ chỉ chứa nhiều khoảng trắng hơn.

Dự kiến ​​bán kính trong biến rvà số cạnh trong biến n. Bán kính là một chút vô nghĩa khi không hiển thị các trục, bởi vì Mathicala chia tỷ lệ tất cả các hình ảnh cho phù hợp.

Ví dụ sử dụng:

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>

Phiên bản bị đánh cắp:

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

Phần tái bút 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

Vượt qua bán kính, số cạnh và điểm trung tâm trên dòng lệnh

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

hoặc thêm vào nguồn

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

Dịch vào trung tâm, mở rộng theo bán kính, di chuyển đến (1,0); sau đó lặp lại n lần: xoay 360 / n, vẽ đường thẳng tới (1,0); vẽ dòng cuối cùng, đột quỵ và phát ra trang.

Hiền nhân , 44 - 25% = 33

Giả sử số cạnh được lưu trữ trong sbiến và bán kính được lưu trong rbiến.

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

Đầu ra mẫu:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

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

Thử thách này sẽ không đầy đủ nếu không có câu trả lời của 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

Ví dụ: ./polygon.sh 8 100tạo hình ảnh này:

JavaScript 584 (867 vô danh)

Mã này sử dụng N Complex Roots of unity và dịch các góc thành các điểm X, Y. Sau đó, nguồn gốc được chuyển đến trung tâm của khung vẽ.

Chơi gôn

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

Đầu ra mẫu:

Ung dung

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

Mã này yêu cầu phần tử canvas HTML5, c là đối tượng canvas, r là bán kính và n là # của các cạnh.

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

Giả sử hai biến được xác định trước: $psố lượng điểm và $rbán kính tính bằng pixel. Ngoài ra, người ta có thể trả trước list(,$r,$p)=$argv;và sử dụng các đối số dòng lệnh thay thế. Đầu ra sẽ là một png, cần được dẫn đến một tệp.

Đầu ra

$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

Giả sử tất cả các cài đặt được đặt thành các giá trị mặc định. Chạy chương trình như thế 5:PRGM_POLYGON(cho một hình ngũ giác)

Nó hoạt động bằng cách vẽ một vòng tròn với số bước rất thấp. Ví dụ, một hình ngũ giác sẽ có các bước 2π / 5 radian.

Các cài đặt cửa sổ đủ tốt theo mặc định, TMINvà TMAXđược đặt thành 0và 2π, vì vậy tất cả những gì chúng ta cần thay đổi là TSTEP.

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

Lấy các cạnh và bán kính từ INPUT, tính toán và lưu trữ các điểm, sau đó vẽ chúng bằng cách sử dụng GLINE. Tôi cảm thấy như thế này có thể ngắn hơn nhưng nó giống như 1 giờ sáng, sao cũng được. Giả sử màn hình hiển thị sạch và mặc định env, vì vậy bạn có thể cần phải ACLSchạy nó từ TRỰC TIẾP.

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 ít hơn 25% = 23,25

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

Bài viết đầu tiên ở đây! Tôi biết tôi đến bữa tiệc muộn, nhưng đây có vẻ là một câu hỏi hay như bất kỳ câu hỏi nào để bắt đầu. Gọi bằng cách sử dụng 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 # trong LINQPAD

Tín dụng cho phần toán học được chuyển đến Geobits (Tôi hy vọng bạn không phiền!) Với câu trả lời Java. Tôi vô vọng ở môn toán :)

Tôi đã làm điều này trong LINQPAD vì nó có một cửa sổ đầu ra tích hợp. Vì vậy, về cơ bản, bạn có thể kéo và thả phần sau vào nó và nó sẽ vẽ đa giác. Chỉ cần chuyển nó sang 'Chương trình C #' và nhập lib System.Drawing vào thuộc tính truy vấ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 byte - 25% = 43,5

Saw no Matlab, vì vậy đây là một giải pháp khá đơn giản:

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

Bạn có thể tắt một số byte nếu r và n đã có trong không gian làm việc.

Cuộc gọi ví dụ:

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)

Kiểm tra xem một pixel có ở phía bên trong của tất cả các siêu phẳng (đường thẳng) của đa giác không. Bán kính được chạm vì thực sự apothem được sử dụng.

Toán học 27 (= 36 - 25%)

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

Khi chúng tôi gửi mã Mathicala, chúng tôi thường quên đi các chức năng mới liên tục được tích hợp vào ngôn ngữ, với vốn từ vựng ngôn ngữ hiện tại có khoảng 5000 chức năng cốt lõi . Từ vựng ngôn ngữ lớn và mở rộng là btw khá tiện dụng cho việc chơi gôn. CirclePoints đã được giới thiệu trong phiên bản hiện tại 11.X. Một ví dụ cụ thể về bán kính 7 mặt 5 là:

Ngoài ra, bạn chỉ cần nhập tham số góc để điều khiển hướng đa giác của mình:

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

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

Đầu vào là trong các biến r,n. Nếu được bao gồm trong số đếm, nó sẽ là r,n=input(), cho thêm 12 byte.

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

Dùng thử trực tuyến - (sử dụng mã khác vì execkhông được triển khai trong trình thông dịch trực tuyến)

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

Các biến S và R được sử dụng cho đầu vào.

Giải thích:

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

Các cạnh được vẽ bằng màu -I, thường gần bằng -1 (& HFFFFFFFF màu trắng) (ngoại trừ khi I0, khi nó trong suốt).

Bạn cũng có thể vẽ một đa giác đầy bằng cách sử dụng GTRI N,M,X,Y,R,R,-Ithay vìGLINE...

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}

Giải pháp này sử dụng thư viện tikz shapes.geometric .

Đây là một đa giác với các 5cạnh và bán kính 8intrông như thế nào khi được xem trong evince .