Cho phép xác định ma trận không trống, chưa sắp xếp và hữu hạn với các số duy nhất như sau:

$$N = \begin{Bmatrix} 4&5&7\\1&3&6 \end{Bmatrix}$$

Cho phép xác định 4 di chuyển ma trận là:

• * (Lên): Di chuyển một cột lên
• * (Xuống): Di chuyển một cột xuống
• → * (phải): Di chuyển một hàng sang phải
• ← * (trái): Di chuyển một hàng sang trái

Dấu hoa thị (*) đại diện cho cột / hàng bị ảnh hưởng bởi việc di chuyển (Nó có thể là 0 chỉ mục hoặc 1 chỉ mục. Tùy thuộc vào bạn. Vui lòng cho biết câu nào trong câu trả lời của bạn).

---

Thách thức là, sử dụng các động tác trên, sắp xếp ma trận theo thứ tự tăng dần (là góc trên cùng bên trái thấp nhất và góc dưới bên phải cao nhất).

Thí dụ

Đầu vào:

$$N=\begin{Bmatrix}4&2&3\\1&5&6 \end{Bmatrix}$$ Đầu ra có thể: ↑0hoặc ↓0. (Lưu ý bất kỳ động thái nào trong số đó có thể sắp xếp ma trận để cả hai câu trả lời đều đúng)

---

Đầu vào:

$$N=\begin{Bmatrix}2&3&1\\4&5&6 \end{Bmatrix}$$ Đầu ra có thể:→0

---

Đầu vào (Ví dụ kiểm tra):

$$N = \begin{Bmatrix} 4&5&7\\1&3&6 \end{Bmatrix}$$ Đầu ra có thể:↑0↑1←1↑2

---

Đầu vào:

$$N = \begin{Bmatrix} 5&9&6\\ 8&2&4\\ 1&7&3 \end{Bmatrix}$$ Đầu ra có thể: ↑0↑2→0→2↑0→2↑1↑2←1

---

Đầu vào:

$$N = \begin{Bmatrix} 1 & 27 & 28 & 29 & 6 \\10 & 2 & 3 & 4 & 5 \\17 & 7 & 8 & 13 & 9 \\15 & 11 & 12 & 18 & 14 \\26 & 16 & 21 & 19 & 20 \\30 & 22 & 23 & 24 & 25 \end{Bmatrix}$$ Đầu ra có thể: ↑2↑1←3→0←3↓0←0←2→3↑3↑4

---

Đầu vào:

$$N = \begin{Bmatrix} 1 \end{Bmatrix}$$ Đầu ra: hoặc bất kỳ di chuyển nào

---

Đầu vào:

$$N = \begin{Bmatrix} 1&2\\3&4 \end{Bmatrix}$$ Đầu ra:

---

Ghi chú

• Có thể có các đầu ra chính xác khác nhau (không nhất thiết phải giống như các trường hợp thử nghiệm hoặc ngắn nhất)
• Bạn có thể cho rằng nó sẽ luôn là một cách để đặt hàng ma trận
• Các cạnh kết nối (như pacman: v)
• Sẽ không có ma trận có nhiều hơn 9 cột hoặc / và hàng
• Giả sử ma trận chỉ chứa các số nguyên duy nhất dương khác không
• Bạn có thể sử dụng bất kỳ 4 giá trị riêng biệt nào ngoài các số để biểu thị các bước di chuyển (trong trường hợp đó, vui lòng nêu rõ trong câu trả lời của bạn)
• Cột / hàng có thể là 0 hoặc 1 được lập chỉ mục
• Giành được tiêu chí đánh gôn

---

Các trường hợp kiểm tra thêm luôn được chào đón

JavaScript (ES6),  226  219 byte

Tìm kiếm lực lượng vũ phu, sử dụng di chuyển phải ( "R") và xuống ( "D").

Trả về một chuỗi mô tả các bước di chuyển hoặc một mảng trống nếu ma trận đầu vào đã được sắp xếp. Các cột và hàng trong đầu ra được lập chỉ mục 0.

f=(m,M=2)=>(g=(s,m)=>m[S='some'](p=r=>r[S](x=>p>(p=x)))?!s[M]&&m[0][S]((_,x,a)=>g(s+'D'+x,m.map(([...r],y)=>(r[x]=(m[y+1]||a)[x])&&r)))|m[S]((_,y)=>g(s+'R'+y,m.map(([...r])=>y--?r:[r.pop(),...r]))):o=s)([],m)?o:f(m,M+2)

Hãy thử trực tuyến!

Đã bình luận

f =                              // f = main recursive function taking:
(m, M = 2) => (                  //   m[] = input matrix; M = maximum length of the solution
  g =                            // g = recursive solver taking:
  (s, m) =>                      //   s = solution, m[] = current matrix
    m[S = 'some'](p =            // we first test whether m[] is sorted
      r =>                       // by iterating on each row
        r[S](x =>                // and each column
          p > (p = x)            // and comparing each cell x with the previous cell p
        )                        //
    ) ?                          // if the matrix is not sorted:
      !s[M] &&                   //   if we haven't reached the maximum length:
      m[0][S]((_, x, a) =>       //     try all 'down' moves:
        g(                       //       do a recursive call:
          s + 'D' + x,           //         append the move to s
          m.map(([...r], y) =>   //         for each row r[] at position y:
            (r[x] =              //           rotate the column x by replacing r[x] with
              (m[y + 1] || a)[x] //           m[y + 1][x] or a[x] for the last row (a = m[0])
            ) && r               //           yield the updated row
      ))) |                      //
      m[S]((_, y) =>             //     try all 'right' moves:
        g(                       //       do a recursive call:
          s + 'R' + y,           //         append the move to s
          m.map(([...r]) =>      //         for each row:
            y-- ?                //           if this is not the row we're looking for:
              r                  //             leave it unchanged
            :                    //           else:
              [r.pop(), ...r]    //             rotate it to the right
      )))                        //
    :                            // else (the matrix is sorted):
      o = s                      //   store the solution in o
)([], m) ?                       // initial call to g(); if we have a solution:
  o                              //   return it
:                                // else:
  f(m, M + 2)                    //   try again with a larger maximum length

Python 2 , 296 277 245 Python 3 , 200 194 byte

from numpy import*
def f(p):
 s='';u=[]
 while any(ediff1d(p)<0):u+=[(copy(p),s+f'v{v}',f':,{v}')for v in r_[:shape(p)[1]]]+[(p,s+'>0',0)];p,s,i=u.pop(0);exec(f'p[{i}]=roll(p[{i}],1)')
 return s

Hãy thử trực tuyến!

-19: mũi tên unicode không cần thiết ...
-32: làm lại một chút, nhưng hiệu suất trung bình chậm hơn nhiều.
-45: lấy một số cảm hứng từ câu trả lời của @ Arnauld. Đã chuyển sang Python 3 cho f''(-4 byte)
-6: range( )→r_[: ] , diff(ravel( ))→ediff1d( )

---

Tìm kiếm triệt để sự kết hợp của tất cả các ↓di chuyển có thể và →0. Lần ra về trường hợp thử nghiệm thứ ba.

Vì →ntương đương với

↓0↓1...↓(c-1) 	... repeated r-n times
→0
↓0↓1...↓(c-1)	... repeated n times

trong đó rvà clà số lượng hàng và cột, những di chuyển này là đủ để tìm mọi giải pháp.

---

from numpy import*
def f(p):
    s=''                                    #s: sequence of moves, as string
    u=[]                                    #u: queue of states to check
    while any(ediff1d(p)<0):                #while p is not sorted
        u+=[(copy(p),s+f'v{v}',f':,{v}')    #add p,↓v to queue
            for v in r_[:shape(p)[1]]]      # for all 0<=v<#columns
        u+=[(p,s+'>0',0)]                   #add p,→0
        p,s,i=u.pop(0)                      #get the first item of queue
        exec(f'p[{i}]=roll(p[{i}],1)')      #transform it
    return s                                #return the moves taken

---

>vtương ứng với →↓. (những người khác không xác định)

Thạch , 35 byte

ṙ€LXȮƊ¦1
ÇZÇZƊ⁾ULXȮOịØ.¤?F⁻Ṣ$$¿,“”Ṫ

Hãy thử trực tuyến!

Chương trình đầy đủ. Đầu ra di chuyển đến STDOUT bằng L cho trái và R cho phải. Tiếp tục thử di chuyển ngẫu nhiên cho đến khi ma trận được sắp xếp, do đó không hiệu quả về mặt tốc độ hoặc độ phức tạp thuật toán.