मैट्रिक्स में प्रत्येक 2x2 ब्लॉक को घुमाएं

Question

चुनौती

पूर्णांक के n x mसाथ एक मैट्रिक्स दिया n > 1और m > 1भरा

१ २ ३
४ ५ ६

और 2x2मैट्रिक्स में ब्लॉक के रूप में कई मानों के साथ पूर्णांक की एक सूची ( (n-1)*(m-1)यदि आपको सटीक संख्या की आवश्यकता है)

[१, २]

2x2दिए गए क्रम में सूची में वर्तमान मान से घुमाए गए प्रत्येक ब्लॉक के साथ मैट्रिक्स को आउटपुट करें । ऊपर का उदाहरण मिलेगा

४ ६ २
५ ३ १

पहला ब्लॉक दाईं ओर एक बार घुमाया जाता है और दूसरा ब्लॉक दाईं ओर दो घुमाया जाता है।

टिप्पणियाँ

• एक सकारात्मक पूर्णांक का मतलब है कि आप कई कदमों से दाईं ओर घूमते हैं।
• एक नकारात्मक पूर्णांक का मतलब है कि आप उस कई चरणों से बाएं घूमते हैं।
• शून्य का मतलब है कि आप घूमते नहीं हैं।
• आप ब्लॉकों को पंक्ति-वार घुमाते हैं। इसका मतलब है कि आप पहली पंक्ति में शुरू करते हैं और दाईं ओर जाते हैं। एक बार जब आप उस पंक्ति के प्रत्येक ब्लॉक को घुमाते हैं तो आप अगले एक पर जाते हैं। अंत में हर ब्लॉक को एक बार बिल्कुल घुमाया गया।
• ध्यान रखें कि ब्लॉक एक-दूसरे को ओवरलैप करते हैं। ऊपर दिए गए पहले मैट्रिक्स में ब्लॉक [[1,2],[4,5]]और [[2,3],[5,6]]उदाहरण के लिए है।
• ब्लॉक का प्रत्येक घुमाव आसन्न ब्लॉकों पर रोटेशन को प्रभावित करता है। यही कारण है कि आपको ऊपर वर्णित पैटर्न में घुमाव करना होगा।

नियम

• आप इनपुट को सबसे सुविधाजनक प्रारूप में ले सकते हैं। कृपया अपने उत्तर में निर्दिष्ट करें कि आप किसका उपयोग करते हैं। हालांकि यह आपको मैट्रिक्स ब्लॉक-वार पढ़ने की अनुमति नहीं देता है।
• कार्य या पूर्ण कार्यक्रम की अनुमति है।
• इनपुट / आउटपुट के लिए डिफ़ॉल्ट नियम ।
• मानक खामियां लागू होती हैं।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है। टाईब्रेकर पहले जमा करना है।

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

यहां इनपुट प्रारूप मैट्रिक्स के लिए सूचियों की सूची और मूल्यों के लिए एक सामान्य सूची है।

[[१,२], [३,४]], [३१] -> [[४,१], [३,२]]
[[११,११], [११,११]], -३३३, ६६६] -> [[११,११], [११,११]]
[[१,२,३], [४,५,६]], [१,२] -> [[४,६,२], [५,३,६१]]
[[1,2,3], [4,5,6], [7,8,9]], [4,0,12, -20] -> [[1,2,3], [4, 5,6], [7,8,9]]
[[1,2,3,4,5], [5,4,3,2,1], [1,2,3,4,5]], [2, -3,4,1,6, 24,21, -5] -> [[4,1,5,2,4], [2,1,3,5,5], [3,2,4,3,4,1]]

हैप्पी कोडिंग!

Answer 1

CJam ( 42 40 बाइट्स)

{(\@2$,(/.{@a@a+z(\@.{4,={+2/zW%~}*}z~}}

ऑनलाइन डेमो

मूल रूप से यह ब्लॉक को मोड़ने के लिए एक ही तकनीक को दो बार लागू करता है

{4,={+2/zW%~}*}

जो 2x2 मैट्रिक्स और घूमने के लिए कई बार संचालित होता है।

[first row] [[second row] [third row] ... [last row]] [value_0 value_1 ... value_n]

के साथ संसाधित किया जा सकता है

.{block}

और का प्रभाव है

[first row]
[second row] value_0 {block}~
[third row] value_1 {block}~
...

क्योंकि .( %CJam में) परिणाम समाप्त होने तक किसी सरणी में इकट्ठा नहीं होता है।

Comments

आप 4,=सही मोड्यूलो का उपयोग करके एक बाइट को बचा सकते हैं (जब तक कि आपके ब्लॉक को कम से कम एक बार चलाने की आवश्यकता न हो?)।

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

इसके अलावा zW%रोटेशन के बारे में क्या ?

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

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

— पीटर टेलर

Answer 2

CJam, 65 63 60 55 बाइट्स

वहाँ चाहिए यह करने के लिए एक बेहतर तरीका हो सकता है ...

{_e_\z,:N(@/Ta*ee{~4,=,f{;1$,,\[XTN_)]f+_(+er\f=}~}/N/}

यह एक अनाम फ़ंक्शन है जो स्टैक पर निर्देशों और मैट्रिक्स (उस क्रम में) की अपेक्षा करता है और परिणामस्वरूप मैट्रिक्स को उनके स्थान पर छोड़ देता है।

इसका परीक्षण यहां करें।

व्याख्या

मुझे अभी कोड के लिए पूर्ण विराम लिखने का मन नहीं है, इसलिए यहाँ एक मोटा अवलोकन है:

• 2D सरणी हेरफेर CJam में एक दर्द है, इसलिए मैं मैट्रिक्स को अनियंत्रित कर रहा हूं, प्रत्येक घुमाव को विशिष्ट पदों पर तत्वों के क्रमचय के रूप में गणना करता हूं और फिर सरणी को अंत में फिर से पंक्तियों में विभाजित करता हूं। मैट्रिक्स की चौड़ाई में संग्रहीत है N।
• स्थिति पर एक रोटेशन kunrolled सरणी में चार सूचकांक परिवर्तन: k <- k+1, k+1 <- k+1+N, k+N <- k, k+1+N <- k+1। kनिर्देश सूची के साथ प्रत्येक सूचकांक के लिए, मैं इसके लिए एक क्रमपरिवर्तन की गणना करता हूं, और इसे अनियंत्रित इनपुट सरणी पर लागू करता हूं।
• यह समस्या छोड़ देता है, कि रैखिक सरणी में कुछ घुमाव इनपुट के अंतिम कॉलम में अपने शीर्ष बाएं कोने के साथ स्थित होंगे। इन्हें छोड़ने के लिए, मैं ज़ीरो को निर्देश सूची में शामिल करता हूं, जैसे कि ये अमान्य 2x2 सब-ब्लॉक तकनीकी रूप से संसाधित होते हैं, लेकिन बिना ऑप के।

Answer 3

पायथन 2 , 166 159 बाइट्स

A,R=input();m=~-len(A[0])
for j,r in enumerate(R):exec r%4*"a,b,c,d=A[j/m][j%m:][:2]+A[j/m+1][j%m:][:2];A[j/m][j%m:j%m+2]=c,a;A[j/m+1][j%m:j%m+2]=b,d;"
print A

इसे ऑनलाइन आज़माएं!