ความคิด

เราทำเมทริกซ์เกลียววนมาก่อนและหมุนเต็มรูปแบบและหมุนวนในแนวทแยงแต่ไม่เท่าที่ฉันจะหาได้การหมุนของงู !

การหมุนของงูคืออะไร?

ลองนึกภาพแถวของเมทริกซ์ที่กระโดดไปมาด้วยตัวแบ่งระหว่างพวกมันเหมือนกับตัวหารของคิวยาว:

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

ลิงก์ dyadic ยอมรับ marix ทางด้านซ้ายและจำนวนเต็มการหมุนทางด้านขวา (ใช้ความหมายกลับด้านเป็นบวก / ลบ)

ลองออนไลน์!

อย่างไร?

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 (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ล่วงหน้าที่จะบันทึกในวงเล็บต่อมาและใช้เมทริกซ์เป็นและการหมุนเป็นmr

เมทริกซ์ใหม่ถูกสร้างขึ้นด้วยมิติเดียวmกับ - ที่มีความกว้างของw( w:=len(m[0])) และความสูงเป็นh(h:=len(m) )

แถวอื่น ๆ ของเมทริกซ์นี้จะกลับด้าน ( [::n**j])

ค่าจะถูกค้นหาโดยการคำนวณแถวและคอลัมน์ในต้นฉบับmโดยใช้แถวองค์ประกอบปัจจุบันiและคอลัมน์j...

เราตั้งsไปr+iและจะk เป็นแถวของต้นฉบับเพื่อเข้าถึงองค์ประกอบปัจจุบันของเรา(j+s//w)%hk

เพื่อให้สามารถเข้าถึงได้อย่างง่ายดายแถวจัดทำดัชนีแปลกจากขวาแถวที่เราย้อนกลับดังกล่าวก่อนที่จะเข้าถึงองค์ประกอบของพวกเขา (กับ[:n**k]) s%wนี้หมายถึงองค์ประกอบที่น่าสนใจอยู่ที่

J , 41 30 21 ไบต์

-11 ไบต์ขอบคุณ Jonah!

-9 ไบต์ขอบคุณ FrownyFrog & ngn!

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

ลองออนไลน์!

ย้อนกลับ +/-

JavaScript (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$ ใช้เพื่อ 'snakify' หรือ 'unsnakify' matrix โดยการกลับแถวที่ดัชนีคี่

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

ลองออนไลน์!

ขอบคุณEmignaสำหรับ -5 น่าเสียดายที่ฉันไม่สามารถเห็นวิธีการลอกส่วนที่ซ้ำซ้อนออก :(

ถ่าน , 36 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｅθ⎇﹪κ²⮌ιι

สลับแถวสำรองของอินพุต

Ｆ...Ｆι⊞υκ

แผ่อาร์เรย์

Ｅυ§υ⁻κη

หมุนอาร์เรย์ที่แบน

⪪...Ｌ§θ⁰

แยกอาร์เรย์กลับเป็นแถว

Ｅ...⎇﹪κ²⮌ιι

สลับแถวสำรอง

Ｉ...

แปลงแต่ละรายการเป็นสตริงและเอาท์พุทในรูปแบบเอาต์พุตเริ่มต้นซึ่งเป็นหนึ่งหมายเลขต่อบรรทัดโดยเว้นสองแถว (การจัดรูปแบบด้วยตัวคั่นจะทำให้ค่าความยาวของตัวแยก)

Pyth, 20 ไบต์

L.e_W%k2bbyclQ.>syQE

ลองออนไลน์ได้ที่นี่

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

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

APL (Dyalog Classic)ขนาด 20 ไบต์

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

ลองออนไลน์!

C # (Visual C # Interactive คอมไพเลอร์) , 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, 2, 4 และอื่น ๆ )
• col=w-i%w-1 (แถวที่ 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
    ];
}