एक स्नोफ्लेक ड्रा करें

Question

जो बहामास में रहता है। सदी का मौसम है। उनके बच्चे निराश हैं कि बर्फ नहीं है। जोई को अपने बच्चों के लिए बर्फ बनाने की जरूरत है। सौभाग्य से, उसके पास 3-डी प्रिंटर है। वह इसके साथ बर्फ के टुकड़े बनाने की योजना बना रहा है। दुर्भाग्य से उसे कोई अंदाजा नहीं है कि बर्फ का टुकड़ा कैसा दिखेगा। वास्तव में, उसने कभी बर्फबारी नहीं देखी है! आइए हम एक ऐसा प्रोग्राम बनाकर उसकी मदद करें जो स्वतः ही उसके लिए स्नोफ्लेक की 2d- छवि उत्पन्न कर देता है।

इनपुट

छवि का व्यास (पिक्सेल में), उस छवि का प्रतिशत जो वास्तव में एक हिमपात का एक खंड है।

उत्पादन

आवश्यक व्यास के साथ एक हिमपात का एक खंड छवि। इसे एक फ़ाइल में सहेजा जा सकता है या उपयोगकर्ता को प्रदर्शित किया जा सकता है।

विशेष विवरण

एक पच्चर बनाएं जिसमें 30 डिग्री का कोण हो। कील के बिंदु पर प्रारंभिक बीज के साथ एक ब्राउनियन ट्री बनाएं । छवि के केंद्र के चारों ओर पच्चर को प्रतिबिंबित करें शेष छवि उत्पन्न करने के लिए 12 बार। स्नोफ्लेक का रंग सफेद है। पृष्ठभूमि का रंग काला है।

स्कोरिंग

इस तथ्य के कारण एक ब्राउनियन ट्री को उत्पन्न करने के विभिन्न तरीके हैं, स्कोर 10 * संख्या है - गोल्फ स्कोर।

गोल्फ स्कोर को निम्न बोनस के साथ कार्यक्रम में बाइट्स की संख्या के रूप में परिभाषित किया गया है:

-20% बर्फ के टुकड़े की समरूपता को मनमाने ढंग से निर्दिष्ट कर सकते हैं।

-50% बर्फ के टुकड़े का आकार निर्दिष्ट कर सकता है। (वेज के पक्षों की लंबाई के अनुपात को निर्दिष्ट करने में सक्षम होने से।)

उच्चतम स्कोर जीतता है।

यहाँ एक तस्वीर है कि पच्चर का आकार लगभग 2 अनुपात के साथ क्या होगा:

स्कोरबोर्ड:

मार्टिन बटनर: 10 * 14 - 409 = -269

निमि: 10 * 1 - 733 * .5 = -356.5

ऑप्टिमाइज़र: 10 * 5 - 648 = -598

विजेता -269 स्कोर वाला मार्टिन है!

Comments

संबंधित

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

मुझे समझ नहीं आ रहा है, अगर हम कथित तौर पर किसी ऐसे व्यक्ति की मदद कर रहे हैं जिसने कभी बर्फबारी नहीं देखी है, तो वे जानते हैं कि वे क्या दिखते हैं, हम उन्हें आदेश के घूर्णी समरूपता बनाने वाले हैं। क्या हम गरीब आदमी को ट्रोल करने वाले हैं?

— पीटर टेलर

@ कोनोर "स्कोर 10 * की संख्या है - गोल्फस्कोर।" उस कार्यक्रम का स्कोर -300000000 होगा। वह बहुत कम है।

— TheNumberOne

6x60deg वेजेस! @PeterTaylor की टिप्पणी के समय इसने जो कहा, उसमें सुधार हुआ, लेकिन वास्तव में आपको 12x30deg wedges की आवश्यकता है .. प्रत्येक 6 बिंदुओं में से प्रत्येक के दाहिने हाथ की ओर 6, और प्रत्येक बिंदु के बाएं हाथ की ओर 6 परिलक्षित होते हैं। BTW, मुझे दूसरा बोनस समझ में नहीं आ रहा है

— Level River St

@ ऑप्टिमाइज़र हो गया, अब क्लीयर होना चाहिए।

— TheNumberOne

Answer 1

गणितज्ञ, 409 बाइट्स

{n,p}=Input[];m=999;Clear@f;_~f~_=0;0~f~0=1;r=RandomInteger;For[i=0,i<m,++i,For[x=m;y=0,f[x+1,y]+f[x-1,y]+f[x,y+1]+f[x,y-1]<1,a=b=-m;While[x+a<0||y+b<0||(y+b)/(x+a)>Tan[Pi/6],a=-r@1;b=r@2-1];x+=a;y+=b];x~f~y=1];Graphics[{White,g=Point/@Join@@{c=Cases[Join@@Table[{i,j}-1,{i,m},{j,m}],{i_,j_}/;i~f~j>0],c.{{1,0},{0,-1}}},Array[Rotate[g,Pi#/3,{0,0}]&,6]},Background->Black,ImageSize->n*p,ImageMargins->n(1-p)/2]

Ungolfed:

{n,p}=Input[];
m = 999;
ClearAll@f;
_~f~_ = 0;
0~f~0 = 1;
r = RandomInteger;
For[i = 0, i < m, ++i,
  For[x = m; y = 0, 
   f[x + 1, y] + f[x - 1, y] + f[x, y + 1] + f[x, y - 1] < 1,
   a = b = -m;
   While[x + a < 0 || y + b < 0 || (y + b)/(x + a) > Tan[Pi/6],
    a = -r@1;
    b = r@2 - 1
    ];
   x += a;
   y += b
   ];
  x~f~y = 1
  ];
Graphics[
 {White, g = 
   Point /@ 
    Join @@ {c = 
       Cases[Join @@ Table[{i, j} - 1, {i, m}, {j, m}], {i_, j_} /;
          i~f~j > 0], c.{{1, 0}, {0, -1}}}, 
  Array[Rotate[g, Pi #/3, {0, 0}] &, 6]},
 Background -> Black,
 ImageSize -> n*p,
 ImageMargins -> n (1 - p)/2
 ]

यह उन प्रपत्रों की अपेक्षा करता है, {n,p}जहां nपिक्सेल में छवि का आकार होता है, और pबर्फ के टुकड़े द्वारा कवर की जाने वाली छवि का प्रतिशत होता है।

दिए गए मापदंडों के साथ एक बर्फ के टुकड़े को उत्पन्न करने में आधे मिनट के लिए कुछ लगता है। आप का मान बदलकर वह तेज़ हो सकता है mसे 999करने के लिए 99है, लेकिन फिर परिणाम एक सा विरल लग रहा है। इसी तरह, आप बड़ी संख्या का उपयोग करके गुणवत्ता को क्रैंक कर सकते हैं, लेकिन फिर इसे बहुत लंबा लगेगा।

मैं एक पूर्णांक जाली पर ब्राउनियन पेड़ का गठन कर रहा हूं, नए कणों को रख रहा हूं {999, 0}, और जब तक कि वे मौजूदा कणों को नहीं मारते हैं, तब तक यादृच्छिक रूप से बाईं और ऊपर या नीचे (दाएं नहीं) को घुमाते हैं। मैं 0 से 30 डिग्री के बीच की गति के लिए विवश हूँ। अंत में, मैं एक्स-एक्सिस पर उस पच्चर को प्रतिबिंबित करता हूं, और इसे अपने 5 घुमावों के साथ प्रदर्शित करता हूं।

यहाँ कुछ परिणाम हैं (बड़े संस्करण के लिए क्लिक करें):

और यहां ब्राउनियन पेड़ के दो एनिमेशन बढ़ रहे हैं (प्रति फ्रेम प्रति कील 10 कण):

Comments

वाह मुझे पसंद है ... उन सभी को, वास्तव में। परिणाम अच्छे हैं!

— Sp3000

Answer 2

जावास्क्रिप्ट, ईएस 6, 799 740 695 658 648

मैं केवल दो कैनवस टैग और फ़ंक्शन fको स्निपेट से बाइट काउंट के हिस्से के रूप में गिन रहा हूं । बाकी सामान लाइव डेमो के लिए है

इसे एक्शन में देखने के लिए, नीचे दिए गए स्निपेट को लेटेस्ट फ़ायरफ़ॉक्स में इनपुट बॉक्स के ज़रिए साइज़ और रेशो दें

ध्यान दें कि आपको परिणाम को छिपाना होगा फिर लगातार बर्फ के टुकड़े से पहले फिर से दिखाना होगा

f=(N,P)=>{E.width=E.height=D.width=D.height=N
E.style.background="#000"
C=D.getContext("2d"),F=E.getContext("2d")
C.strokeStyle='#fff'
M=Math,r=M.random,I=0,n=N/2
C.beginPath()
C.rect(n,n,2,2)
C.fill()
B=_=>{x=n*P/100,y=0,w=[]
do{w.push([x,y])
do{X=2*((r()*2)|0)
Y=2*(((r()*3)|0)-1)
}while(x-X<0||y-Y<0||(y-Y)/(x-X)>.577)
x-=X,y-=Y}while(!C.isPointInPath(n+x,n+y))
I++
w=w.slice(-4)
x=w[0]
C.moveTo(x[0]+n,x[1]+n)
w.map(x=>C.lineTo(n+x[0],n+x[1]))
C.stroke()
E.width=E.height=N
for(i=0;i<12;i++){F.translate(n,n)
i||F.rotate(M.PI/6)
i-6?F.rotate(M.PI/3):F.scale(1,-1)
F.translate(-n,-n)
F.drawImage(D,0,0)}
I<(n*n*P*.22/100)&&setTimeout(B,15)}
B()}

<input placeholder="Input N" id=X /><input placeholder="Input percentage" id=Y /><button onclick="f(~~X.value,~~Y.value)">Create snowflake</button><br>
<canvas id=E><canvas id=D>

विभिन्न आकारों और प्रतिशत के साथ यहां कुछ उदाहरण प्रस्तुत किए गए हैं। सबसे अच्छे को SkullFlake (सूची में पहला) कहा जाता है । पूर्ण संकल्प में उन्हें देखने के लिए छवियों पर क्लिक करें।

मार्टिन और githubphagocyte से बहुत मदद और इनपुट।

Comments

यह इनपुट के रूप में भरी गई छवि का प्रतिशत नहीं लेता है।

— TheNumberOne

@ TheBestOne में अब यह प्रतिशत का ध्यान रखता है। ध्यान दें कि चूंकि यह एक ब्राउनियन ट्री आधारित स्नोफ्लेक है, न तो प्रतिशत और न ही वेज लंबाई के लिए अनुपात सही हो सकता है क्योंकि यादृच्छिकता की भूमिका खेलने में है।

— ऑप्टिमाइज़र

यह अब योग्य है।

— TheNumberOne

Answer 3

हास्केल, 781 733 बाइट्स

कार्यक्रम में option वेज के विकल्प की लंबाई के अनुपात को निर्दिष्ट किया गया है "विकल्प, इसलिए आपको इसे तीन कमांड लाइन तर्कों के साथ कॉल करना होगा:

./sf 150 50 40

तर्क # 1 छवि का आकार है, # 2 वेज में पिक्सेल का% और वेज के छोटे पक्ष का # 3 लंबाई (% में) है। छवि को। O.png ”नामक फ़ाइल में सहेजा गया है।

150-50-40:

मेरा कार्यक्रम कट-ऑफ स्पाइक्स के साथ स्नोफ्लेक्स का उत्पादन करता है, क्योंकि नए पिक्सल वेज (ग्रीन डॉट, नीचे देखें) के मध्य अक्ष पर शुरू होते हैं और वहां रहने के लिए जाते हैं, क्योंकि वे बाईं ओर, ऊपर या नीचे समान रूप से यादृच्छिक रूप से चलते हैं। जैसे कि पच्चर के बाहर के पिक्सल को छोड़ दिया जाता है, सीधी रेखा पच्चर (हरे तीर) की सीमा पर दिखाई देती है। मैं पिक्सल के लिए अन्य रास्तों को आज़माने में बहुत आलसी था।

150-50-40:

जब पच्चर काफी बड़ा होता है (तीसरा तर्क 100) तो मध्य अक्ष पर स्पाइक बढ़ सकते हैं और फिर उनमें से 12 होते हैं।

150-40-100:

कुछ पिक्सेल गोल आकार बनाते हैं (बाएं: 150-5-20; दाएं 150-20-90)।

कार्यक्रम:

import System.Environment;import System.Random;import Graphics.GD
d=round;e=fromIntegral;h=concatMap;q=0.2588
j a(x,y)=[(x,y),(d$c*e x-s*e y,d$s*e x+c*e y)] where c=cos$pi/a;s=sin$pi/a
go s f w p@(x,y)((m,n):o)|x<1=go s f w(s,0)o|abs(e$y+n)>q*e x=go s f w p o|elem(x-m,y+n)f&&(v*z-z)*(b-q*z)-(-v*q*z-q*z)*(a-z)<0=p:go s(p:f)w(s,0)o|1<2=go s f w(x-m,y+n)o where z=e s;a=e x;b=e y;v=e w/100
main = do 
 k<-getArgs;g<-getStdGen;let(s:p:w:_)=map read k
 i<-newImage(2*s,2*s);let t=h(j 3)$h(\(x,y)->[(x,y),(d$0.866*e x+0.5*e y,d$0.5*e x-0.866*e y)])$take(s*d(q*e s)*p`div`100)$go s[(0,0)]w(s,0)$map(\r->((1+r)`mod`2,r))(randomRs(-1,1)g)
 mapM(\(x,y)->setPixel(x+s,y+s)(rgb 255 255 255)i)((h(j(-3/2))t)++(h(j(3/2))t));savePngFile "o.png" i

Comments

@ ऑप्टिमाइज़र: कील के मध्य अक्ष पर स्पाइक होता है। पच्चर एक्स-अक्ष पर 15 डिग्री से ऊपर और नीचे जाता है। एक *-*-100छवि में इसके दोनों किनारे छवि की बाईं सीमा तक पहुँचते हैं (पोज़ की स्थिति के लिए दूसरी छवि देखें)। लगभग आधे हिस्से पर पिक्सेल हैं - अन्य हिस्सों में खाली हैं।

— निमि।

इस काउंटर के उपयोग से आपके प्रोग्राम की लंबाई 841 बाइट्स है।

— TheNumberOne

@ THEBestOne: इंडेंटिंग के दौरान टैब बनाम स्पेस। मैंने उन्हें अतिरिक्त 4 रिक्त स्थान जोड़ते समय मिलाया है code style। मैंने अपनी पोस्ट संपादित की है और टैब सेट किया है, लेकिन वे अभी भी रिक्त स्थान के रूप में दिखाई देते हैं। क्या किसी को पता है कि इसे कैसे ठीक करना है?

— दोपहर

@nimi साइट पर TheBestOne लिंक किया गया है, थोड़ा सा हैश #लिंक है जिस पर आप क्लिक कर सकते हैं। आप वहां अपना टैब्ड कोड पेस्ट कर सकते हैं और इसे लिंक कर सकते हैं।

— Sp3000

आप शायद कोड का लिंक कहीं बना सकते हैं। आप टैब के बजाय रिक्त स्थान का उपयोग कर सकते हैं। आप code styleप्रत्येक पंक्ति 4 स्थानों को इंडेंट करके मैन्युअल रूप से प्राप्त कर सकते हैं ।

— TheNumberOne

Answer 4

प्रसंस्करण 2 - 575 वर्ण

एक फ़ाइल f में ले जाता है जिसकी पहली पंक्ति छवि का आकार है और दूसरी फ्लेक्स त्रिज्या है। जब भी कोई नया बिंदु रखा जाता है तो उसे केंद्र के चारों ओर 12 बार घुमाया जाता है। यह एक घुमाए हुए पच्चर के रूप में बहुत समान प्रभाव पैदा करता है, लेकिन बिल्कुल समान नहीं।

  int d,w,h,k,l,o,p,x,y;
  String n[] = loadStrings("f.txt");
  d=Integer.parseInt(n[0]);
  h=Integer.parseInt(n[1]);
  size(d,d);
  w=d/2;
  k=l=(int)random(d); 
  background(0);
  loadPixels();
  o=p=0;
  pixels[w*w*2+w]=color(255);
  while(true)
  {
    o=k+(int)random(-2,2);
    p=l+(int)random(-2,2);
    if(p*d+o>d*d-1 || p*d+o<0 || o<0 || o>d){
      k=l=(int)random(d);
    }
    else
    {
      if(pixels[p*d+o]==color(255))
      {
        p=l-w;
        o=k-w;
        if(o*o+p*p>h*h){break;}
        float s,c;
        for(int j=0;j<12;j++)
        {
          s=sin(PI*j/6);
          c=cos(PI*j/6);         
          x=(int)((o*c)-(p*s));
          y=(int)(((p*c)+(o*s)));
          pixels[(int)(d*y+x+w+(w*d))]=color(255);
        }
        k=l=(int)random(d);  
      }
      else
      {
        k=o;
        l=p;
      }
    }
  }
  updatePixels(); 

आप यहाँ प्रसंस्करण प्राप्त कर सकते हैं

Comments

यह विनिर्देशों के अनुरूप नहीं है। यदि आप इसे घुमाए जाने के बजाय केंद्र के चारों ओर बिंदु पर प्रतिबिंबित करते हैं तो यह अर्हता प्राप्त करेगा।

— TheNumberOne

color(255)color(-1)एक बाइट बचाने के लिए बन सकते हैं

— Kritii Lithos