Ide

Kami telah melakukan spiral matriks sebelumnya, dan rotasi penuh, dan bahkan rotasi diagonal , tetapi sejauh ini saya tidak bisa, rotasi ular !

Apa itu rotasi ular?

Bayangkan deretan matriks yang bolak-balik, dengan pembagi di antara mereka seperti pembagi antrian panjang:

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

Sekarang bayangkan memutar item-item ini dengan 2. Setiap item bergerak maju, seperti orang-orang bergerak dalam satu baris, dan item-item di ujung tumpah dan kembali ke awal:

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

Jika ada jumlah ganjil dari baris itu akan keluar dari kanan, tetapi masih membungkus ke awal. Sebagai contoh, ini adalah 3 rotasi:

    +--------------+
      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  -->
    +--------------+

Rotasi negatif akan membawa Anda mundur. Ini rotasi -2:

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

Tantangan

Fungsi atau program Anda akan mengambil 2 input, dalam format apa pun yang nyaman:

• Sebuah matriks
• Integer (positif atau negatif) yang menunjukkan berapa banyak tempat untuk memutarnya.

Itu akan kembali:

• Matriks yang diputar

Catatan:

• Golf kode. Bytes paling sedikit menang.
• Matriks tidak harus persegi, tetapi akan mengandung setidaknya 2 baris dan 2 kolom
• Bilangan bulat positif akan memutar baris 1 ke kanan
• Bilangan bulat negatif akan memutar baris 1 ke kiri
• Anda dapat membalikkan arti angka rotasi positif / negatif, jika nyaman
• Jumlah rotasi bisa lebih besar dari jumlah item. Dalam hal ini, itu akan dibungkus. Artinya, itu akan setara dengan jumlah modulo jumlah item.
• Matriks hanya akan berisi bilangan bulat, tetapi mungkin berisi bilangan bulat apa pun, termasuk pengulangan

Uji Kasus

Format:

• Matriks
• Nomor rotasi
• Nilai pengembalian yang diharapkan

4 5
6 7

1

6 4
7 5

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 

8 8 7 7
5 5 6 6

10

5 5 8 8
6 6 7 7

Jelly , 10 byte

UÐeẎṙṁ⁸UÐe

Link diad yang menerima marix di sebelah kiri dan integer rotasi di sebelah kanan (menggunakan makna terbalik positif / negatif)

Cobalah online!

Bagaimana?

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

R , 121 110 101 byte

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)}

Cobalah online!

Panduan

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
}

Python 3.8 (pra-releasSSSse) , 119 byte

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))]

Fungsi yang tidak disebutkan namanya menerima matrix, rotationyang menghasilkan matriks baru.
Menggunakan tanda rotasi yang berlawanan.

Cobalah online!

Bagaimana?

Kami mengatur n=-1dimuka untuk menghemat tanda kurung nanti dan mengambil matriks sebagai mdan rotasi sebagai r.

Matriks baru dibangun dengan dimensi yang sama dengan m- dengan lebar w( w:=len(m[0])) dan tinggi h( h:=len(m)).

Setiap baris lain dari matriks ini dibalik ( [::n**j]).

Nilai-nilai dicari dengan menghitung baris dan kolom mereka di aslinya, mmenggunakan baris elemen saat ini i,, dan kolom, j...

Kami mengatur ske r+idan kke (j+s//w)%h. kadalah deretan dokumen asli untuk mengakses elemen kami saat ini.

Agar dapat dengan mudah mengakses baris aneh yang diindeks dari kanan, kami membalikkan baris tersebut sebelum mengakses elemennya (dengan [:n**k]), ini berarti elemen yang diminati adalah s%w.

J , 41 30 21 byte

-11 byte, terima kasih untuk Jonah!

-9 byte, terima kasih kepada FrownyFrog & ngn!

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

Cobalah online!

Terbalik +/-

JavaScript (Node.js) , 102 byte

Mengambil input sebagai (matrix)(integer). Arti tanda bilangan bulat terbalik.

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))

Cobalah online!

Fungsi pembantu

Fungsi pembantu $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()

Fungsi utama

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

05AB1E , 16 byte

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

Cobalah online!

Terima kasih kepada Emigna untuk -5. Sayangnya, saya tidak bisa melihat bagaimana cara golf bagian yang berlebihan keluar. :(

Arang , 36 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｅθ⎇﹪κ²⮌ιι

Membalikkan baris alternatif input.

Ｆ...Ｆι⊞υκ

Ratakan array.

Ｅυ§υ⁻κη

Putar array yang rata.

⪪...Ｌ§θ⁰

Membagi array kembali menjadi baris.

Ｅ...⎇﹪κ²⮌ιι

Membalikkan baris alternatif.

Ｉ...

Konversi setiap entri ke string dan output dalam format output default yang merupakan satu angka per baris dengan baris spasi ganda. (Memformat dengan pemisah akan memakan biaya panjang pemisah.)

Pyth, 20 byte

L.e_W%k2bbyclQ.>syQE

Cobalah online di sini .

Japt , 28 byte

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

Cobalah

Jawaban Port of Arnauld . Tantangan terbesar adalah menciptakan fungsi yang dapat digunakan kembali. Secara khusus, ada fungsi pembantu untuk membalik setiap baris lainnya. Pendekatan yang saya ambil adalah membuat panggilan rekursif dan tergantung pada apakah variabel diatur.

JS yang dialihkan:

// 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)

Python 3 , 94 byte

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

Cobalah online!

Menggunakan pembalikan baris ganjil dari jawaban Jonathan Allan .

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_[]

APL (Dyalog Classic) , 20 byte

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

Cobalah online!

C # (Visual C # Interactive Compiler) , 141 byte

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];}

Cobalah online!

-5 total byte berkat @someone!

Fungsi anonim yang melakukan modifikasi di tempat ke matriks input.

Satu loop berulang di atas sel. Anda dapat memindai dari atas ke bawah dan dari kiri ke kanan menggunakan rumus berikut:

• row=i/w
• col=i%w

Di mana ipenghitung lingkaran dan wjumlah kolom. Ini sedikit bervariasi saat memindai dalam pola ular.

• row=i/w
• col=i%w (Baris ke-0, ke-2, ke-4, dll.)
• col=w-i%w-1 (Baris 1, 3, 5, dll.)

Hal lain yang perlu diperhatikan adalah bahwa %di C # tidak dikonversi ke nilai positif seperti di beberapa bahasa lain. Diperlukan beberapa byte tambahan untuk menjelaskan hal ini.

// 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
    ];
}