चुनौती

के n x nसाथ पूर्णांकों के एक मैट्रिक्स को देखते हुएn >= 2

१ २
३ ४

और बिल्कुल 2nतत्वों के साथ पूर्णांकों की एक सूची

[1,2, -3, -1]

घुमाया गया मैट्रिक्स आउटपुट। यह मैट्रिक्स निम्नलिखित तरीके से सम्‍मिलित है:

सूची में पहला पूर्णांक लें और इस मान से दाईं ओर पहली पंक्ति घुमाएं।
अगला पूर्णांक लें और इस मान से पहला कॉलम नीचे घुमाएँ।
अगला पूर्णांक लें और दूसरी पंक्ति को इस मान से दाईं ओर घुमाएं, आदि जब तक कि आप मैट्रिक्स की हर पंक्ति और स्तंभ को एक बार घुमा नहीं लेते।

सूची में नकारात्मक पूर्णांक हो सकते हैं, जिसका अर्थ है कि आप पंक्ति / कॉलम को दाएं / नीचे के बजाय बाएं / ऊपर शिफ्ट करते हैं। यदि पूर्णांक शून्य है, तो पंक्ति / स्तंभ को घुमाएँ नहीं।

ऊपर दिए गए इनपुट का उपयोग करके उदाहरण

सूची तत्व मैट्रिक्स स्पष्टीकरण
-------------------------------------------------- ----------
1 2 1 1 से दाईं ओर पहली पंक्ति घुमाएँ
                   ३ ४

2 2 1 1 कॉलम को 2 से नीचे घुमाएँ
                   ३ ४

-3 2 1 3 से बाईं ओर 2 पंक्ति घुमाएँ
                   ४ ३

-1 2 3 1 से 2 कॉलम ऊपर घुमाएँ
                   ४ १

नियम

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

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

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

[[१,२], [३,४]], [१,२, ३, -१] -> [[२,३], [३,१]]
[[१,२], [३,४]], [११,१,११] -> [[३,२], [४,१]]
[[१,२], [३,४]], [०,०,०,०] -> [[१,२], [३,४]]
[[1,2, -3], [- 4,5,6], [7, -8,0]], [1, -2,0, -1,3,4] -> [[7, 5,0], [- 3, -8,2], [- 4,1,6]]
[[1,2, -3], [- 4,5,6], [7, -8,0]], [3,12, -3,0, -6, -3] -> [[1 , 2, -3], [- 4,5,6], [7, -8,0]]

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

code-golf array-manipulation matrix

— Denker
स्रोत

Mapcar को मदद करनी चाहिए ...

— msh210

6

सीजेएम, 13 बाइट्स

{{a.m>1m<z}/}

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

सभी परीक्षण मामलों को चलाएं।

एक ही विचार, एक ही बाइट गिनती, विभिन्न कार्यान्वयन:

{{\(@m>a+z}/}
{{(Im>a+z}fI}
{{:\Im>]z}fI}

व्याख्या

आदर्श रूप से हम सूची के प्रत्येक निर्देश को एक ही मानना चाहते हैं, और इसका उपयोग मैट्रिक्स की पहली पंक्ति को घुमाने के लिए करते हैं। यह प्रत्येक निर्देश के बाद मैट्रिक्स को परिवर्तित करके और आसानी से किया जा सकता है और यह सुनिश्चित कर सकता है कि अंत में उन सभी अतिरिक्त परिवर्तनों को रद्द कर दिया जाए। इसलिए प्रत्येक निर्देश को संसाधित करने के बाद, हम सभी पंक्तियों को एक ऊपर घुमाते हैं (जैसे कि समान आयाम के साथ अगला निर्देश अगली पंक्ति को संसाधित करता है) और फिर मैट्रिक्स को स्थानांतरित करता है, जैसे कि हम वास्तव में स्तंभों को संसाधित कर रहे हैं। ये अतिरिक्त परिवर्तन सूची में दिए गए निर्देशों के लिए रूढ़िवादी हैं और ठीक उसी समय की अवधि है 2n, जैसा हमें चाहिए।

कोड के लिए के रूप में:

{      e# For each instruction...
  a    e#   Wrap it in a singleton array.
  .m>  e#   Combine it element-wise with the matrix to rotate right. This is
       e#   a fairly common idiom to apply a binary operation only to the first
       e#   element of an array, since element-wise operations just retain all the
       e#   unpaired elements of the longer array.
  1m<  e#   Rotate the rows one up.
  z    e#   Transpose.
}/

— मार्टिन एंडर
स्रोत

4

एपीएल (डायलॉग एक्सटेंडेड) , १ 14 १५ १४ १३ बाइट्स

Adám द्वारा -3 बाइट्स

(⍉1⊖⌽`@1⍢⌽)/⌽

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

इनपुट को एक सूची के रूप में लेता है जहां पहला तत्व मैट्रिक्स है, और शेष तत्व रोटेशन मात्रा हैं। यदि If बाएं के बजाय दाईं ओर घुमाया जाता है, तो यह CJam को हरा देगा।

(⍉1⊖⌽@1 1⍢⌽)/⌽    Monadic train:
(⍉1⊖⌽@1 1⍢⌽)      Helper function to rotate and transpose once.
                        Takes args ⍺ (amount to rotate) and ⍵ (current array)
     ⌽                 Function to rotate left
        1 1             2-element vector containing 1.
                        The second 1 is redundant, but saves 1 byte over (,1).
     ⌽@1 1             Function to rotate the 1st row left by ⍺.
     ⌽@1 1⍢⌽          Reverse ⍵, rotate 1st row left by ⍺, then reverse again.
                        This rotates the first row of ⍵ to the *right*.
  1⊖                   Rotate all the rows upward,
 ⍉                                                 then transpose.
(⍉1⊖⌽@1 1⍢⌽)/⌽   Fold (/) this function over the reversed input.
                     If our input is ⍵, ⍺_1, ⍺_2, ..., ⍺_2n,
                     the reversed input will be ⍺_2n, ..., ⍺_1, ⍵.
                     The / operator applies the function right to left,
                     so the ⌽ is necessary.

— lirtosiast
स्रोत

{⍉1⊖⌽⍺⌽@(⍳1)⌽⍵}→ (⍉1⊖⌽@(⍳1)⍢⌽)लेकिन आप क्यों मुझे समझा सकते हैं @1के बजाय काम नहीं करेगा @(⍳1)या @(,1)? इसके अलावा, ओपी आपको रिवर्स में इनपुट लेने की अनुमति दे सकता है।

— 10

तो यह पता चला है कि dfns ' atजो कि विस्तार के पीछे @है, एक संगत विस्तार नहीं है। हालाँकि, आप मूल का उपयोग कर सकते हैं जिसके @साथ `@1एक बाइट की बचत होती है @1 1।

— आदम

A बनाम बनाम J में बारी बारी से काम करता है? मैं इसे जे में अनुवाद करने की कोशिश कर रहा हूं और इसे बहुत अधिक क्रियाशील पा रहा हूं ...

— योना

2

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

def f(m,v):
    for i,x in enumerate(v):x%=len(m);r=m[i/2];m[i/2]=r[-x:]+r[:-x];m=zip(*m)
    return m

टेस्ट

ftuples की सूची देता है। फ़ंक्शन बॉडी में प्रत्येक पंक्ति 1 टैब वर्ण के साथ इंडेंट की जाती है।

— vaultah
स्रोत

एक सीधे return zip(*m)आप 5 बाइट्स बचा नहीं होगा ?

— डेनकर

@DenkerAffe: क्या आप m=zip(*m);return mबस के साथ बदलने का सुझाव दे रहे हैं return zip(*m)? मैं ऐसा नहीं कर सकता क्योंकि लूप m=zip(*m)का एक हिस्सा हैfor

— vaultah

हाँ, हालांकि यह मेरा था। यह नहीं देखा कि पाश में है, मेरा बुरा है।

— डेनकर

0

स्टैक्स , 12 बाइट्स

ÄBí•`»O╒┬g½ë

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

हर पंक्ति और स्तंभ को एक मैट्रिक्स में घुमाएं