मैट्रिक्स रोटेशन प्रकार

Question

निम्नलिखित के रूप में अद्वितीय संख्याओं के साथ एक गैर-खाली, अनसोल्ड और परिमित मैट्रिक्स को परिभाषित करें:

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

4 मैट्रिक्स चाल को परिभाषित करते हैं:

• ↑ * (अप): एक कॉलम को ऊपर ले जाता है
• ↓ * (नीचे): एक कॉलम को नीचे ले जाता है
• → * (दाएं): एक पंक्ति को दाईं ओर ले जाता है
• ← * (बाएं): एक पंक्ति को बाईं ओर ले जाता है

तारांकन (*) उस स्तंभ / पंक्ति का प्रतिनिधित्व करता है जो चाल से प्रभावित होता है (यह 0-अनुक्रमित या अनुक्रमित हो सकता है। आपके ऊपर। कृपया उत्तर दें कि आपके उत्तर में कौन सा है)।

---

चुनौती है, ऊपर की चालों का उपयोग करना, एक आरोही क्रम में मैट्रिक्स को क्रमबद्ध करना (सबसे ऊपर बाएं कोने में सबसे नीचे और सबसे नीचे दाएं कोने में सबसे अधिक)।

उदाहरण

$$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 अनुक्रमित हो सकती है
• मानदंड कोड-गोल्फ जीतना

---

अतिरिक्त परीक्षण मामलों का हमेशा स्वागत है

Comments

यहाँ एक वेबसाइट है जहाँ आप इन पहेलियों को स्वयं हल कर सकते हैं।

— दरवाज़े

@Doorknob जब मैं Dx को चुनौती लिख रहा था तो यह उपयोगी होगा। फिर भी धन्यवाद!

— लुइस फेलिप डी जीसस मुनोज

मुझे नहीं लगता कि आप कहीं भी कहते हैं कि दिए गए समाधान को जितना संभव हो उतना कम होना चाहिए। क्या वह जानबूझकर है? उदाहरण के लिए ←0←0दूसरे उदाहरण के लिए एक मान्य समाधान है जहाँ आपने एक समाधान दिया है →0। यदि ऐसा है, तो मुझे लगता है कि संभवतया आधे विकल्प का उपयोग नहीं किया जाएगा।

— FryAmTheEggman

सम्बंधित? codegolf.stackexchange.com/questions/172824/…

— सुमेर

इसके अलावा कुछ लोग carykh नामक एक youtuber द्वारा बनाये गए openprocessing.org/sketch/580366 को आज़माना चाह सकते हैं । इसे "लूपओवर" कहा जाता है

— गैरेथ मा

Answer 1

जावास्क्रिप्ट (ईएस 6),  226  219 बाइट्स

सही ( "R") और नीचे ( "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

Comments

अच्छा जवाब। क्या आप जानते हैं कि क्या इसके लिए एक कुशल अहंकार मौजूद है, या यदि समाधान की अधिकतम संख्या निर्धारित करना संभव है, तो समाधान के बिना क्रूरता हो सकती है?

— जोनाह

@ जोनाहा यहां एक समाधान का वर्णन करने और चाल की संख्या के ऊपरी हिस्से को देने वाला एक पेपर है। ( यह चुनौती भी देखें जो मूल रूप से एक अलग जीत की कसौटी के साथ एक ही काम है।)

— अरनौल

वाह, शुक्रिया @Arnauld

— योना

Answer 2

पायथन 2 , 296 277 245 पायथन 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: @ अरनुलद के जवाब से कुछ प्रेरणा ली। पायथन 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के अनुरूप क्रमशः →↓। (अन्य अपरिभाषित)

Answer 3

जेली , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पूरा कार्यक्रम। आउटपुट बाएँ के लिए L और R के दाईं ओर स्थित STDOUT का उपयोग करता है। मैट्रिक्स को हल करने तक यादृच्छिक चाल की कोशिश करता रहता है, इसलिए गति या एल्गोरिथम जटिलता के मामले में बहुत कुशल नहीं है।