पेंटाफ्लक ड्रा करें

Question

सबसे पहले ... मैं सभी को मेरी क्रिसमस की शुभकामनाएं देना चाहता हूं (क्षमा करें, यदि मैं आपके टाइमजोन के लिए एक दिन देरी से हूं)।

इस अवसर का जश्न मनाने के लिए, हम एक स्नोफ्लेक बनाने जा रहे हैं। क्योंकि साल 201 है 5 और क्रिसमस 2 पर है 5 (व्यक्तियों के एक बड़े हिस्से के लिए) वें, हम एक आकर्षित करेगा पेंटा परत। पेंटाफ्लक पेंटागन से बना एक साधारण भग्न है। यहाँ कुछ उदाहरण दिए गए हैं (यहाँ से लिया गया है) :

प्रत्येक पेंटाफ्लक में एक ऑर्डर एन है। ऑर्डर 0 का पेंटाफ्लक केवल एक पेंटागन है। अन्य सभी आदेशों के लिए n, एक पेंटाफ्लेक पिछले ऑर्डर के 5 पेंटाफ्लेक्स से बना है, जो पिछले ऑर्डर के 6 वें पेंटाफ्लेक के आसपास व्यवस्थित है। उदाहरण के लिए, एक पेंटाफ्लेक ऑर्डर 1 एक केंद्रीय पेंटागन के आसपास व्यवस्थित 5 पेंटागन से बना है।

इनपुट

आदेश n। यह पूर्वनिर्धारित चर को छोड़कर किसी भी तरह से दिया जा सकता है।

उत्पादन

ऑर्डर nपेंटाफ्लेक की एक छवि । कम से कम 100px चौड़ा और 100px लंबा होना चाहिए। इसे फ़ाइल में सहेजा जा सकता है, उपयोगकर्ता को प्रदर्शित किया जा सकता है, या इसे आउटपुट किया जा सकता है STDOUT। आउटपुट के किसी अन्य रूप की अनुमति नहीं है। इस चुनौती से पहले मौजूद सभी छवि प्रारूपों की अनुमति है।

जीतना

कोडगुल्फ़ के रूप में, बाइट्स की सबसे कम संख्या वाला व्यक्ति जीतता है।

Comments

-1 क्योंकि बर्फ के टुकड़े में केवल 6 गुना समरूपता है! = डी

— दोष

@flawr केवल इस लेख के अनुसार .1% बर्फ के टुकड़े में वास्तव में 6 गुना समरूपता है ... या किसी भी समरूपता। हालाँकि, जिन स्नोफ्लेक्स में समरूपता होती है उनमें 6-गुना समरूपता के अलावा 3-गुना समरूपता हो सकती है: P

— TheNumberOne

इस लेख में केवल सभी स्नोफ्लेक्स के .1% से कम के तरीके का अध्ययन किया गया है, और यह वैसे भी निरर्थक है, क्योंकि उन्होंने केवल अमेरिकी स्नोफ्लेक्स का अध्ययन किया था। मुझे यकीन है कि मीट्रिक हिमपात का एक रास्ता अधिक सममित है! (PS: सुंदर चित्र! स्नोफ्लेक # 167 विशेष रूप से दिलचस्प है !) (मैंने अभी देखा कि मीट्रिक स्नोफ्लेक्स में 10 गुना समरूपता होनी चाहिए।)

— 14

जब तक यह उपरोक्त विधियों में से एक का उपयोग करके आउटपुट करता है तब तक यह ठीक रहेगा। हालाँकि, nआपकी स्क्रिप्ट फ़ाइल में पूर्वनिर्धारित नहीं किया जा सकता है। आप पढ़ सकते हैं nसे STDIN, शीघ्र यह उपयोगकर्ता से एक समारोह / commad लाइन तर्क के रूप में इसे ले ... मूल रूप से कुछ भी आप सीधे अपने कोड में एम्बेड करने के लिए छोड़कर चाहते हैं।

— TheNumberOne

इसे +1 न करें क्योंकि इसमें 25 :(

— The_Basset_Hound

Answer 1

मतलाब, 226

function P(M);function c(L,X,Y,O);hold on;F=.5+5^.5/2;a=2*pi*(1:5)/5;b=a(1)/2;C=F^(2*L);x=cos(a+O*b)/C;y=sin(a+O*b)/C;if L<M;c(L+1,X,Y,~O);for k=1:5;c(L+1,X+x(k),Y+y(k),O);end;else;fill(X+x*F, Y+y*F,'k');end;end;c(0,0,0,0);end

Ungolfed:

function P(M);                
function c(L,X,Y,O);          %recursive function
hold on;
F=.5+5^.5/2;                  %golden ratio
a=2*pi*(1:5)/5;               %full circle divided in 5 parts (angles)
b=a(1)/2;
C=F^(2*L);
x=cos(a+O*b)/C;               %calculate the relative position ofnext iteration
y=sin(a+O*b)/C;
if L<M;                       %current recursion (L) < Maximum (M)? recurse
    c(L+1,X,Y,~O);            %call recursion for inner pentagon
    for k=1:5;
        c(L+1,X+x(k),Y+y(k),O)%call recursion for the outer pentagons
    end; 
else;                         %draw
    fill(X+x*F, Y+y*F,'k');  
end;
end;
c(0,0,0,0);
end

पांचवां पुनरावृत्ति (पहले से ही प्रस्तुत करने में काफी समय लगा)।

कोड का थोड़ा सा परिवर्तन (दुर्भाग्य से अधिक बाइट्स) इस सुंदरता में परिणाम =)

ओह, और एक और एक:

Comments

इस चुनौती की ओर इशारा करने के लिए धन्यवाद, मैं गया और एक और समाधान जोड़ा गया, आशा है कि आप बुरा नहीं मानेंगे;) मैं सुरक्षित रूप से आपकी बाइट-काउंट से दूर हूं, वैसे भी, मुझे यह याद रखना बहुत दिलचस्प लगा।

— एंड्रास डीक

Answer 2

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

a=RotationTransform
b=Range
r@k_:={Re[t=I^(4k/5)],Im@t}
R@k_:=a[Pi,(r@k+r[k+1])/2]
Graphics@Nest[GeometricTransformation[#,ScalingTransform[{1,1}(Sqrt@5-3)/2]@*#&/@Append[R/@b@5,a@0]]&,Polygon[r/@b@5],#]&

अंतिम पंक्ति एक फ़ंक्शन है जिसे पूर्णांक पर लागू किया जा सकता है n।

मैथेमेटिका फ़ंक्शन नाम लंबे हैं। किसी को उन्हें फंसाना चाहिए और उन्हें एक नई भाषा बनानी चाहिए। :)

जब इसे लागू किया जाता है 1:

जब इसे लागू किया जाता है 2:

Answer 3

MATLAB, 235 233 217 बाइट्स

अद्यतन: @flawr के सुझावों के एक समूह ने मुझे 16 बाइट्स खोने में मदद की। चूँकि केवल इसने मुझे त्रुटिपूर्ण समाधान को हराने की अनुमति दी , और यह कि मुझे पहली बार में दोषों की सहायता के बिना चुनौती नहीं मिली, इसे हमारे द्वारा संयुक्त रूप से प्रस्तुत करें :)

N=input('');f=2*pi/5;c=1.5+5^.5/2;g=0:f:6;p=[cos(g);sin(g)];R=[p(:,2),[-p(2,2);p(1,2)]];for n=1:N,t=p;q=[];for l=0:4,q=[q R^l*[c-1+t(1,:);t(2,:)]/c];end,p=[q -t/c];end,p=reshape(p',5,[],2);fill(p(:,:,1),p(:,:,2),'k');

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

Ungolfed संस्करण:

N=input('');                                % read order from stdin

f=2*pi/5;                                   % angle of 5-fold rotation
c=1.5+5^.5/2;                               % scaling factor for contraction

g=0:f:6;
p=[cos(g);sin(g)];                          % starting pentagon, outer radius 1
R=[p(:,2),[-p(2,2);p(1,2)]];                % 2d rotation matrix with angle f

for n=1:N,                                  % iterate the points
    t=p;
    q=[];
    for l=0:4,
       q=[q R^l*[c-1+t(1,:);t(2,:)]/c];     % add contracted-rotated points
    end,
    p=[q -t/c];                             % add contracted middle block
end,

p=reshape(p',5,[],2);                 % reshape to 5x[]x2 matrix to separate pentagons
fill(p(:,:,1),p(:,:,2),'k');          % plot pentagons

परिणाम N=5( axis equal offपूर्वगामीता के लिए थोड़ी देर के बाद , लेकिन मुझे आशा है कि बाइट-वार की गणना नहीं होती है):

Comments

मुझे लगता है कि आप R=[p(:,2),[-p(2,2);p(1,2)]];(और पिछले को समाप्त करके R,C,S) कुछ बाइट्स बचा सकते हैं q=[q R^l*[c-1+t(1,:);t(2,:)]/c]और आप उपयोग कर सकते हैं और मुझे लगता हैc=1.5+5^.5/2;

— त्रुटी

@flawr स्पष्ट रूप से आप सही कह रहे हैं :) 1. रोटेशन मैट्रिक्स के लिए धन्यवाद, 2. नए के लिए धन्यवाद q, मैं भी वहाँ पैरेंटेस की एक बेकार जोड़ी थी ... 3. धन्यवाद, लेकिन यह जादू क्या है?: D 4. चूंकि समाधान अब आपके मूल से छोटा है, इसलिए मैं इसे आंशिक रूप से आपकी अधीनता मानता हूं।

— एंड्रास डीक

Answer 4

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

Mathematica Tableसंस्करण 10 के बाद से नए सिंटैक्स का समर्थन करता है : Table[expr, n]जो एक अन्य बाइट बचाता है। Table[expr, n]के बराबर है Table[expr, {n}]।

f@n_:=(p=E^Array[π.4I#&,5];Graphics@Map[Polygon,ReIm@Fold[{g,s}~Function~Join[.62(.62g#+#&/@s),{-.39g}],p,p~Table~n],{-3}])

इस फ़ंक्शन का मूल जटिल संख्याओं का उपयोग कर रही है, ताकि वे इनफॉर्मेशन कर सकें और फिर उन्हें पॉइंट्स द्वारा कन्वर्ट कर सकें ReIm।

परीक्षण का मामला:

f[4]

Comments

πUTF-8 में दो बाइट्स लेता है, इसलिए आप कुल 125 बाइट्स करते हैं।

— २०१२ आर्कम्पियन

OMFG यह क्या है

— DumpsterDoofus

Answer 5

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

एक बाल द्वारा पीटर रिक्टर के जवाब को संपादित करना, यहाँ मेरा अपना एक है। यह ग्राफिक्स की कार्यक्षमता पर भारी पड़ा है, और गणित और एफपी पर कम है। 10.1 में नया सर्किल पॉइंट बनाया गया है ।

c=CirclePoints;g=GeometricTransformation;
p@0=Polygon@c[{1,0},5];
p@n_:=GraphicsGroup@{
        p[n-1],
        g[
          p[n-1]~g~RotationTransform[Pi/5],
          TranslationTransform/@{GoldenRatio^(2n-1),n*Pi/5}~c~5
        ]
      };
f=Graphics@*p

संपादित करें: GoldenRatio के लिए DumpsterDoofus का धन्यवाद

Comments

आप की जगह 3 बाइट्स बचा सकता है ((1+Sqrt@5)/2)के साथ GoldenRatio। इसके अलावा दूसरी पंक्ति में मुझे लगता है कि इसके p@0=Polygon@c[{1,0},5];बजाय होना चाहिए p@0=Polygon@cp[{1,0},5];। (BTW मैं वास्तव में पीटर हूं, मुझे दो प्रोफाइल मिले हैं)।

— डम्पस्टरडॉफस

हाँ! अच्छा निर्णय। मैंने टाइपो को भी देखा, लेकिन इसे ठीक करना भूल गया। D'oh,

— hYPotenuser

Answer 6

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

r=Exp[Pi.4I Range@5]
p=1/GoldenRatio
f@0={r}
f@n_:=Join@@Outer[1##&,r,p(f[n-1]p+1),1]~Join~{-f[n-1]p^2}
Graphics@*Polygon@*ReIm@*f

मैं njpipeorgan के उत्तर के लिए एक समान तकनीक का उपयोग करता हूं (वास्तव में मैंने उसकी 2Pi I/5 == Pi.4Iचाल चुरा ली है), लेकिन पुनरावर्ती कार्य के रूप में कार्यान्वित किया गया।

उदाहरण का उपयोग ( %उस अनाम फ़ंक्शन तक पहुंचने के लिए जो अंतिम पंक्ति में आउटपुट था):

 %[5]