कैओस गेम खेलें

Question

अराजकता खेल भग्न उत्पन्न करने के लिए एक सरल तरीका है। एक प्रारंभिक बिंदु को देखते हुए, एक लंबाई अनुपात r और 2 डी बिंदुओं का एक सेट, बार-बार निम्न कार्य करें:

• अपने अंकों के सेट से, यादृच्छिक (समान रूप से) पर एक चुनें।
• उस बिंदु और अंतिम खींचे गए बिंदु (या प्रारंभिक बिंदु) का उपयोग r और 1 - r को वज़न के रूप में करते हैं (यानी r = 0 का अर्थ है कि आपको प्रारंभिक बिंदु मिलता है, r = 1 का अर्थ है कि आपको यादृच्छिक बिंदु मिलता है और r = 0.5 का अर्थ है आप बीच में आधा बिंदु प्राप्त करें।)
• परिणामी बिंदु ड्रा करें।

उदाहरण के लिए, यदि आपने एक समबाहु त्रिभुज और r = 0.5 के शीर्षों को उठाया है , तो प्लॉट किए गए बिंदु एक Sierpinski त्रिभुज को मैप करेंगे:

^{छवि विकिपीडिया पर मिली}

आप एक प्रोग्राम या फ़ंक्शन लिखने के लिए हैं जो भग्न बनाने के लिए अराजकता का खेल "खेलता है"।

इनपुट

आप या तो एक कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, और ARGV, STDIN या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं:

• प्लॉट करने के लिए अंकों की संख्या।
• प्रारंभिक समन्वय (जिसे प्लॉट किया जाना है, भी!)।
• अंतराल में औसत वजन आर [0,1] ।
• से चुनने के लिए अंकों की एक सूची।

उत्पादन

आप स्क्रीन पर प्रस्तुत कर सकते हैं या एक छवि फ़ाइल लिख सकते हैं। यदि परिणाम को रेखापुंज किया जाता है, तो इसे प्रत्येक तरफ कम से कम 600 पिक्सेल की आवश्यकता होती है, सभी बिंदु कैनवास पर होने चाहिए, और छवि के क्षैतिज और ऊर्ध्वाधर सीमा का कम से कम 75% बिंदुओं के लिए उपयोग किया जाना चाहिए (इससे बचने के लिए) "यह वास्तव में बहुत दूर ज़ूम आउट किया गया है" कहकर एक काले पिक्सेल के साथ उत्तर देता है। एक्स और वाई अक्ष एक ही पैमाने पर होना चाहिए (कि करने के लिए 0,0 से (लाइन) है (1,1) एक 45 डिग्री के कोण पर होना चाहिए) और प्रत्येक बिंदु अराजकता खेल में साजिश रची एक एकल के रूप में प्रतिनिधित्व किया जाना चाहिए पिक्सेल (यदि आपका प्लॉटिंग विधि एंटी-एलियास बिंदु है, तो यह 2x2 पिक्सेल पर फैल सकता है)।

रंग आपकी पसंद हैं, लेकिन आपको कम से कम दो अलग-अलग रंगों की आवश्यकता है: एक पृष्ठभूमि के लिए और एक चेस गेम के दौरान प्लॉट किए गए डॉट्स के लिए। आपको इनपुट बिंदुओं को प्लॉट करना पड़ सकता है।

कृपया अपने उत्तर में तीन दिलचस्प उदाहरण आउटपुट शामिल करें ।

स्कोरिंग

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

संपादित करें: अब आपको इनपुट बिंदुओं को प्लॉट करने की आवश्यकता नहीं है, क्योंकि वे वास्तव में वैसे भी सिंगल पिक्सेल के रूप में दिखाई नहीं देते हैं।

Comments

" प्रत्येक बिंदु पर प्लॉट किए गए ... को एकल पिक्सेल के रूप में दर्शाया जाना चाहिए " क्या मतलब है? क्या यह क) कोई एंटी-अलियासिंग का उपयोग नहीं किया जाना चाहिए; या बी) कि दूसरे रंग में बिंदुओं की संख्या इनपुट से पहले आइटम के बराबर होनी चाहिए? ध्यान दें कि बी) गारंटी देना असंभव है जब तक कि पुनरावृत्ति प्रक्रिया के लिए एक परीक्षण नहीं होता है "क्या यह पिक्सेल पहले से प्लॉट किए गए एक के साथ मेल खाता है?", क्योंकि अगर यादृच्छिक संख्या चयनकर्ता एक ही बिंदु पर एक पंक्ति में पर्याप्त समय का चयन करता है, तो स्थिति में परिवर्तित हो जाएगी। वह बात।

— पीटर टेलर

@PeterTaylor उद्देश्य के रूप में बड़े डॉट्स की साजिश रचने वाले लोगों से बचने का इरादा था (जैसे कि गणितज्ञ डिफ़ॉल्ट रूप से करता है), लेकिन मैंने पहले ही ध्यान दिया है कि एंटी-अलियासिंग सोहम के जवाब में एकल पिक्सल सुनिश्चित करने के साथ कुछ परेशानी का कारण बनता है। मुझे लगता है कि मैं इसे "2x2 पिक्सेल से बड़ा नहीं होना चाहिए" के लिए आराम करूंगा, जिसे सभी एंटी-अलियासिंग समस्या को कवर करना चाहिए।

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

मुझे लगता है कि मैंने कुछ गलत समझा है: आप हमेशा अंतिम बिंदु के 'मतलब' को लेते हैं जो आपने साजिश रची है और वर्तमान सूची का एक यादृच्छिक बिंदु है। फिर आप सूची में उस नए बिंदु को जोड़ते हैं। क्या वो सही है? ऐसा लगता है कि यदि आपके पास एक 'कोने' में कई बिंदु हैं, तो आपको कई और मिलेंगे, लेकिन उस बादल से बाहर निकलने की संभावना नहीं है - कम से कम मेरा कोड हमेशा 'बहुत तेजी से' उन बिंदुओं तक पहुंचता है जो एक दूसरे के बहुत करीब हैं वास्तव में तस्वीर बढ़ाएँ।

— दोष

@flawr नहीं, आप सूची में नया बिंदु नहीं जोड़ेंगे। सूची तय हो गई है - एल्गोरिथ्म केवल अंतिम बिंदु के बारे में परवाह करता है जिसे प्लॉट किया गया था, न कि इससे पहले वाले।

— नथानिएल

धन्यवाद, जो बहुत कुछ समझाता है, शायद प्रश्न में स्पष्ट किया जाना चाहिए।

— दोष

Answer 1

मैथमेटिका, 89

f[n_,s_,r_,p_]:=Graphics@{AbsolutePointSize@1,Point@NestList[#-r#+r RandomChoice@p&,s,n]}

f[10000, {0, 0}, .5, {{-(1/2), Sqrt[3]/2}, {-(1/2), -(Sqrt[3]/2)}, {1, 0}}]

यह काम किस प्रकार करता है

Mathematica में Graphics[]फ़ंक्शन स्केलेबल ग्राफिक्स का उत्पादन करता है, आप इसे केवल चित्र कोनों को खींचकर जो भी आकार चाहते हैं, उसे प्रस्तुत करते हैं। वास्तव में, सभी प्रदर्शित ग्राफिक्स का प्रारंभिक आकार एक ".ini" सेटिंग है जिसे आप 600 या किसी अन्य मूल्य पर सेट कर सकते हैं जिसे आप चाहते हैं। तो 600x600 आवश्यकता के लिए कुछ विशेष करने की आवश्यकता नहीं है।

यह AbsolutePointSize[]बात निर्दिष्ट करती है कि छवि का आकार बढ़ाकर बिंदु आकार को संशोधित नहीं किया जाएगा।

कोर निर्माण है

 NestList[#-r#+r RandomChoice@p&,s,n]

या गैर-गोल्फ वाले छद्म कोड में:

 NestList[(previous point)*(1-r) + (random vertex point)*(r), (start point), (iterations)]

यह (start point)प्रत्येक क्रमिक बिंदु पर पहले तर्क में (वेक्टरियल) फ़ंक्शन को शुरू करने और लागू करने से पहले एक सूची का निर्माण कर रहा है, अंत में प्लॉट किए जाने वाले सभी गणना बिंदुओं की सूची को वापस कर रहा है।Point[]

कुछ स्व-प्रतिकृति उदाहरण:

Grid@Partition[Table[
   pts = N@{Re@#, Im@#} & /@ Table[E^(2 I Pi r/n), {r, 0, n - 1}];
   Framed@f[10000, {0, 0}, 1/n^(1/n), pts], {n, 3, 11}], 3]

Comments

@ MartinBüttner Instructions for testing this answer without Mathematica installed:1) इसे पास्टबिन से डाउनलोड करें और इसे * .CDF 2 के रूप में सेव करें) (एक छोटी फ़ाइल नहीं ) पर वुल्फराम रिसर्च से मुफ्त सीडीएफ वातावरण डाउनलोड और इंस्टॉल करें । का आनंद लें। मुझे बताओ अगर यह काम करता है!

— डॉ। बिसरिसेर

आपका गोल्फ संस्करण काफी काम नहीं करता है (कम से कम V10 पर): आपको जगह के बीच या बीच में दूर #rजाने के r#लिए चारों ओर स्विच करने की आवश्यकता है *।

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

@ मार्टिनबरनर उत्सुक! यह v9 पर एक आकर्षण की तरह काम करता है (मेरे पास अभी तक v10 नहीं है)। वैसे भी, मैंने (आँख बंद करके) #और अदला-बदली की r।

— डॉ। बिसरिसेर

आह, यह एक नई सुविधा है। अब आप फ़ंक्शंस के लिए फ़ंक्शंस लागू कर सकते हैं, जिस स्थिति में आपको नामित पैरामीटर मिलते हैं जिन्हें एक्सेस किया जा सकता है #key। मुझे यकीन है कि काम आएगा। :)

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

Answer 2

जावा: २४६ २५३ ४४।

एक समारोह के रूप में m():

void m(float[]a){new java.awt.Frame(){public void paint(java.awt.Graphics g){int i=0,x=i,y=i,v;for(setSize(832,864),x+=a[1],y+=a[2];i++<=a[0];v=a.length/2-2,v*=Math.random(),x+=(a[v+=v+4]-x)*a[3],y+=(a[v+1]-y)*a[3])g.drawLine(x,y,x,y);}}.show();}

लाइन ब्रेक (उपयोग दिखाने के लिए एक कार्यक्रम के भीतर):

class P{
    public static void main(String[]a){
        new P().m(new float[]{1000000,            // iterations
                              416,432,            // start
                              0.6f,               // r
                              416,32,16,432,      // point list...
                              416,832,816,432,
                              366,382,366,482,
                              466,382,466,482});
    }

    void m(float[]a){
        new java.awt.Frame(){
            public void paint(java.awt.Graphics g){
                int i=0,x=i,y=i,v;
                for(setSize(832,864),x+=a[1],y+=a[2];
                    i++<=a[0];
                    v=a.length/2-2,v*=Math.random(),
                    x+=(a[v+=v+4]-x)*a[3],
                    y+=(a[v+1]-y)*a[3])
                    g.drawLine(x,y,x,y);
            }
        }.show();
    }
}

आरेखण इनपुट बिंदुओं को आवश्यकताओं से हटा दिया गया था (yay 80 बाइट्स!)। वे अभी भी नीचे दिए गए पुराने स्क्रीनशॉट में दिखाए गए हैं, लेकिन यदि आप इसे चलाते हैं तो वे दिखाई नहीं देंगे। रुचि होने पर संशोधन इतिहास देखें।

फ्लोट की एक सरणी के रूप में इनपुट दिए गए हैं। पहला पुनरावृत्तियों है, अगले दो शुरू हो रहे हैं x y। चौथा है r, और आखिरी बार x1 y1 x2 y2 ...फैशन में निर्देशांक की सूची आती है ।

निंजा स्टार

1000000 400 400 0.6 400 0 0 400 400 800 800 400 350 350 350 450 450 350 450 450

पार करना

1000000 400 400 0.8 300 0 500 0 500 300 800 300 800 500 500 500 500 800 300 800 300 500 0 500 0 300 300 300

Octochains

1000000 400 400 0.75 200 0 600 0 800 200 800 600 600 800 200 800 0 600 0 200

Comments

यह मेरे कंप्यूटर में काम नहीं करता है, और जावा शिकायतें showपदावनत की जाती हैं

— गर्व हैकेलर

@proudhaskeller show() को पदावनत कर दिया गया है, लेकिन यह अभी भी काम करता है। जब आप कहते हैं कि "काम नहीं करता है", तो इसका क्या मतलब है? आप जावा 8 की जरूरत नहीं है, तो आप एक जोड़ने की आवश्यकता होगी finalकरने के लिए String[]aकम से कम मुख्य में।

— 16

प्रसंस्करण के लिए अपना उत्तर दिया और 100 वर्ण काट दिए।

— user12205

@ पेस अच्छा लगा। आप चित्रमय आउटपुट के लिए बहुत अधिक जावा गोल्फ के साथ ऐसा कर सकते हैं, लेकिन मुझे यह पसंद है कि यह बिल्कुल 100 वर्ण है: डी

— जियोबिट्स

Answer 3

जावास्क्रिप्ट (ई 6) + एचटीएमएल 173 176 193

संपादित करें: बड़ा कटौती, विलियम बारबोसा के लिए धन्यवाद

संपादित करें: 3 बाइट्स कम, डॉक्समैक्स के लिए धन्यवाद

173 बाइट्स फ़ंक्शन को गिनते हैं और आउटपुट दिखाने के लिए आवश्यक कैनवास तत्व।

टेस्ट html फ़ाइल और फ़ायर्फ़ॉक्स में खुले रूप में सहेजें।

JSFiddle

---

---

---

---

<canvas id=C>
<script>
F=(n,x,y,r,p)=>{
  for(t=C.getContext("2d"),C.width=C.height=600;n--;x-=(x-p[i])*r,y-=(y-p[i+1])*r)
    i=Math.random(t.fillRect(x,y,1,1))*p.length&~1      
}
F(100000, 300, 300, 0.66, [100,500, 500,100, 500,500, 100,100, 300,150, 150,300, 300,450, 450,300]) // Function call, not counted
</script>

Comments

<canvas id=C><script>F=(n,x,y,r,p)=>{t=C.getContext("2d"),C.width=C.height=600;for(;n--;)t.fillRect(x,y,1,1),i=Math.random()*p.length&~1,x-=(x-p[i])*r,y-=(y-p[i+1])*r}</script>176 बाइट्स लंबी है, मुझे आपकी गिनती समझ में नहीं आई

— विलियम बारबोसा

@WilliamBarbosa मेरी गिनती मेरे उत्तर के आधार पर सही है। आपके संकेत से यह बेहतर हो जाता है - धन्यवाद!

— edc65

अगर आप forकॉल में साइज़ इनिशियलाइज़ेशन और वाई अपडेट को आगे for(C.width=C.height=600;n--;y-=(y-p[i+1])*r)

— बढ़ाते हैं

Answer 4

अजगर - 200 189

import os,random as v
def a(n,s,r,z):
    p=[255]*360000
    for i in[1]*(n+1):
        p[600*s[0]+s[1]]=0;k=v.choice(z);s=[int(k[i]*r+s[i]*(1-r))for i in(0,1)]
    os.write(1,b'P5 600 600 255 '+bytes(p))

फ़ंक्शन तर्कों के रूप में इनपुट लेता है, परिणाम को pgm फ़ाइल के रूप में लिखता है। nपुनरावृत्तियों है, sप्रारंभिक बिंदु है, rआर है, और zइनपुट बिंदुओं की सूची है।

संपादित करें: अब ग्रे में इनपुट बिंदु नहीं बनाते हैं।

दिलचस्प आउटपुट:

Iterations: 100000
Starting Point: (200, 200)
r: 0.8
Points: [(0, 0), (0, 599), (599, 0), (599, 599), (300, 300)]

---

Iterations: 100000
Starting Point: (100, 300)
r: 0.6
Points: [(0, 0), (0, 599), (599, 0), (300, 0), (300, 300), (0, 300)]

---

Iterations: 100000
Starting Point: (450, 599)
r: 0.75
Points: [(0, 0), (0, 300), (0, 599), (300, 0), (599, 300), (150, 450)]

Comments

कुछ सामान्य पायथन चरित्र बचाता है: प्रारंभिक मान जैसे p=[255]*360000फ़ंक्शन के वैकल्पिक मापदंडों के रूप में जा सकते हैं; एक लूप का शरीर सभी एक ही लाइन पर जा सकता है अगर इसका कोई नियंत्रण प्रवाह नहीं है; आप के [1]*(n+1)रूप में parens से दाढ़ी कर सकते हैं [1]*-~n; चूंकि आप iलूप के लिए बाहरी में उपयोग नहीं करते हैं , यह कोड को nकई बार चलाने के लिए छोटा है exec"code;"*n); मुझे लगता है कि अंदर के पराये को for i in(0,1)हटाया जा सकता है।

— xnor

Answer 5

सुपरकोलाइडर - 106

SuperCollider संगीत बनाने के लिए एक भाषा है, लेकिन यह चुटकी में ग्राफिक्स कर सकता है।

f={|n,p,r,l|Window().front.drawHook_({{Pen.addRect(Rect(x(p=l.choose*(1-r)+(p*r)),p.y,1,1))}!n;Pen.fill})}

मैंने कुछ बाइट्स को बचाने के लिए कुछ अस्पष्ट वाक्यविन्यास शॉर्टकट का उपयोग किया है - एक अधिक पठनीय और अधिक स्मृति-कुशल संस्करण है

f={|n,p,r,l|Window().front.drawHook_({n.do{Pen.addRect(Rect(p.x,p.y,1,1));p=l.choose*(1-r)+(p*r)};Pen.fill})}

109 चार्ट में।

मैथेमेटिका उदाहरण के साथ, आपको 600x600 पिक्सेल प्राप्त करने के लिए विंडो को मैन्युअल रूप से आकार देना होगा। जब आप ऐसा करते हैं तो आपको इसे फिर से खींचने के लिए इंतजार करना होगा।

यह एक मूल Sierpinsky त्रिकोण उत्पन्न करता है (नहीं दिखाया गया है क्योंकि आपने इसे पहले देखा है)

f.(20000,100@100,0.5,[0@600,600@600,300@0])

यह एक प्रकार का सीरपिन्स्की पेंटागन प्रकार बनाता है:

f.(100000,100@100,1-(2/(1+sqrt(5))),{|i| (sin(i*2pi/5)+1*300)@(1-cos(i*2pi/5)*300)}!5)

6 अंक के साथ एक ही बात एक उल्टे कोच बर्फ के टुकड़े को बीच में छोड़ देती है:

f.(100000,100@100,1/3,{|i| (sin(i*2pi/6)+1*300)@(1-cos(i*2pi/6)*300)}!6)

अंत में, यहाँ इक्का के जवाब से 3 डी पिरामिड पर एक दरार है। (ध्यान दें कि मैंने छायांकन प्रभाव प्राप्त करने के लिए दो बिंदुओं में से एक का उपयोग किया है।)

f.(150000,100@100,0.49,[300@180, 0@500,0@500,350@400,600@500,250@600])

Answer 6

अजगर, 189 183 175

संपादित करें: उलटा आर अनुपात तय किया , और कुछ बाइट्स को बचाने के लिए B & W छवि पर स्विच किया।

अंक की संख्या लेता है n, पहले बिंदु के रूप में p, के रूप में अनुपात rऔर के रूप में अंक की सूची l। मॉड्यूल पिलो की जरूरत है।

import random,PIL.Image as I
s=850
def c(n,p,r,l):
    i=I.new('L',(s,s));x,y=p;
    for j in range(n):w,z=random.choice(l);w*=r;z*=r;x,y=x-x*r+w,y-y*r+z;i.load()[x,s-y]=s
    i.show()

उदाहरण:

मैं छवि के केंद्र के चारों ओर चक्र में अंक उत्पन्न कर रहा हूं

points = [(425+s*cos(a)/2, 425+s*sin(a)/2) for a in frange(.0, 2*pi, pi/2)]
c(1000000, (425, 425), 0.4, points)

XOXO दोहराव, केवल अनुपात 0.4 से 0.6 तक बदल रहा है

बर्फ के कुछ प्रकार

stars = [(425+s*cos(a)/2,425+s*sin(a)/2) for a in frange(.0,2*pi, pi/4)]
c(1000000, (425, 425), 0.6, stars)

Comments

डनो बैकवर्ड आर चीज़ को ठीक करने के बारे में , लेकिन आप इस प्रोग्राम का उपयोग करके काफी कुछ अक्षर बचा सकते हैं n,p,r,l=input()। आप *=संचालन और उपयोग से कोष्ठक भी हटा सकते हैं import random as R।

— FryAmTheEggman

@FryAmTheEggman दुर्भाग्य से, मेरे उत्तर को सही करने पर अनुकूलन को अमान्य कर दिया गया है *=:(। inputकाम करने के लिए बहुत ही अप्रिय बात होगी, और वर्तमान में आयात सबसे संक्षिप्त रूप संभव है (या मुझे कुछ याद नहीं है?)

— तेह इंटर्नेट बना है। कैटज

मुझे पूरा यकीन है कि रेखा हो सकती है import random as R,PIL.Image as Iऔर फिर random.choiceहो सकती है R.choice। हाँ, इनपुट का उपयोग करना लंगड़ा है, लेकिन आप परीक्षण संस्करण के लिए फ़ंक्शन का उपयोग कर सकते हैं और input()एक बेहतर स्कोर के लिए पोस्ट कर सकते हैं !! 1! : P

— FryAmTheEggman 15

ओह, मैंने अभी देखा है कि यादृच्छिक को परिभाषित करना वास्तव में 0 वर्णों को बचाता है। उफ़: एस वैसे भी, मुझे यह भी एहसास हुआ कि गणित आपका दोस्त है: y=x*(1-r)+w== y=x-x*r-w।

— FryAmTheEggman

@FryAmTheEggman जो मेरी बात थी: p। लेकिन गणित के लिए धन्यवाद।

— तेह इंटर्नेट 8

Answer 7

जावास्क्रिप्ट (407) (190)

मुझे अपनी स्क्रिप्ट पर और गोल्फिंग पर कोई प्रतिक्रिया मिलने की खुशी है क्योंकि मैं JS =) के साथ सहज नहीं हूं (इसे अपने उपयोग के लिए स्वतंत्र महसूस करें / इसे अपने स्वयं के सबमिशन के लिए बदलें!)

इनपुट पढ़ना ( edc65 की प्रविष्टि के लिए तुलनीय नहीं है, मैं इनपुट की गिनती नहीं करता हूं।)

p=prompt;n=p();[x,y]=p().split(',');r=p();l=p().split(';').map(e=>e.split(','));

कैनवास सेटअप और गणना

d=document;d.body.appendChild(c=d.createElement('canvas'));c.width=c.height=1000;c=c.getContext('2d');
for(;n--;c.fillRect(x,y,2,2),[e,f]= l[Math.random()*l.length|0],x-=x*r-e*r,y-=y*r-f*r);

कुछ हद तक अधिक अनगॉल्ड (उदाहरण इनपुट सहित जहां वास्तविक इनपुट प्रोम केवल टिप्पणी की जाती है, इसलिए उपयोग करने के लिए तैयार है):

p=prompt;
n=p('n','4000');
[x,y]=p('start','1,1').split(',');
r=p('r','0.5');
l=p('list','1,300;300,1;300,600;600,300').split(';').map(e=>e.split(','));d=document;
d.body.appendChild(c=d.createElement('canvas'));
c.width=c.height=1000;c=c.getContext('2d');
for(;n--;c.fillRect(x,y,2,2),[e,f]= l[Math.random()*l.length|0],x-=x*r-e*r,y-=y*r-f*r);

उदाहरण

for(k = 0; k<50; k++){
rad = 10;
l.push([350+rad*k*Math.cos(6.28*k/10),350+rad*k*Math.sin(6.28*k/10)]);
}
r = 1.13;

r = 0.5;list = [[1,1],[300,522],[600,1],[300,177]];

r = 0.5
list = [[350+350*Math.sin(6.28*1/5),350+350*Math.cos(6.28*1/5)],
[350+350*Math.sin(6.28*2/5),350+350*Math.cos(6.28*2/5)],
[350+350*Math.sin(6.28*3/5),350+350*Math.cos(6.28*3/5)],
[350+350*Math.sin(6.28*4/5),350+350*Math.cos(6.28*4/5)],
[350+350*Math.sin(6.28*5/5),350+350*Math.cos(6.28*5/5)],


[350+90*Math.sin(6.28*1.5/5),350+90*Math.cos(6.28*1.5/5)],
[350+90*Math.sin(6.28*2.5/5),350+90*Math.cos(6.28*2.5/5)],
[350+90*Math.sin(6.28*3.5/5),350+90*Math.cos(6.28*3.5/5)],
[350+90*Math.sin(6.28*4.5/5),350+90*Math.cos(6.28*4.5/5)],
[350+90*Math.sin(6.28*5.5/5),350+90*Math.cos(6.28*5.5/5)]];

Comments

आपका क्या मतलब है?

— दोष

ओह मुझे बताने के लिए धन्यवाद, मैं जल्द ही सबमिशन अपडेट करने जा रहा हूँ!

— दोष

आपने मेरा उत्तर लिंक कर दिया है, लेकिन मैं कैनवास के सेटअप की गणना करता हूं। मैं केवल फ़ंक्शन को कॉल करने वाली एकल पंक्ति की गणना नहीं करता हूं। वैसे भी अच्छी तस्वीरें, पहले एक जासूसी।

— edc65

आह मुझे इस बात पर ध्यान नहीं गया कि मैं इसे 'तुलनीय' बनाना चाहता था, लेकिन यह मुश्किल है जब मैं केवल जेएस पर भरोसा करने की कोशिश करता हूं =) @ मार्टिनबटनर अपडेट किया गया, अब मुझे यह समझ में आ गया है कि मैं इसे सही तरीके से समझ पा रहा हूं जिससे मैं बहुत कुछ दूर कर सका हूं। कचरा =)

— दोष

Answer 8

प्रसंस्करण, 153

पोर्ट किए गए @Geobits के जावा ने प्रोसेसिंग का उत्तर दिया और कुछ और गोल्फिंग की, जिसके परिणामस्वरूप 100 चार्ट में कमी आई। मैंने मूल रूप से प्रक्रिया को चेतन करने का इरादा किया था, लेकिन इनपुट बाधाएं इस पर बहुत कठोर हैं (प्रसंस्करण में स्टिंग या argv नहीं है, जिसका अर्थ है कि मुझे प्रसंस्करण के मूल draw()लूप का उपयोग करने के बजाय अपना फ़ंक्शन लिखना होगा )।

void d(float[]a){int v;size(600,600);for(float i=0,x=a[1],y=a[2];i++<a[0];v=(int)random(a.length/2-2),point(x+=(a[v*2+4]-x)*a[3],y+=(a[v*2+5]-y)*a[3]));}

लाइन ब्रेक के साथ पूरा कार्यक्रम:

void setup() {
  d(new float[]{100000,300,300,.7,0,600,600,0,600,600,0,0,400,400,200,200,400,200,200,400}); 
}
void d(float[]a){
  int v;
  size(600,600);
  for(float i=0,x=a[1],y=a[2];
      i++<a[0];
      v=(int)random(a.length/2-2),point(x+=(a[v*2+4]-x)*a[3],y+=(a[v*2+5]-y)*a[3]));
}

उपरोक्त कार्यक्रम क्रॉस देता है:

d(new float[]{100000,300,300,.65,142,257,112,358,256,512,216,36,547,234,180,360}); 

यह पिरामिड देता है:

d(new float[]{100000,100,500,.5,100,300,500,100,500,500});

यह Sierpinski त्रिकोण देता है:

Comments

मुझे पिरामिडों का 3 डी प्रभाव पसंद है। :)

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

Answer 9

Ungolfed "संदर्भ कार्यान्वयन", पायथन

अद्यतन : बहुत, बहुत तेजी से (परिमाण के आदेश द्वारा)

इंटरैक्टिव खोल की जाँच करें!

फ़ाइल को संपादित करें और सेट interactiveकरें True, फिर इनमें से एक करें:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides एक बहुभुज बनाता है, बचाता है और प्रदर्शित करता है।

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... युक्ति क्या पूछती है।

import matplotlib.pyplot as plt
import numpy as np
from fractions import Fraction as F
import random
from matplotlib.colors import ColorConverter
from time import sleep
import math
import sys
import cmd
import time

def plot_saved(n, r, start, points, filetype='png', barsize=30, dpi=100, poly=True, show=False):
    printed_len = 0

    plt.figure(figsize=(6,6))
    plt.axis('off')

    start_time = time.clock()
    f = F.from_float(r).limit_denominator()

    spts = []
    for i in range(len(points)):
        spts.append(tuple([round(points[i].real,1), round(points[i].imag,1)]))

    if poly:
        s = "{}-gon ({}, r = {}|{})".format(len(points), n, f.numerator, f.denominator)
    else:
        s = "{} ({}, r = {}|{})".format(spts, n, f.numerator, f.denominator) 

    step = math.floor(n / 50)

    for i in range(len(points)):
        plt.scatter(points[i].real, points[i].imag, color='#ff2222', s=50, alpha=0.7)

    point = start
    t = time.clock()

    xs = []
    ys = []

    for i in range(n+1):
        elapsed = time.clock() - t
        #Extrapolation
        eta = (n+1-i)*(elapsed/(i+1))
        printed_len = rewrite("{:>29}: {} of {} ({:.3f}%) ETA: {:.3f}s".format(
                s, i, n, i*100/n, eta), printed_len)
        xs.append(point.real)
        ys.append(point.imag)
        point = point * r + random.choice(points) * (1 - r)

    printed_len = rewrite("{:>29}: plotting...".format(s), printed_len)
    plt.scatter(xs, ys, s=0.5, marker=',', alpha=0.3)

    presave = time.clock()
    printed_len = rewrite("{:>29}: saving...".format(s), printed_len)
    plt.savefig(s + "." + filetype, bbox_inches='tight', dpi=dpi)

    postsave = time.clock()
    printed_len = rewrite("{:>29}: done in {:.3f}s (save took {:.3f}s)".format(
                            s, postsave - start_time, postsave - presave),
                            printed_len)

    if show:
        plt.show()
    print()
    plt.clf()

def rewrite(s, prev):
    spaces = prev - len(s)
    sys.stdout.write('\r')
    sys.stdout.write(s + ' '*(0 if spaces < 0 else spaces))
    sys.stdout.flush()
    return len(s)

class InteractiveChaosGame(cmd.Cmd):
    def do_polygon(self, args):
        (n, num, den, sx, sy, deg) = map(int, args.split())
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), list(np.roots([1] + [0]*(deg - 1) + [-1])), show=True)

    def do_points(self, args):
        l = list(map(int, args.split()))
        (n, num, den, sx, sy) = tuple(l[:5])
        l = l[5:]
        points = []
        for i in range(len(l)//2):
            points.append(complex(*tuple([l[2*i], l[2*i + 1]])))
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), points, poly=False, show=True)

    def do_pointsdpi(self, args):
        l = list(map(int, args.split()))
        (dpi, n, num, den, sx, sy) = tuple(l[:6])
        l = l[6:]
        points = []
        for i in range(len(l)//2):
            points.append(complex(*tuple([l[2*i], l[2*i + 1]])))
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), points, poly=False, show=True, dpi=dpi)

    def do_default(self, args):
        do_generate(self, args)

    def do_EOF(self):
        return True

if __name__ == '__main__':
    interactive = False
    if interactive:
        i = InteractiveChaosGame()
        i.prompt = ": "
        i.completekey='tab'
        i.cmdloop()
    else:
        rs = [1/2, 1/3, 2/3, 3/8, 5/8, 5/6, 9/10]
        for i in range(3, 15):
            for r in rs:
                plot_saved(20000, r, np.complex(0,0), 
                            list(np.roots([1] + [0] * (i - 1) + [-1])), 
                            filetype='png', dpi=300)

Comments

इस चलने के बिना, मैं पता नहीं क्या है भयानक साधन। शायद आप समझा सकते हैं, या कुछ चित्रों को दिखा सकते हैं जो इसे छोटे लोगों से अलग बनाता है?

— जॉयबिट्स

@Geobits को अस्वीकरण और चित्र शामिल करने के लिए संपादित किया गया :)

— सोहम चौधरी

मैं पसंद करूंगा यदि आपने इसे एक अन्य शीर्षक के तहत शामिल किया (जैसे अनगुल्ड संदर्भ कार्यान्वयन) आपके अन्य उत्तर में केवल असंगत कोड पोस्ट करने के रूप में तकनीकी रूप से "उत्तर नहीं है"।

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

Answer 10

पायथन (202 वर्ण)

के रूप में अंकों की संख्या ले जाता है n, के रूप में औसत वजन r, एक के रूप में प्रारंभिक बिंदु tuple sऔर XY की एक सूची के रूप में अंक की सूची tupleकहा जाता रों l।

import random as v,matplotlib.pyplot as p
def t(n,r,s,l):
 q=complex;s=q(*s);l=[q(*i)for i in l];p.figure(figsize=(6,6))
 for i in range(n):p.scatter(s.real,s.imag,s=1,marker=',');s=s*r+v.choice(l)*(1-r)
 p.show()

Comments

@ मार्टिनबटनर क्या यह तथ्य है कि मैं एक विशेष प्रकार का इनपुट ले रहा हूं, जो कल्पना से मिलता है?

— सोहम चौधरी

इसके अलावा, मेरी मशीन पर, परिणाम 600x600 पिक्सेल नहीं है, x और y में अलग-अलग लंबाई के पैमाने हैं और अंक 1 पिक्सेल से अधिक हैं।

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