아이디어

우리는 전에 매트릭스 나선, 전체 회전, 심지어 대각선 회전 을 수행했지만 뱀 회전 은 찾을 수 없습니다 !

뱀 회전이란 무엇입니까?

행렬의 행이 앞뒤로 스 네이 핑하는 것을 상상해보십시오.

    +--------------+
      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 행을 왼쪽으로 회전시킵니다.
• 편리한 경우 양수 / 음수 회전의 의미를 반대로 바꿀 수 있습니다.
• 회전 수는 항목 수보다 클 수 있습니다. 이 경우 랩핑됩니다. 즉, 수 모듈로의 수와 항목 수에 해당합니다.
• 행렬에는 정수만 포함되지만 반복을 포함하여 모든 정수가 포함될 수 있습니다.

테스트 사례

체재:

• 매트릭스
• 회전 수
• 기대 값

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

젤리 , 10 바이트

UÐeẎṙṁ⁸UÐe

왼쪽의 마 릭스와 오른쪽의 회전 정수를 받아들이는 2 차원 링크 (양수 / 음수의 반대 의미 사용)

온라인으로 사용해보십시오!

방법?

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 바이트

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
}

Python 3.8 (pre-releasSSSse) , 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.

J , 41 30 21 바이트

Jonah 덕분에 -11 바이트!

FrownyFrog & ngn 덕분에 -9 바이트!

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

온라인으로 사용해보십시오!

반전 +/-

자바 스크립트 (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

05AB1E , 16 바이트

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

온라인으로 사용해보십시오!

-5의 Emigna 에게 감사합니다 . 불행히도 중복 부분을 골라내는 방법을 알 수 없습니다. :(

숯 , 36 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｅθ⎇﹪κ²⮌ιι

입력의 대체 행을 반전시킵니다.

Ｆ...Ｆι⊞υκ

배열을 평평하게합니다.

Ｅυ§υ⁻κη

평평한 배열을 회전시킵니다.

⪪...Ｌ§θ⁰

배열을 다시 행으로 나눕니다.

Ｅ...⎇﹪κ²⮌ιι

대체 행을 반대로 바꿉니다.

Ｉ...

각 항목을 문자열로 변환하고 행이 두 줄 간격으로 줄당 하나의 숫자 인 기본 출력 형식으로 출력하십시오. 구분자로 서식을 지정하면 구분자 길이가 길어집니다.

Pyth, 20 바이트

L.e_W%k2bbyclQ.>syQE

여기에서 온라인으로 사용해보십시오 .

apt , 28 바이트

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

시도 해봐

항구 Arnauld의 대답 . 가장 큰 과제는 재사용 가능한 기능을 만드는 것이 었습니다. 특히, 다른 모든 행을 반대로하는 도우미 함수가 있습니다. 내가 취하는 접근법은 변수가 설정되었는지 여부에 따라 재귀 호출을하는 것입니다.

번역 된 JS :

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

파이썬 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*

온라인으로 사용해보십시오!

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 바이트

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

온라인으로 사용해보십시오!

C # (Visual C # 대화식 컴파일러) , 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];}

온라인으로 사용해보십시오!

@someone 덕분에 총 5 바이트!

입력 행렬을 전체적으로 수정하는 익명 함수입니다.

단일 루프는 셀을 반복합니다. 다음 공식을 사용하여 위에서 아래로, 왼쪽에서 오른쪽으로 스캔 할 수 있습니다.

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

i루프 카운터는 어디에 있고 w열의 수입니다. 이것은 뱀 패턴으로 스캔 할 때 약간 다릅니다.

• row=i/w
• col=i%w (0, 2, 4 등)
• col=w-i%w-1 (1, 3, 5 등)

주목해야 할 또 다른 사항은 %C # 의 in이 다른 언어에서와 같이 양수 값으로 변환되지 않는다는 것입니다. 이를 설명하기 위해 몇 바이트가 더 필요합니다.

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