एक छवि को हिलाएँ

Question

मुझे हिल्बर्ट कर्व पसंद है ।

---

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

unraveling

अनवार करने के लिए आप ऊपरी बाएँ हाथ के कोने में पिक्सेल के साथ शुरू करेंगे और जब तक आप छवि के किनारे पर नहीं पहुँचेंगे, तब तक सही यात्रा करेंगे। एक बार जब आप छवि के किनारे से टकरा जाते हैं तो आप अगली पंक्ति में चले जाएँगे और जब तक आप फिर से किनारे पर नहीं पहुँचेंगे, तब तक बाईं यात्रा शुरू करेंगे। आप हर बार दिशा बदलकर पंक्ति को अपरिवर्तित करते रहेंगे ताकि आपको एक निरंतर वक्र प्राप्त हो सके। यह साँप के एक अच्छे से खेले जाने वाले खेल की तरह दिखना चाहिए

सुलझने का परिणाम पिक्सेल का एक क्रम होना चाहिए जिसमें हर पिक्सेल बिल्कुल एक बार शामिल हो

Reraveling

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

आई / ओ

आपके कार्यक्रम या फ़ंक्शन को मानक तरीकों के माध्यम से निर्दिष्ट बाधाओं की एक छवि में ले जाना चाहिए और मानक तरीकों के माध्यम से दूसरी छवि को आउटपुट करना चाहिए।

स्कोरिंग

यह सबसे कम बाइट्स जीत के साथ कोड-गोल्फ कार्यक्रम है।

उदाहरण

इनपुट

उत्पादन

---

इनपुट

उत्पादन

---

इनपुट

उत्पादन

---

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

बेझिझक अपने जवाबों में अपने परिणाम शामिल करें!

Comments

क्या इनपुट के रूप में छवि के बजाय आरजीबी मानों की एक सरणी लेना ठीक है? आउटपुट के बारे में क्या?

— जुंगह्वान मिन

@ जेएचएम नहीं, आप नहीं कर सकते। हालाँकि, आप जो भी छवि प्रारूप चाहते हैं, उसे चुन सकते हैं, इसलिए यदि आपकी भाषा में बिलियन इमेज सपोर्ट नहीं है, तो आप एक असम्पीडित .ppm फ़ाइल का उपयोग कर सकते हैं, जो RGB मानों की एक सरणी के समान है।

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

Answer 1

गणितज्ञ, २ Mat६ २ by३ बाइट्स

Image[Array[1,{l=Length@#,l}]~ReplacePart~Thread[#&@@@Split[#&@@@FoldList[Switch[#2,"-",#{1,I},"+",#/{1,I},"F",#+{ReIm@Last@#,0},_,#]&,{{1,1},I},Characters@Nest[StringReplace@{"L"->"+RF-LFL-FR+","R"->"-LF+RFR+FL-"},"L",Log2@l]]]->Join@@MapAt[Reverse,#,2;;;;2]]]&@*ImageData

ओह! चुनौती लेकिन मज़ा!

व्याख्या

ImageData

ImageRGB मानों की एक सरणी में कनवर्ट करें ।

Array[1,{l=Length@#,l}]

सिर के साथ एक lबाय lऐरे को उत्पन्न करें 1, जहां lइनपुट की लंबाई (यानी छवि की चौड़ाई) है।

यह पैदावार {{1[1, 1], 1[1, 2], ..., 1[1, L]}, {1[2, 1], ..., 1[2, L]}, ..., {1[L, 1], ..., 1[L, L]}}( lभ्रम को कम करने के लिए कैप में लिखा गया है)

StringReplace@{"L"->"+RF-LFL-FR+","R"->"-LF+RFR+FL-"}

एक StringReplaceसमारोह है कि हर की जगह "L"के साथ "+RF-LFL-FR+"और "R"साथ"-LF+RFR+FL-"

Nest[ ... ,"L",Log2@l]

StringReplaceफ़ंक्शन को String "L", Log2[l]समय पर लागू करें ।

Characters

परिणामस्वरूप वर्णों Stringमें परिवर्तित करें List।

Switch[#2,"-",#{1,I},"+",#/{1,I},"F",#+{ReIm@Last@#,0},_,#]&

एक अनाम फ़ंक्शन जो:

• यदि दूसरा इनपुट है "-", तो पहले इनपुट के दूसरे तत्व को गुणा करें I।
• यदि दूसरा इनपुट है "+", तो पहले इनपुट के दूसरे तत्व को विभाजित करें I।
• यदि दूसरा इनपुट है "F", तो दूसरे इनपुट के पहले इनपुट को बढ़ाएं ReIm( इनपुट के वास्तविक और काल्पनिक भाग को अलग करें)।

फोल्डलिस्ट [..., {{1,1}, I}, ...]

दूसरे इनपुट के रूप में वर्णों के {{1,1},I}प्रत्येक तत्व का उपयोग करते हुए, उपरोक्त अनाम फ़ंक्शन को संचयी रूप से शुरू करना List। यह कोड सभी पुनरावृत्तियों के आउटपुट देता है।

#&@@@Split[#&@@@ ... ]

प्रत्येक के दूसरे तत्वों से छुटकारा पाएं Listऔर डुप्लिकेट को हटा दें। (इस बिंदु तक कदम Listहिल्बर्ट वक्र के निर्देशांक उत्पन्न करते हैं )

Join@@MapAt[Reverse,#,2;;;;2]

इनपुट आरजीबी सरणी को अनलॉक करें (हर दूसरी पंक्ति और फ्लैटेंस को उलट देता है)।

Thread[ ... -> ... ]

Ruleऑब्जेक्ट बनाएँ , जैसे कि पहले इनपुट में पहला तत्व (हिल्बर्ट वक्र के निर्देशांक) को दूसरे इनपुट के पहले तत्व (अप्रकाशित छवि), दूसरे इनपुट के साथ दूसरे तत्व और इसी तरह जोड़ा जाता है।

... ~ReplacePart~ ...

उन प्रतिस्थापन लागू Ruleकरने के लिए रों Arrayदूसरे चरण से।

Image

आरजीबी मानों की सरणी में परिवर्तित करें a Image।

सैंपल इन / आउट

इनपुट:

आउटपुट:

---

इनपुट:

आउटपुट:

उलटा कार्य ( 266 253 बाइट्स)

Image[MapAt[Reverse,Extract[#,#&@@@Split[#&@@@FoldList[Switch[#2,"-",#{1,I},"+",#/{1,I},"F",#+{ReIm@Last@b,0},_,#]&,{{1,1},I},Characters@Nest[StringReplace@{"L"->"+RF-LFL-FR+","R"->"-LF+RFR+FL-"},"L",Log2[l=Length@#]]]]]~Partition~l,2;;;;2]]&@*ImageData

Answer 2

ऑक्टेव 234 बाइट्स

I=imread(input(''));w=rows(I);X=[0,3;1,2];for k=2:log2(w);n=numel(X);X=[X',rot90(X',2)+3*n;X+n,X+2*n];end;for k = 1:3;I(2:2:end,:,k)=fliplr(I(2:2:end,:,k));end[~,S]=sort(X(:));I(S+(0:w^2:2*w^2))=permute(I,[2 1 3]);imwrite(I,input(''))

इनपुट और आउटपुट छवियों के फ़ाइल नाम को मानक इनपुट प्रदान किया जाना चाहिए। बिना इनपुट / आउटपुट के कोड का आकार 194 बाइट्स है ।
स्पष्टीकरण:

सूचकांकों का आधार पैटर्न है:

X =
  0 3
  1 2

प्रत्येक पुनरावृत्ति में पिछली बार किए गए पुनरावृत्ति के परिणाम से 4 प्रतियाँ और प्रत्येक प्रति पर कुछ परिवर्तन लागू होते हैं तो सभी ब्लॉकों को वर्तमान परिणाम बनाने के लिए संक्षिप्त कर दिया जाता है।

X =[0,3;1,2];
for k = 2:log2(s)
    n=numel(X);
    X = [X',rot90(X',2)+3*n;X+n,X+2*n];
end

तो हमारे पास:

block(1,1): X' 
block(1,2): rot90(X',2)+3*n 
block(2,1): X+n
block(2,2): X+2*n

0    1  | 14   15
3    2  | 13   12
--------|--------
4    7  |  8   11
5    6  |  9   10

हिल्बर्ट सूचकांकों को क्रमबद्ध किया गया और छंटे हुए तत्वों के सूचकांक वापस आए:

[~,S]=sort(X(:));

सभी पंक्तियों को भी उकेरते हुए उकेरा गया:

for k = 1:3
    I(2:2:end,:,k) = fliplr(I(2:2:end,:,k));
end

Reraveling लागू:
-S प्रत्येक चैनल के लिए
दोहराए गए-ऑक्टेव डेटा के बाद से लागू कॉलम-वार की व्यवस्था की गई

I(S+(0:w^2:2*w^2))=permute(I,[2 1 3]);

उदाहरण चित्र:

Comments

यदि आप I / O का उपयोग करने से बचना चाहते हैं, तो आप अपने कार्यक्रम को एक फ़ंक्शन के रूप में चुन सकते हैं।

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

फ़ंक्शन + अंत कीवर्ड अधिक बाइट्स का उपभोग करते हैं!

— rahnema1