एक नियमित बहुभुज बनाएं

Question

इस कोड गोल्फ का लक्ष्य पक्षों और त्रिज्या (केंद्र से शिखर तक की दूरी) की संख्या को देखते हुए एक नियमित बहुभुज (समान पक्ष लंबाई वाला एक) आकर्षित करना है।

• पक्षों और त्रिज्या की संख्या एक फ़ाइल, एसटीडीआईएन, या सिर्फ एक सादे पुराने चर के माध्यम से दर्ज की जा सकती है। अपनी भाषा में जो कुछ भी है उसका उपयोग करें।
• कुल अक्षर / बाइट्स का -25% अगर छवि वास्तव में ASCII कला के बजाय खींची गई है।

Comments

बहुभुज की त्रिज्या क्या है? इसके वृत्त की त्रिज्या? इसका प्रकोप?

— पीटर टेलर

क्या आप वहां मौजूद हैं। मैंने ठीक कर दिया। इस बारे में क्षमा करें: पी।

— ताकोनुत

@PeterTaylor एक नियमित बहुभुज की त्रिज्या किसी भी शीर्ष (त्रिज्या आउटसाइकल या परिधि ) की दूरी है । सर्किल के त्रिज्या (या पक्षों की दूरी) को एपोटेम कहा जाता है । यह "स्पष्ट नहीं होना चाहिए कि आप क्या पूछ रहे हैं", क्योंकि इसमें आसानी से मिली परिभाषा है (# 1 परिणाम "बहुभुज के त्रिज्या के लिए" Google पर)।

— ज्योबिट्स

@Geobits मैं सहमत हूँ, लेकिन मैंने फिर भी इसे वैसे भी संपादित किया।

— टैकोनट

@PeterTaylor मैं इसे दोनों के रूप में टैग करूँगा: I

— टैकोनट

Answer 1

लोगो 37 - 25% = 27.75 (चरों के साथ)

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

लोगो 49 - 25% = 36.75 (फ़ंक्शन के रूप में)

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

त्रिभुज

चरों के साथ बुलाया

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

एक समारोह के रूप में इस्तेमाल किया P 100 3

वर्ग

चरों के साथ बुलाया

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

एक समारोह के रूप में इस्तेमाल किया P 100 4

पंचकोण

चरों के साथ बुलाया

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

एक समारोह के रूप में इस्तेमाल किया P 100 5

दसभुज

चरों के साथ बुलाया

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

एक समारोह के रूप में इस्तेमाल किया P 100 10

वृत्त

चरों के साथ बुलाया

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

एक समारोह के रूप में इस्तेमाल किया P 100 360

Comments

क्या आप स्क्रीनशॉट पोस्ट कर सकते हैं?

— गाबे

मेरी नज़र में बहुभुज का एक ही पक्ष है, त्रिज्या नहीं।

— रॉस मिलिकान

@RossMillikan: छवियाँ पैमाने पर नहीं थीं। मैंने बस छवियों को अद्यतन किया

— अभिजीत

Answer 2

गणितज्ञ, ४० - २५% = ३०

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

Comments

महान। मैंने जो कोशिश की, उसे हरा दिया Graphics।

— डेविड १

कोई निष्पक्ष नहीं! बहुत आसान!

— रोबी विंस्ज़

अच्छी तरह से किया, यह मेरे लिए कभी नहीं होता।

— माइकल स्टर्न

है Graphics@RegularPolygonकी अनुमति नहीं दी?

— ग्रेग मार्टिन

@GregMartin इसकी अनुमति है, लेकिन इसके साथ त्रिज्या निर्दिष्ट करना बहुत कठिन है।

— केवल

Answer 3

जावा 8: 533 322 - 25% = 241.5

खैर, यह जावा है: / बस रेखाएँ खींचता है, बिंदु को इंगित करता है। किसी भी मनमाने ढंग से बहुभुज के लिए काम करना चाहिए। इसे मूल आकार से काफी कम काटें। गोल्फ सबक के लिए वल्कन (टिप्पणियों में) को बड़ा श्रेय।

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

कतार टूट जाती है:

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

इनपुट तर्क है [त्रिज्या] [पक्ष]:

java D 300 7

आउटपुट:

Comments

के java.awt.image.*बजाय आयात से 12 बाइट्स को हटा देंjava.awt.image.BufferedImage

— FThompson

मैंने कुछ ट्रिक्स का उपयोग करके इसे 500 बाइट्स तक घटा दिया है । 1) चार बाइट्स को बचाने के Short.valueOfबजाय उपयोग करें Integer.valueOf, क्योंकि इनपुट को कभी भी शॉर्ट्स की सीमा से अधिक नहीं होना चाहिए। 2) y[]=x.clone()एक बाइट को बचाता है y[]=new int[s]। 3) एक अतिरिक्त नौ बाइट्स को बचाने के f.show();बजाय पदावनत का उपयोग करें f.setVisible(1>0);। 4) के 6.28बजाय का उपयोग करें Math.PI*2, क्योंकि अनुमान इस उद्देश्य के लिए पर्याप्त है, तीन बाइट्स की बचत। 5) दो बाइट को बचाने के लिए ग्राफिक्स इंस्टेंस बनाते समय Graphics gइसके बजाय डिक्लेयर करें Graphics2D g।

— एफटीएचम्पसन

@ वल्कन मैं इसे एक और 120 (मुख्य रूप से BufferedImageऔर Graphicsपूरी तरह से सबकुछ फेंककर paint()) नीचे गिरा दिया । इसने छवि का रंग बदल दिया, हालांकि यह अभी भी अच्छा IMO दिखता है। मुझे इस पर एक और नज़र डालने के लिए धन्यवाद :)

— Geobits

@Geobits महान सुधार। आपके कम किए गए संस्करण से कार्य करना, मैंने स्थानीय चर के रूप में, पूर्णांक को हटाकर और कुछ वर्णों को बचाने के लिए फॉर-लूप का उपयोग / दुरुपयोग करके इसे 349 बाइट्स तक घटा दिया है , मुख्य रूप से अर्धविराम। यहाँ व्हॉट्सएप के साथ एक संस्करण भी है। Framed

— FThompson

केdrawPolygon बजाय का उपयोग करके 325 बाइट्स में कमीdrawLine । व्हॉट्सएप का वर्जन ।

— FThompson

Answer 4

TeX / TikZ (60 - 80.25)

फ़ाइल polygon.tex:

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

(80 बाइट्स)

पक्षों की त्रिज्या और संख्या को चर / मैक्रोज़ \rऔर के रूप में प्रदान किया जाता है \n। त्रिज्या के लिए कोई भी TeX यूनिट दी जा सकती है। इकाई के बिना, डिफ़ॉल्ट इकाई cmका उपयोग किया जाता है। उदाहरण:

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

(मूल्यों के बिना 16 बाइट्स)

यदि पृष्ठ संख्या को दबाया जाना चाहिए, तो यह द्वारा किया जा सकता है

\footline{}

(11 बाइट्स)

पीडीएफ फाइल बनाने के उदाहरण:

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"

स्कोर:

यह स्पष्ट नहीं है कि, गिनती की आवश्यकता क्या है। स्कोर के लिए सीमा होगी:

• आधार कोड 80 बाइट माइनस 25% = 60 है

• या सभी समावेशी (इनपुट चर परिभाषाएँ, कोई पृष्ठ संख्या नहीं): (80 + 16 + 11) शून्य से 25% = 80.25

• यदि पहले और अंतिम बिंदु के बीच के संबंध को सुचारू करने की आवश्यकता नहीं है, तो --cycle7 बाइट्स को बचाते हुए हटाया जा सकता है।

Answer 5

जोगेब्रा , 42 - 25% = 31.5 बाइट्स

यदि आप बाइट्स के बजाय वर्णों में गणना करते हैं, तो यह 41 - 25% = 30.75 वर्ण होगा।

(यह है, अगर आप जियोगेब्रा को एक भाषा मानते हैं ...)

मान लेता है कि त्रिज्या को चर rमें संग्रहीत किया जाता है और चर में संग्रहीत पक्षों की संख्या s।

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

यह दिए गए त्रिज्या से पक्ष की लंबाई की गणना करने के लिए कोसाइन प्रमेय c ² = a ² + b ² - 2 ab cos C का उपयोग करता है।

नमूना आउटपुट s= 7, r= 5 के लिए

Answer 6

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 अंतःवृत्त की त्रिज्या है)

कृपया ANSI टर्मिनल में चलाएं

संपादित करें:

• इक्का का सुझाव ले लो
• इनपुट के रूप में पुराने चर (या #define) का उपयोग करें
• अब खतना त्रिज्या का उपयोग करें

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

संकलन:

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

Comments

जब आप gcc का उपयोग करते हैं तो आप वास्तव में #includes को छोड़ सकते हैं । इसके अलावा, आप vबाहर के रूप में वैश्विक घोषित कर सकते हैं main, और के uपैरामीटर के रूप में घोषित कर सकते हैं main, तो आपको int(यानी v;main(u){//...) की आवश्यकता नहीं है । अंत में, आप अंतिम forलूप को बदल सकते हैंfor(j=0;j<s;)/*...*/x=j++-s/2.,//...

— user12205

Answer 7

C, 359 Chars

गोल्फ में मेरा पहला प्रयास। कम से कम यह जावा समाधान धड़कता है ;-)

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

और यह एकमात्र ऐसा कार्यक्रम है जो ASCII में बहुभुज को ड्राइंग के बजाय आउटपुट करता है। इसके कारण और कुछ फ़्लोटिंग पॉइंट राउंडिंग समस्याएँ हैं, आउटपुट विशेष रूप से सुंदर नहीं दिखता है (ASCII चार्ट उतने विस्तृत नहीं हैं)।

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

Comments

पहले intहटाया जा सकता है क्योंकि वे intसंकलक द्वारा मान लिए जाते हैं । इसके अलावा, अंतिम forलूप को बदल दिया जा सकता हैfor(j=0;j<r;){x=p+u*j;y=q+z*j++;//...

— user12205

if(i<0)करने के लिए बदला जा सकता है if(i)। जो अभी भी केवल एक पुनरावृत्ति में आवश्यक है, लेकिन इसे बाहर निकालने के लिए एक कुशल तरीका नहीं मिल सका :(

— Allbeert

Answer 8

गणितज्ञ, ५४ * =५% = ४०.५

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

मुझे नहीं लगता कि एक अनऑर्गोलेटेड संस्करण के लिए कोई बिंदु है। इसमें केवल अधिक व्हाट्सएप शामिल होगा।

चर में त्रिज्या और चर rमें पक्षों की संख्या की अपेक्षा करता है n। अक्षों को प्रदर्शित किए बिना त्रिज्या थोड़ा अर्थहीन है, क्योंकि गणितज्ञ सभी छवियों को फिट करने के लिए तराजू करता है।

उदाहरण का उपयोग:

Comments

Graphics@Polygon@Array[r{Sin@#,Cos@#}&,n+1,{0,2π}]

— च्यानोग

@ अच्यांग आह, मैं भूल जाता हूं Array ।

— मार्टिन एंडर

Answer 9

HTML / जावास्क्रिप्ट: 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 संस्करण:

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

Comments

द्वारा 4 वर्ण सहेजें i=S=5;और for(;i-->0;)।

— मैट

@Matt धन्यवाद! मैं इस वाक्यविन्यास को नहीं जानता था, और इसके बारे में कोई जानकारी नहीं पा सकता। इसे क्या कह कर पुकारते हैं ?

— sebcap26

@ sebcap26 क्या आपका मतलब i-->0भाग है? यह वैसा ही है i-- > 0। कुछ लोग इसे एरो ऑपरेटर भी कहते हैं या ऑपरेटर को जाता है ;)

— कॉमफ्रीक

कोई चिंता नहीं :) जैसा कि @ sebcap26 ने कहा, यह लूप की स्थिति का मूल्यांकन करने के लिए हर बार घट रहा है।

— मैट

मुझे लगता है कि आप को दूर करने वर्ण को बचा सकता है c=document.currentScript.parentNode;और जगह <canvas>से<canvas id="c">

— Hedi

Answer 10

पोस्टस्क्रिप्ट 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

कमांड लाइन पर त्रिज्या, पक्षों की संख्या और केंद्र बिंदु पास करें

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

या स्रोत के लिए प्रस्तुत करना

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

केंद्र में अनुवाद करें, त्रिज्या तक स्केल करें, (1,0) पर जाएं; फिर n बार दोहराएं: 360 / n से घुमाएं, लाइन को (1,0) तक खींचें; अंतिम पंक्ति, स्ट्रोक ड्रा करें और पृष्ठ का उत्सर्जन करें।

Answer 11

ऋषि , 44 - 25% = 33

मान लेता है कि पक्षों की संख्या sचर में संग्रहीत है और त्रिज्या rचर में संग्रहीत है ।

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

नमूना उत्पादन:

s= 5, r= 3

s= 5, r= 6

s= 12, r= 5

Comments

कुल्हाड़ियों की स्केलिंग भ्रामक है। क्या यह ठीक है? (उदा। प्रथम बिंदु पर (0,3) जब त्रिज्या = 3, (0,1) के बजाय)

— डिजिटल ट्रॉमा

@DigitalTrauma मेरा कार्यक्रम मूल रूप से "मानक" नियमित बहुभुज बनाता है, फिर छवि को स्केल कारक से बढ़ाता है। जहाँ तक मुझे पता है कि regular_polygonफंक्शन हमेशा पहले वर्टेक्स (0,1) के साथ बहुभुज बनाता है। एक फिक्स 7 अतिरिक्त बाइट्स ( ,axes=0बाद में figsize=r) के साथ कुल्हाड़ियों को नहीं दिखाना होगा

— user12205

Answer 12

bc + ImageMagick + xview + bash, 104.25 (139 बाइट्स - 25%)

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

उदाहरण के लिए, ./polygon.sh 8 100इस छवि का निर्माण करता है:

Answer 13

जावास्क्रिप्ट 584 (867 अपुष्ट)

यह कोड एकता के एन कॉम्प्लेक्स रूट्स का उपयोग करता है और कोणों को एक्स, वाई बिंदुओं में अनुवाद करता है। फिर मूल को कैनवास के केंद्र में ले जाया जाता है।

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

नमूना उत्पादन:

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

इस कोड के लिए HTML5 कैनवास तत्व की आवश्यकता होती है, c कैनवस ऑब्जेक्ट है, आर त्रिज्या है और n # पक्षों का है।

Answer 14

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

दो पूर्वनिर्धारित चर मानते हैं: $pअंकों की संख्या, और $rपिक्सेल में त्रिज्या। वैकल्पिक रूप से, कोई list(,$r,$p)=$argv;इसके बजाय कमांड लाइन तर्क प्रस्तुत कर सकता है और उसका उपयोग कर सकता है । आउटपुट एक पीएनजी होगा, जिसे एक फ़ाइल में पाइप किया जाना चाहिए।

---

उत्पादन

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

Answer 15

TI-80 BASIC, 25 बाइट्स - 25% = 18.75

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

मान लें कि सभी सेटिंग्स डिफ़ॉल्ट मानों पर सेट हैं। प्रोग्राम को चलाएं जैसे 5:PRGM_POLYGON(एक पंचकोण के लिए)

यह बहुत ही कम चरणों के साथ एक वृत्त खींचकर काम करता है। उदाहरण के लिए, एक पंचकोण में 2 5/5 रेडियन के चरण होंगे।

विंडो सेटिंग्स डिफ़ॉल्ट रूप से काफी अच्छी होती हैं, TMINऔर TMAXइन पर सेट होती हैं 0और 2πइसलिए हमें बदलने की जरूरत है TSTEP।

Answer 16

SmileBASIC 3, 183 159 - 25% = 119.25 बाइट्स

पक्षों और त्रिज्या से लेता है INPUT, अंक की गणना करता है और संग्रहीत करता है, और फिर उपयोग करके उन्हें खींचता है GLINE। मुझे लगता है कि यह छोटा हो सकता है लेकिन यह 1 बजे जैसा है, जो भी हो। एक साफ और डिफ़ॉल्ट डिस्प्ले एनवी मानता है, इसलिए आपको ACLSइसे 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

Comments

एक बाइट एक बाइट है, आप यह नहीं कह सकते कि यह केवल एक आधा है।

— 12M2121

25% नियम घटाना।

— मैथ्यू रो

Answer 17

OpenSCAD: 31 कम 25% = 23.25

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

पहली पोस्ट यहाँ! मुझे पता है कि मुझे पार्टी में देर हो रही है, लेकिन यह उतना अच्छा लग रहा था जितना किसी के साथ शुरू करना। का उपयोग कर कॉल करें p(n,r)।

Comments

साइट पर आपका स्वागत है!

— गेहूं जादूगर

Answer 18

एक्शनस्क्रिप्ट 1, फ्लैश प्लेयर 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)

Answer 19

LINQPAD में C #

गणित के भाग का श्रेय जोबिट्स को जाता है (मुझे आशा है कि आप बुरा नहीं मानते!) जावा उत्तर के साथ। मैं गणित में निराश हूँ :)

मैंने LINQPAD में ऐसा किया है क्योंकि इसे एक आउटपुट विंडो बनाया गया है। तो अनिवार्य रूप से आप इसमें निम्नलिखित को ड्रैग और ड्रॉप कर सकते हैं और यह बहुभुज खींचेगा। बस इसे 'C # प्रोग्राम' पर स्विच करें, और क्वेरी गुणों में System.Drawing lib को आयात करें।

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

Answer 20

मतलाब 58 बाइट्स - 25% = 43.5

कोई मतलूब समाधान नहीं देखा, तो यहाँ एक है जो बहुत सीधा है:

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

यदि कार्यक्षेत्र में पहले से ही r और n मौजूद हैं, तो आप कुछ बाइट्स शेव कर सकते हैं।

उदाहरण कॉल:

f(7,8)

Answer 21

पायथन 2, 222 बाइट्स

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)

चेक करता है कि क्या कोई पिक्सेल बहुभुज के सभी हाइपरप्लेन (लाइनों) के अंदरूनी तरफ है। त्रिज्या को छुआ है क्योंकि वास्तव में एपोटेम का उपयोग किया जाता है।

Answer 22

गणितज्ञ 27 (= 36 - 25%)

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

जब हम मैथेमेटिका कोड सबमिट करते हैं तो हम अक्सर नए कार्यों के बारे में भूल जाते हैं जो भाषा में निर्मित होते रहते हैं, वर्तमान भाषा शब्दावली में लगभग 5000 मिलियन फ़ंक्शन होते हैं । बड़ी और विस्तारित भाषा शब्दावली कोड-गोल्फिंग के लिए काफी उपयोगी है। वर्तमान संस्करण 11.X में CirclePoints पेश किए गए थे। 7-पक्षीय त्रिज्या 5 का एक विशिष्ट उदाहरण है:

इसके अलावा, आपको अपने बहुभुज के अभिविन्यास को नियंत्रित करने के लिए बस कोण पैरामीटर दर्ज करने की आवश्यकता है:

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

Answer 23

पायथन 2, 74 बाइट्स - 25% = 55.5

चर में इनपुट है r,n। यदि गिनती में शामिल किया जाता है, तो यह r,n=input()12 बाइट्स के लिए अधिक होगा।

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

इसे ऑनलाइन आज़माएं - ( execऑनलाइन इंटरप्रेटर में लागू नहीं होने के बाद से अलग कोड का उपयोग करता है)

Answer 24

SmileBASIC, 85 75 - 25% = 56.25 बाइट्स

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

चर एस और आर इनपुट के लिए उपयोग किए जाते हैं।

व्याख्या की:

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

पक्षों को रंग का उपयोग करके तैयार -Iकिया जाता है, जो आमतौर पर -1 (और HFFFFFFFFFF सफेद) के करीब होता Iहै (जब 0, जब पारदर्शी होता है) को छोड़कर ।

आप GTRI N,M,X,Y,R,R,-Iइसके बजाय का उपयोग करके एक भरा बहुभुज आकर्षित कर सकते हैंGLINE...

Answer 25

टिक्ज़, 199 बाइट्स

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

यह समाधान tikz लाइब्रेरी का उपयोग करता है shapes.geometric।

यहाँ है क्या के साथ एक बहुभुज 5पक्षों और त्रिज्या 8inकी तरह जब में देखी दिखता जताना ।