मैंने एक वर्ग से बने जुड़वां ड्रैगन वक्र का एक शांत जिफ देखा , और सोचा कि अगर हम एक और आधार छवि से शुरू करते हैं तो क्या होगा। इसलिए मैंने ऐसा करने के लिए एक कार्यक्रम लिखा।

यह इतना अच्छा है कि मुझे लगा कि इसे चुनौती के रूप में करना मजेदार होगा।

कार्य

आप एक चौकोर छवि के साथ एक किनारे की लंबाई लेंगे जो 2 की शक्ति (4 से अधिक) है।

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

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

आपको केवल आउटपुट की आवश्यकता है / परिवर्तन के अंतिम परिणाम को प्रदर्शित करें, जीआईएफ की तरह सभी मध्यवर्ती चरणों को नहीं।

यह कोड-गोल्फ है इसलिए लक्ष्य बाइट्स में मापे गए स्रोत कोड की लंबाई को कम करना है।

उदाहरण के माध्यम से काम किया

मैं पृष्ठ फ़्रेम के शीर्ष पर दिखाए गए कैट गिफ़ के माध्यम से फ़्रेम द्वारा काम करूंगा।

यहाँ प्रारंभिक छवि है:

यह छवि 512 से 512 पिक्सेल है। हम प्रत्येक बैंड को 1/8 छवि आकार (64 पिक्सेल) को लंबवत रूप से शुरू करने और स्थानांतरित करने के लिए 4 बैंड में तोड़ देंगे।

अब हम इसे कई बैंड (8 बैंड) से दो बार में विभाजित करेंगे और पिछली बार (32 पिक्सल) के मुकाबले इसे आधा स्थानांतरित कर देंगे। इस बार हम क्षैतिज रूप से बदलाव करेंगे।

अब हम लंबवत रूप से इस बार 16 बैंडों में बंटेंगे और प्रत्येक बैंड को 16 पिक्सेल से स्थानांतरित करेंगे।

32 बैंड, 8 पिक्सेल, क्षैतिज पारी

64 बैंड, 4 पिक्सेल, ऊर्ध्वाधर पारी।

128 बैंड, 2 पिक्सल, क्षैतिज पारी।

256 बैंड, 1 पिक्सेल, ऊर्ध्वाधर पारी।

चूंकि अगली पाली में हमें प्रत्येक बैंड को आधा पिक्सेल से स्थानांतरित करने की आवश्यकता होगी, हम इस बिंदु पर रुकेंगे और परिणाम को आउटपुट करेंगे।

परीक्षण के मामलों

मेरे पास एक काम करने वाली स्क्रिप्ट है जो इन छवियों को बना सकती है इसलिए मैंने सोचा कि मैं आप लोगों को परीक्षण मामलों के लिए छवियां चुनने दूंगा। इसलिए यदि आपके पास एक चौकोर छवि है जो कि 2 चौड़ी की शक्ति है जिसे आप ड्रैगनफाइंड होते देखना चाहते हैं। इसे मुझे भेजने के लिए स्वतंत्र महसूस करें और मैं इसे एक परीक्षण मामला बनाऊंगा।

आपको एक सादे सफेद या ठोस काले रंग की छवि पर भी परीक्षण करना चाहिए ताकि आप यह निर्धारित कर सकें कि पिक्सल गायब हो रहे हैं या नहीं।

— गेहूं का जादूगर
स्रोत

संबंधित , संबंधित ।

— जोनाथन एलन

ड्रैगन की छवि? अहम

— कॉनर ओ'ब्रायन

मुख्य कारण यह बंद हो जाता है, मुझे लगता है, यह स्पष्ट नहीं है कि छवि को कितनी बार स्थानांतरित किया जाना चाहिए। यदि आप निर्दिष्ट करते हैं कि शिफ्ट कितनी बार होनी चाहिए, तो मुझे लगता है कि यह ठीक रहेगा। मेरे लिए और कुछ भी स्पष्ट नहीं है।

— कॉमरेड स्पार्कलपनी

@LuisMendo **Start** by shifting one 8th of the size of the imageतो repeat ... each time splitting the image into twice as many divisions and shifting half as far as the previous timeपहली बार 1/8, दूसरा 1/16 होगा। तीसरा 1/32 जब तक पिक्सेल की संख्या आंशिक है। मैं नहीं देखता कि इस बारे में क्या अस्पष्ट है।

— लेवल रिवर सेंट

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

— लेवल रिवर सेंट

MATLAB, 237 बाइट्स

function A=r(A);n=size(A,1);p=@(a,v)permute(a,[v,3]);k=n/8;v=1:2;while k>=1;b=mod(0:n-1,4*k)<2*k;x=find(b);y=find(~b);c=[k+1:n,1:k;n-k+1:n,1:n-k];A=p(A,v);c=c(3-v,:);A(x,:,:)=A(x,c(1,:),:);A(y,:,:)=A(y,c(2,:),:);A=p(A,v);k=k/2;v=3-v;end

थोड़ा सा अनुमान लगाने का काम लिया क्योंकि मैंने चश्मे से प्रक्रिया को नहीं समझा, लेकिन छवि की मदद से यह काम किया।

— flawr
स्रोत

पायथन 2, 317 313 304 298

from PIL import Image
I=Image.open(input())
w,h=I.size
b,p,q,s=4,w/8,1,1
while p>1:o=I.copy();o.paste(I,[(w-p,0),(0,w-p)][q==1]);o.paste(I,[(p-w,0),(0,p-w)][q==1]);q*=-1;x=0;exec'o.paste(I.crop([(0,x,w,x+p*2),(x,0,x+p*2,w)][s%2]),[(q*p,x),(x,q*p)][s%2]);q*=-1;x+=p*2;'*b;p/=2;I=o;s+=1;b*=2
o.show()

— dieter
स्रोत

हमारी साइट के नियमों के अनुसार आप इसका उपयोग कर सकते हैं input()और इसके बजाय इनपुट प्राप्त करने के लिए इसे स्ट्रिंग के रूप में पारित करने की अपेक्षा कर सकते हैं raw_input()।

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

गणितज्ञ, १ 17 by बाइट्स

यह धीमा है और पूरी तरह से गोल्फ नहीं है।

r=ImageRotate;r[#2,Pi/2(3-#)]&@@Nest[{#+1,ImageAssemble@MapIndexed[RotateLeft[#,(-1)^#2]&]@ImagePartition[r@#2,Reverse@d/2^{#,#-1}]}&@@#&,{3,#},Log2@Min[d=ImageDimensions@#]-2]&

यह लीना है:

यह लीना द ड्रैगन है:

— alephalpha
स्रोत