ให้กำหนดเมทริกซ์ที่ไม่ว่างเปล่าไม่ได้แยกและ จำกัด ด้วยจำนวนที่ไม่ซ้ำดังนี้:

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

ให้นิยามการเคลื่อนที่แบบ 4 เมทริกซ์เป็น:

• ↑ * (ขึ้น): เลื่อนคอลัมน์ขึ้น
• ↓ * (ลง): เลื่อนคอลัมน์ลง
• → * (ขวา): เลื่อนแถวไปทางขวา
• ← * (ซ้าย): เลื่อนแถวไปทางซ้าย

เครื่องหมายดอกจัน (*) หมายถึงคอลัมน์ / แถวที่ได้รับผลกระทบจากการย้าย (สามารถเป็นดัชนี 0 หรือดัชนี 1 ขึ้นอยู่กับคุณโปรดระบุว่าหนึ่งในคำตอบของคุณ)

---

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

ตัวอย่าง

การป้อนข้อมูล:

$$N=\begin{Bmatrix}4&2&3\\1&5&6 \end{Bmatrix}$$ ขาออกเป็นไปได้: หรือ↑0 ↓0(สังเกตว่าการเคลื่อนไหวใด ๆ เหล่านั้นสามารถเรียงลำดับเมทริกซ์ได้ดังนั้นคำตอบทั้งคู่จึงถูกต้อง)

---

อินพุต:

$$N=\begin{Bmatrix}2&3&1\\4&5&6 \end{Bmatrix}$$ เอาต์พุตที่เป็นไปได้:→0

---

อินพุต (ตัวอย่างกรณีทดสอบ):

$$N = \begin{Bmatrix} 4&5&7\\1&3&6 \end{Bmatrix}$$ เอาต์พุตที่เป็นไปได้:↑0↑1←1↑2

---

อินพุต:

$$N = \begin{Bmatrix} 5&9&6\\ 8&2&4\\ 1&7&3 \end{Bmatrix}$$ เอาต์พุตที่เป็นไปได้: ↑0↑2→0→2↑0→2↑1↑2←1

---

$$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}$$ ↑2↑1←3→0←3↓0←0←2→3↑3↑4

---

$$N = \begin{Bmatrix} 1 \end{Bmatrix}$$

---

$$N = \begin{Bmatrix} 1&2\\3&4 \end{Bmatrix}$$

---

หมายเหตุ

• อาจมีเอาต์พุตที่ถูกต้องแตกต่างกัน (ไม่จำเป็นต้องเหมือนกันกับกรณีทดสอบหรือสั้นที่สุด)
• คุณสามารถสมมติว่ามันจะเป็นวิธีการสั่งซื้อเมทริกซ์เสมอ
• ขอบเชื่อมต่อ (เช่น pacman: v)
• จะไม่มีเมทริกซ์ที่มีมากกว่า 9 คอลัมน์หรือ / และแถว
• สมมติว่าเมทริกซ์มีเฉพาะจำนวนเต็มไม่เป็นศูนย์บวก
• คุณสามารถใช้ 4 ค่าที่แตกต่างนอกเหนือจากตัวเลขเพื่อแสดงการเคลื่อนไหว (ในกรณีนั้นโปรดระบุว่าในคำตอบของคุณ)
• คอลัมน์ / แถวสามารถทำดัชนีได้ 0 หรือ 1
• เกณฑ์การชนะรหัส - กอล์ฟ

---

กรณีทดสอบเพิ่มเติมยินดีต้อนรับเสมอ

JavaScript (ES6),  226  219 ไบต์

ค้นหากำลังดุร้ายโดยใช้การเคลื่อนไหวright ( "R") และdown ( "D")

ส่งคืนสตริงที่อธิบายถึงการย้ายหรืออาร์เรย์ว่างถ้าเมทริกซ์อินพุตถูกเรียงลำดับแล้ว คอลัมน์และแถวในผลลัพธ์ถูกทำดัชนี 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)

ลองออนไลน์!

แสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

-19: ไม่จำเป็นต้องใช้ลูกศรยูนิโคด ...
-32: ทำใหม่เล็กน้อย แต่ประสิทธิภาพโดยเฉลี่ยช้ากว่ามาก
-45: รับแรงบันดาลใจจากคำตอบของ @ Arnauld เปลี่ยนเป็น Python 3 สำหรับf''(-4 ไบต์)
-6: range( )→r_[: ] , diff(ravel( ))→ediff1d( )

---

ค้นหาอย่างละเอียดถี่ถ้วนการรวมกันของเป็นไปได้ทั้งหมดย้ายและ↓ →0หมดเวลาในกรณีทดสอบที่สาม

เนื่องจาก→nเทียบเท่า

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

โดยที่rและcเป็นจำนวนแถวและคอลัมน์การเคลื่อนไหวเหล่านี้เพียงพอที่จะค้นหาวิธีแก้ปัญหาทั้งหมด

---

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

---

>v→↓สอดคล้องตามลำดับ (คนอื่นไม่ได้กำหนด)

เยลลี่ 35 ไบต์

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

ลองออนไลน์!

โปรแกรมเต็มรูปแบบ เอาต์พุตย้ายไปที่ STDOUT โดยใช้ L สำหรับซ้ายและ R ทางขวา พยายามสุ่มย้ายจนกว่าเมทริกซ์จะถูกจัดเรียงจึงไม่มีประสิทธิภาพมากนักในแง่ของความเร็วหรือความซับซ้อนของอัลกอริทึม