विचार

हमने मैट्रिक्स सर्पिल पहले, और पूर्ण घुमाव, और यहां तक कि किया है विकर्ण घुमाव हैं , लेकिन नहीं, जहां तक मैं पा सकता हूं, घोंघे के घुमाव !

सांप का घूमना क्या है?

आगे और पीछे लंबी कतार के डिवाइडर की तरह डिवाइडर के साथ एक मैट्रिक्स की पंक्तियों की कल्पना करें:

    +--------------+
      1  2  3  4  5|
    +------------  |
    |10  9  8  7  6|
    |  +-----------+
    |11 12 13 14 15|
    +------------  |
     20 19 18 17 16|
    +--------------+

अब इन वस्तुओं को 2 से घुमाने की कल्पना करें। प्रत्येक आइटम अग्रिम, जैसे लोग एक पंक्ति में आगे बढ़ रहे हैं, और अंत में आइटम बाहर फैल जाते हैं और शुरुआत में वापस आते हैं:

    +--------------+
-->  19 20  1  2  3|
    +------------  |
    | 8  7  6  5  4|
    |  +-----------+
    | 9 10 11 12 13|
    +------------  |
<--  18 17 16 15 14|
    +--------------+

यदि पंक्तियों की एक विषम संख्या है, तो यह दाईं ओर से बाहर निकलेगी, लेकिन फिर भी शुरुआत में लपेटेगी। उदाहरण के लिए, यहाँ एक 3 रोटेशन है:

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


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

एक नकारात्मक घुमाव आपको पीछे की ओर ले जाएगा। यहाँ एक -2 रोटेशन है:

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

चुनौती

आपका फ़ंक्शन या प्रोग्राम किसी भी सुविधाजनक प्रारूप में 2 इनपुट लेगा:

एक मैट्रिक्स
एक पूर्णांक (धनात्मक या ऋणात्मक) यह दर्शाता है कि इसे घुमाने के लिए कितने स्थान हैं।

यह लौटेगा:

घुमाया हुआ मैट्रिक्स

टिप्पणियाँ:

कोड गोल्फ। सबसे कम बाइट्स जीतता है।
मैट्रिक्स को चौकोर नहीं होना चाहिए, लेकिन इसमें कम से कम 2 पंक्तियाँ और 2 कॉलम होंगे
सकारात्मक पूर्णांक दाईं ओर पंक्ति 1 को घुमाएगा
नकारात्मक पूर्णांक बाईं ओर पंक्ति 1 को घुमाएंगे
आप सुविधाजनक होने पर सकारात्मक / नकारात्मक रोटेशन संख्याओं के अर्थ को उलट सकते हैं
रोटेशन संख्या मदों की संख्या से बड़ी हो सकती है। उस मामले में, यह लपेट जाएगा। यही है, यह संख्या मॉडुलो की संख्या के बराबर होगा।
मैट्रिक्स में केवल पूर्णांक शामिल होंगे, लेकिन इसमें दोहराव सहित कोई भी पूर्णांक हो सकता है

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

प्रारूप:

मैट्रिक्स
रोटेशन संख्या
प्रत्याशित वापसी मूल्य

2  3  4  5
6  7  8  9
10 11 12 13

-3

5  9  8  7
12 11 10 6
13 2  3  4

code-golf array-manipulation matrix

— जोनाह
स्रोत

4

+/- का उल्टा अर्थ ठीक है। मुझे लगता है कि प्रवेश द्वार को हालांकि ऊपर बाईं ओर रहना चाहिए।

— योना

7

यह निश्चित रूप से अजगर में एक जवाब की जरूरत है।

— 640KB

7

जेली , १० बाइट्स

UÐeẎṙṁ⁸UÐe

बाईं ओर मारीक्स और दाईं ओर रोटेशन पूर्णांक को स्वीकार करने वाला एक डाईएडिक लिंक (सकारात्मक / नकारात्मक के रिवर्स अर्थ का उपयोग करता है)

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

कैसे?

UÐeẎṙṁ⁸UÐe - Link: matrix of integers, M; integer, R
 Ðe        - apply to even indices of M:
U          -   reverse each
   Ẏ       - tighten
    ṙ      - rotate left by R
     ṁ     - mould like:
      ⁸    -   chain's left argument, M
        Ðe - apply to even indices:
       U   -   reverse each

— जोनाथन एलन
स्रोत

6

आर , 121 110 101 बाइट्स

function(m,n,o=t(m)){o[,j]=o[i<-nrow(o):1,j<-c(F,T)];o[(seq(o)+n-1)%%sum(1|o)+1]=o;o[,j]=o[i,j];t(o)}

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

पूर्वाभ्यास

function(m,n) {           # Input: m - matrix, n - shift
  o <- t(m)               # Transpose the matrix, since R works in column-major order
                          # while our snake goes in row-major order
  i <- nrow(o):1          # Take row indices in reverse
  j <- c(F,T)             # Take even column indices (FALSE, TRUE, FALSE, TRUE, ...)
  o[,j] <- o[i,j]         # "Normalize" the matrix by reversing every second column
  o[(seq(o)+n-1) %%       # Perform the shift: add n-1 to indices,
    length(o)+1] <- o     # Modulo sequence length, and +1 again
  o[,j] <- o[i,j]         # Reverse even columns again to return to snake form
  t(o)                    # Transpose the matrix back to orginal shape and return
}

— किरिल एल।
स्रोत

3

पायथन 3.8 (प्री-रिलेसेएसएस) , 119 बाइट्स

lambda m,r,n=-1:[[m[(k:=(j+(s:=r+i)//w)%h)][::n**k][s%w]for i in range(w:=len(m[0]))][::n**j]for j in range(h:=len(m))]

एक अनाम फ़ंक्शन स्वीकार matrix, rotationकरता है जो नए मैट्रिक्स का उत्पादन करता है।
विपरीत रोटेशन संकेत का उपयोग करता है।

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

कैसे?

हम n=-1बाद में कोष्ठक पर सहेजने के लिए और मैट्रिक्स को mऔर घुमाव के रूप में लेते हैंr ।

एक नए मैट्रिक्स के रूप में ही आयामों के साथ निर्माण किया है m- की चौड़ाई के साथ w( w:=len(m[0])) और की ऊंचाई h( h:=len(m))।

इस मैट्रिक्स की हर दूसरी पंक्ति उलट है ( [::n**j])।

मूल्यों को मूल mतत्व पंक्ति iऔर स्तंभ का उपयोग करके मूल में उनकी पंक्ति और स्तंभ की गणना करके देखा जाता है , j...

हमने सेट sकियाr+i और kकरने के लिए (j+s//w)%h। kहमारे वर्तमान तत्व के लिए उपयोग करने के लिए मूल की पंक्ति है।

दाईं ओर से विषम अनुक्रमित पंक्तियों को आसानी से एक्सेस करने के लिए हम उनके तत्वों (के साथ [:n**k]) तक पहुँचने से पहले ऐसी पंक्तियों को उलट देते हैं , इसका मतलब है कि ब्याज का तत्व है s%w।

— जोनाथन एलन
स्रोत

3

जे , ४१ ३० 21 बाइट्स

-11 बाइट्स जोनाह को धन्यवाद!

-9 बाइट्स FrownyFrog और ngn के लिए धन्यवाद!

$@]t@$(|.,@t=.|.@]/\)

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

औंधा +/-

— गैलेन इवानोव
स्रोत

1

30 बाइट्स, +/- उलट नहीं, लेकिन फिर भी सहायक का उपयोग करता है: $@]t@$(|.,@(t=.#\,`(|.@,)/.]))( इसे ऑनलाइन आज़माएं! )

— जोनाह

सुधार: +/- अभी भी उलट।

— योना

@ जोना अब वो J है! मुझे याद है कि आप हाल ही में प्रत्यावर्ती उलटफेर के साथ एक ही चाल को देखकर, लेकिन जाहिर तौर पर इसके बारे में भूल गए हैं। धन्यवाद! जब &.मैं कोशिश कर रहा था कि मैं हर समय बाएं तर्क को खो रहा था, इसीलिए मैंने हार मान ली।

— गैलेन इवानोव

1

21 बाइट्स , thx @ngn

— FrownyFrog

@FrownyFrog वाह, अब यह शुरुआती आकार का आधा है। मुझे बेवकूफ लग रहा है ... धन्यवाद!

— गैलेन इवानोव

2

जावास्क्रिप्ट (Node.js) , 102 बाइट्स

के रूप में इनपुट लेता है (matrix)(integer)। पूर्णांक के संकेत का अर्थ उल्टा है।

m=>n=>(g=m=>m.map(r=>r.sort(_=>~m,m=~m)))(m.map(r=>r.map(_=>a[(l+n++%l)%l]),l=(a=g(m).flat()).length))

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

हेल्पर फ़ंक्शन

$g$

g = m =>        // m[] = input matrix
  m.map(r =>    // for each row r[] in m[]:
    r.sort(_ => //   sort r[]:
      ~m,       //     using either 0 (don't reverse) or -1 (reverse)
      m = ~m    //     and toggling m before each iteration
                //     (on the 1st iteration: m[] is coerced to 0, so it yields -1)
    )           //   end of sort()
  )             // end of map()

मुख्य कार्य

m => n =>                    // m[] = matrix, n = integer
  g(                         // invoke g on the final result
    m.map(r =>               //   for each row r[] in m[]:
      r.map(_ =>             //     for each entry in r[]:
        a[(l + n++ % l) % l] //       get the rotated value from a[]; increment n
      ),                     //     end of inner map()
      l = (                  //     l is the length of a[]:
        a = g(m).flat()      //       a[] is the flatten result of g(m)
      ).length               //       (e.g. [[1,2],[3,4]] -> [[1,2],[4,3]] -> [1,2,4,3])
    )                        //   end of outer map()
  )                          // end of call to g

— Arnauld
स्रोत

2

05AB1E , 16 बाइट्स

εNFR]˜²._¹gäεNFR

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

-5 के लिए Emigna को धन्यवाद । दुर्भाग्य से, मैं यह नहीं देख सकता कि कैसे अनावश्यक भाग को बाहर निकालना है। :(

— आउटगोल्फर को एरिक करें
स्रोत

1

चारकोल , 36 बाइट्स

ＦＥθ⎇﹪κ²⮌ιιＦι⊞υκＩＥ⪪Ｅυ§υ⁻κηＬ§θ⁰⎇﹪κ²⮌ιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｅθ⎇﹪κ²⮌ιι

इनपुट की वैकल्पिक पंक्तियों को उल्टा करें।

Ｆ...Ｆι⊞υκ

सरणी को समतल करें।

Ｅυ§υ⁻κη

चपटे सरणी को घुमाएं।

⪪...Ｌ§θ⁰

सरणी को पंक्तियों में वापस विभाजित करें।

Ｅ...⎇﹪κ²⮌ιι

वैकल्पिक पंक्तियों को उलट दें।

Ｉ...

प्रत्येक प्रविष्टि को स्ट्रिंग और आउटपुट में डिफ़ॉल्ट आउटपुट प्रारूप में कनवर्ट करें जो पंक्तियों के साथ प्रति पंक्ति एक पंक्ति है, जिसमें डबल-स्पेस दिया गया है। (एक विभाजक के साथ स्वरूपण करने से विभाजक की लंबाई खर्च होती है।)

— नील
स्रोत

1

अजगर, 20 बाइट्स

L.e_W%k2bbyclQ.>syQE

इसे यहाँ ऑनलाइन आज़माएँ ।

— सोक
स्रोत

1

जाप , 28 बाइट्स

mÏ%2©XÔªX
c éV òUÎl
W©UªßV1V

कोशिश करो

पोर्ट ऑफ़ अरनल्ड का जवाब । सबसे बड़ी चुनौती एक पुन: प्रयोज्य समारोह का निर्माण करना था। विशेष रूप से, हर दूसरी पंक्ति को उलटने के लिए एक सहायक कार्य होता है। मैं जो दृष्टिकोण ले रहा हूं वह एक पुनरावर्ती कॉल करना है और इस पर निर्भर करता है कि एक चर सेट है या नहीं।

स्थानांतरित जेएस:

// U: first input argument (matrix)
// m: map it through a function
U = U.m(function(X, Y, Z) {
  // if the row index is even, don't alter it
  // if the row index is odd, reverse it (w)
  return Y % 2 && X.w() || X
});
V = U
  // flatten the matrix
  .c()
  // shift by the amount specified in second argument
  .é(V)
  // partition back to matrix
  .ò(
    // the number of columns should be the same as input
    U.g().l()
  );
// if W is specified, return the result from the first line
W && U ||
  // otherwise, make a recursive call with the shifted matrix
  rp(V, 1, V)

— दाना
स्रोत

1

पायथन 3 , 94 बाइट्स

lambda m,n:g(roll(g(m),n))
g=lambda b:[b[i][::(-1)**i]for i in r_[:len(b)]]
from numpy import*

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

जोनाथन एलन के जवाब से विषम-पंक्ति-उलट इस्तेमाल किया ।

lambda m,n:g(roll(g(m),n))  #reverse odd rows, shift elements, then reverse odd rows again.
g=lambda b:[b[i][::(-1)**i] #reverse odd rows
    for i in r_[:len(b)]]   #r_[:x] = range(x)
from numpy import*          #roll() and r_[]

— attinat
स्रोत

1

APL (Dyalog Classic) , 20 बाइट्स

↑∘t⊢∘⍴⍴⌽∘∊∘(t←⊢∘⌽\↓)

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

— NGN
स्रोत

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 141 बाइट्स

a=>n=>{for(dynamic l=a.Length,w=a.GetLength(1),i=l,j,b=a.Clone();i-->0;)a[(j=(i+n%l+l)%l)/w,j/w%2<1?j%w:w-j%w-1]=b[i/w,i/w%2<1?i%w:w-i%w-1];}

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

-5 बाइट्स कुल @someone को धन्यवाद!

एक अनाम फ़ंक्शन जो इनपुट मैट्रिक्स में इन-प्लेस संशोधन करता है।

एक एकल लूप कोशिकाओं पर निर्भर करता है। आप निम्न सूत्रों का उपयोग करके ऊपर से नीचे और बाएँ से दाएँ स्कैन कर सकते हैं:

row=i/w
col=i%w

जहां iएक लूप काउंटर है और wकॉलम की संख्या है। सांप पैटर्न में स्कैन करते समय यह थोड़ा भिन्न होता है।

row=i/w
col=i%w (0 वां, दूसरा, चौथा, आदि)
col=w-i%w-1 (पहला, 3 वां, 5 वां, आदि)

एक और बात ध्यान देने वाली यह है कि %C # में सकारात्मक मूल्य में परिवर्तित नहीं होता है, जैसा कि कुछ अन्य भाषाओं में होता है। इसके लिए कुछ अतिरिक्त बाइट्स की आवश्यकता होती है।

// a: input matrix
// n: number of cells to rotate
a=>n=>{
  for(
    // l: total number of cells
    // w: number of columns
    // i: loop index
    // j: offset index
    // b: copy of input matrix
    dynamic
      l=a.Length,
      w=a.GetLength(1),
      i=l,j,
      b=a.Clone();
    // iterate from i down to 0
    i-->0;
  )
    // calculate the offset `j` and use
    // the above formulas to index
    // into `a` for setting a value
    a[
      (j=(i+n%l+l)%l)/w,
      j/w%2<1?j%w:w-j%w-1
    ]=
    // use the un-offset index `i` and
    // the above formulas to read a
    // value from the input matrix
    b[
      i/w,
      i/w%2<1?i%w:w-i%w-1
    ];
}

— दाना
स्रोत

आप के साथ घोषणाओं को मर्ज करके 3 बाइट्स बचा सकते हैं dynamic; टिप्पणी भी एल। इसे ऑनलाइन आज़माएं!

— मेरा सर्वनाम 5

अच्छा :) यह घोषणा लूप में भी स्थानांतरित की जा सकती है। मैं varगोल्फ के लिए उपयोग करता हूं जो आपको चर की सूची घोषित नहीं करने देता है। शायद इसलिए मैं इससे चूक गया। अच्छी पकड़!

— दाना

y2 बाइट्स को बचाने के लिए पूरी तरह से छुटकारा पाएं : इसे ऑनलाइन आज़माएं!

— मेरा सर्वनाम

@someone - धन्यवाद!

— दाना

1d सरणी और चौड़ाई इनपुट के साथ TIO 135 ।

— मेरा सर्वनाम एक

स्नेक लाइक ए स्नेक

विचार

चुनौती

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

जेली , १० बाइट्स

कैसे?

आर , 121 110 101 बाइट्स

पूर्वाभ्यास

पायथन 3.8 (प्री-रिलेसेएसएस) , 119 बाइट्स

कैसे?

जे , ४१ ३० 21 बाइट्स

जावास्क्रिप्ट (Node.js) , 102 बाइट्स

हेल्पर फ़ंक्शन

मुख्य कार्य

05AB1E , 16 बाइट्स

चारकोल , 36 बाइट्स

अजगर, 20 बाइट्स

जाप , 28 बाइट्स

पायथन 3 , 94 बाइट्स

APL (Dyalog Classic) , 20 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 141 बाइट्स