रुबिक-छँटाई एक मैट्रिक्स (उर्फ टोरस पहेली)

16

इस कोड-चुनौती के लिए विचार सरल है: पूर्णांक का एक मैट्रिक्स दिया गया है, चलो इसे रुबिक-शैली के आंदोलनों को लागू करके क्रमबद्ध करें। इसका मतलब है कि आप किसी एक पंक्ति या स्तंभ का चयन कर सकते हैं और उसके तत्वों को किसी भी दिशा में घुमा सकते हैं:

[1, 3, 2, 4]  => [3, 2, 4, 1] (rotate left for rows/up for columns)
[1, 3, 2, 4]  => [4, 1, 3, 2] (rotate right for rows/down for columns)

इसलिए, किसी भी आयाम के पूर्णांक का एक मैट्रिक्स दिया गया है, केवल इन रूबिक-शैली परिवर्तनों को लागू करने वाले तत्वों को छाँटें। एक मैट्रिक्स

[ए1 1ए12ए13ए14ए21ए22ए23ए24ए31ए32ए33ए34]

माना जाएगा कि क्या उसके तत्व निम्नलिखित प्रतिबंधों का पालन करते हैं:

ए1 1≤ए12≤ए13≤ए14≤ए21≤ए22≤ए23≤ए24≤ए31≤ए32≤ए33≤ए34

आई / ओ

  • इनपुट पॉजिटिव पूर्णांकों का एक मैट्रिक्स होगा जिसमें कोई दोहराया हुआ मान नहीं होगा।
  • आउटपुट इसे सॉर्ट करने के लिए आवश्यक मूवमेंट होगा। जैसा कि यह एक कोड गोल्फ चुनौती नहीं है और आपको इसकी लंबाई के बारे में चिंता करने की आवश्यकता नहीं है, हर आंदोलन के लिए प्रस्तावित प्रारूप वह है #[UDLR]जहां #स्थानांतरित करने के लिए पंक्ति या स्तंभ की संख्या (0-अनुक्रमित) है और इसमें [UDLR]एक एकल वर्ण है वह सीमा जो निर्दिष्ट करता है कि आंदोलन ऊपर (नीचे) (कॉलम के लिए) है या बाएं / दाएं (पंक्तियों के लिए)। तो 1Uइसका मतलब होगा "1-वें कॉलम को ऊपर की ओर 1Rले जाना " लेकिन "1-वें पंक्ति को दाईं ओर ले जाना" होगा। आंदोलनों को अल्पविराम से अलग किया जाएगा, इसलिए एक समाधान इस तरह व्यक्त किया जाएगा 1R,1U,0L,2D:।

स्कोरिंग

मैट्रिक्स को इस तरह से सॉर्ट करने की कोशिश करना महंगा हो सकता है क्योंकि इसमें कई तरह के संभावित संयोजन होते हैं, और इसमें कई तरह की संभावित सूचियाँ भी होती हैं जो इसे सॉर्ट कर सकती हैं, इसलिए लक्ष्य कुछ कोड लिखना है जो N * को टाइप करते हैं। नीचे एन मैट्रिसेस। स्कोर सबसे बड़ा आकार एन होगा जिसे आप त्रुटियों के बिना 1 समय की उचित मात्रा में हल कर सकते हैं (मैट्रिक्स का आकार जितना अधिक होगा, उतना बेहतर)। एक टाई के मामले में, टाई-ब्रेकर आपके पाया पथ में आंदोलनों की संख्या (कम पथ, बेहतर) होगा।

उदाहरण: यदि कोई उपयोगकर्ता A = N = 5 के लिए समाधान खोजता है और B N = 6 के लिए कोई समाधान खोजता है, तो B दोनों रास्तों की लंबाई की परवाह किए बिना जीत जाता है। यदि वे दोनों N = 6 के लिए समाधान खोजते हैं, लेकिन A द्वारा पाए गए समाधान में 50 चरण हैं और B के समाधान में 60 चरण हैं, तो A जीत जाता है।

आपके कोड कैसे काम करते हैं, इस बारे में स्पष्टीकरण दिया गया है और कृपया प्राप्त किए गए समाधानों को पोस्ट करें ताकि हम उनका परीक्षण कर सकें । यदि समाधान बहुत बड़े हैं, तो आप पास्टबिन या इसी तरह के उपकरणों का उपयोग कर सकते हैं । साथ ही, आपके समाधान खोजने के लिए आपके कोड द्वारा खर्च किए गए समय का एक अनुमान की सराहना की जाएगी।

परीक्षण के मामलों

निम्नलिखित मैट्रिसेस ( अधिक कॉपी-पेस्ट करने योग्य संस्करण के लिए पास्टबिन लिंक ) बनाया गया है जो पहले से छँटे हुए मैट्रिसेस से शुरू करके उन्हें 10K रैंडम, रुबिक-शैली के आंदोलनों के साथ जोड़कर बनाया गया है:

[8561 110131513]
[211012161762214851926132431]
[11381659402126221 124143928321937310301736734]
[342140223541183331301243191 13924282344136538451417916132683476254]
[20361711550187267341032355424396306139284154272357048132512465863523784533146859655673606422]
[85565275894441682715879132373973676419997846164221631004172131197309328403365070258058960845496172943342335776182482943866]
[567990617112211031551 144284851306188443386611324962010275685888098351007713216410810601144023472731068232120263653936910454191111176217278873349155811695112571189151426545]

प्लेनटेक्स्ट टेस्ट मामले:

[[8, 5, 6], [11, 10, 1], [3, 15, 13]]

[[21, 10, 12, 16], [17, 6, 22, 14], [8, 5, 19, 26], [13, 24, 3, 1]]

[[1, 13, 8, 16, 5], [9, 40, 21, 26, 22], [11, 24, 14, 39, 28], [32, 19, 37, 3, 10], [30, 17, 36, 7, 34]]

[[34, 21, 40, 22, 35, 41], [18, 33, 31, 30, 12, 43], [19, 11, 39, 24, 28, 23], [44, 1, 36, 5, 38, 45], [14, 17, 9, 16, 13, 26], [8, 3, 47, 6, 25, 4]]

[[20, 36, 17, 1, 15, 50, 18], [72, 67, 34, 10, 32, 3, 55], [42, 43, 9, 6, 30, 61, 39], [28, 41, 54, 27, 23, 5, 70], [48, 13, 25, 12, 46, 58, 63], [52, 37, 8, 45, 33, 14, 68], [59, 65, 56, 73, 60, 64, 22]]

[[85, 56, 52, 75, 89, 44, 41, 68], [27, 15, 87, 91, 32, 37, 39, 73], [6, 7, 64, 19, 99, 78, 46, 16], [42, 21, 63, 100, 4, 1, 72, 13], [11, 97, 30, 93, 28, 40, 3, 36], [50, 70, 25, 80, 58, 9, 60, 84], [54, 96, 17, 29, 43, 34, 23, 35], [77, 61, 82, 48, 2, 94, 38, 66]]

[[56, 79, 90, 61, 71, 122, 110, 31, 55], [11, 44, 28, 4, 85, 1, 30, 6, 18], [84, 43, 38, 66, 113, 24, 96, 20, 102], [75, 68, 5, 88, 80, 98, 35, 100, 77], [13, 21, 64, 108, 10, 60, 114, 40, 23], [47, 2, 73, 106, 82, 32, 120, 26, 36], [53, 93, 69, 104, 54, 19, 111, 117, 62], [17, 27, 8, 87, 33, 49, 15, 58, 116], [95, 112, 57, 118, 91, 51, 42, 65, 45]]

कृपया और अधिक पूछें यदि आप उन सभी को हल करते हैं। :-) और उन लोगों के लिए बहुत धन्यवाद जिन्होंने मुझे सैंडबॉक्स में रहते हुए इस चुनौती को परिष्कृत करने में मदद की ।

1 समय की एक उचित राशि: समय की कोई भी राशि जो आपके समाधान का परीक्षण करते समय हमारे धैर्य को कम नहीं करती है। ध्यान दें कि TIO केवल 60 सेकंड के लिए कोड चलाता है, उस सीमा से अधिक समय तक हमें अपनी मशीनों में कोड का परीक्षण करना होगा। उदाहरण: मेरे बजाय अक्षम एल्गोरिथ्म क्रम 3x3 और 4x4 के मैट्रिक्स को हल करने के लिए कुछ मिलीसेकंड लेता है, लेकिन मैंने इसे सिर्फ 5x5 मैट्रिक्स के साथ परीक्षण किया है और इसे हल करने में 317 सेकंड का समय लगा (5 मिलियन से अधिक आंदोलनों में, बहुत ही अजीब अगर हम समझते हैं कि मैट्रिक्स को हल करने के लिए केवल 10K बार स्क्रैम्बल किया गया था )। मैंने आंदोलनों की संख्या को 10K से कम करने की कोशिश की, लेकिन मैंने कोड निष्पादित करने के 30 मिनट बाद आत्मसमर्पण कर दिया।

code-challenge  array-manipulation  sorting  rubiks-cube 
— चार्ली
स्रोत
1
अच्छी चुनौती! हालाँकि, मेरे कुछ अनुरोध / प्रश्न हैं: 1) क्या आप परीक्षण मामलों को अधिक कॉपी-पेस्ट फ्रेंडली प्रारूप में प्रदान कर सकते हैं? (जैसे pastebin) 2) क्या आप समय सीमा आदेश की अधिक सटीक परिभाषा प्रदान कर सकते हैं? 3) क्या मैट्रिक्स को वर्गाकार होने की गारंटी है? (परीक्षण मामलों का सुझाव है, लेकिन परिभाषा नहीं है।)
— अरनौल्ड
@ अरण्युलद 1) मैं इस पर कायम हूं। 2) मैं समय सीमा स्थापित नहीं करना चाहता था, और सैंडबॉक्स में चुनौती होने पर किसी ने कोई सीमा नहीं सुझाई। यदि आपको एक की आवश्यकता है, तो क्या आप 30 मिनट को एक उचित सीमा मानेंगे? 3) हाँ, टेस्ट मैट्रीज़ दिखाए गए हैं, और यदि आवश्यक हो तो वे सभी वर्ग होंगे।
— चार्ली
इस चुनौती के लिए ओ (इनपुट आकार) एल्गोरिदम लागू करने के लिए एक अपेक्षाकृत आसान मौजूद है, इसलिए यह उतना दिलचस्प नहीं है जितना कि यह पहले दिख सकता है।
— user202729
@ user202729 आपके O(input size)समय में इनपुट-आकार क्या होगा ? 5x5 मैट्रिक्स के लिए यह होगा O(25)? यह बहुत तेज़ प्रतीत होता है, इसलिए मुझे उस एल्गोरिथ्म या आपके कार्यान्वयन को देखने के लिए बहुत दिलचस्पी होगी। संपादित करें: आप महसूस करते हैं कि हम 'तले हुए' मैट्रिक्स को इनपुट करते हैं और आंदोलनों को आउटपुट करते हैं, है ना? कोई और रास्ता नही।
— केविन क्रूज़सेन
4
मुझे लगता है, यह इस एल्गोरिथ्म की
— किरिल एल।

जवाबों:

8

निम

import algorithm, math, sequtils, strutils

let l = split(stdin.readLine())
var m = map(l, parseInt)
let n = int(sqrt(float(len(m))))
let o = sorted(m, system.cmp[int])

proc rotations(P, Q: int): tuple[D, L, R, U: string, P, Q: int]=
  result = (D: "D", L: "L", R: "R", U: "U", P: P, Q: Q)
  if P > n - P:
    result.D = "U"
    result.U = "D"
    result.P = n - P
  if Q > n - Q:
    result.L = "R"
    result.R = "L"
    result.Q = n - Q

proc triangle(r: int): string=
  let p = r div n
  let q = r mod n
  let i = find(m, o[r])
  let s = i div n
  let t = i mod n
  var u = s
  var v = q
  if s == p and t == q:
    return ""
  var patt = 0
  if p == s: 
    u = s + 1
    patt = 4
  elif q == t:
    if q == n - 1:
      v = t - 1
      patt = 8
    else:
      u = p
      v = t + 1
      patt = 3
  elif t > q:
    patt = 2
  else:
    patt = 7
  var Q = abs(max([q, t, v]) - min([q, t, v]))
  var P = abs(max([p, s, u]) - min([p, s, u]))
  let x = p*n + q
  let y = s*n + t
  let z = u*n + v
  let w = m[x]
  m[x] = m[y]
  m[y] = m[z]
  m[z] = w
  let R = rotations(P, Q)

  result = case patt:
    of 2:
      repeat("$#$#," % [$v, R.D], R.P) & 
        repeat("$#$#," % [$u, R.L], R.Q) &
        repeat("$#$#," % [$v, R.U], R.P) & 
        repeat("$#$#," % [$u, R.R], R.Q)
    of 3:
      repeat("$#$#," % [$q, R.U], R.P) & 
        repeat("$#$#," % [$p, R.L], R.Q) &
        repeat("$#$#," % [$q, R.D], R.P) & 
        repeat("$#$#," % [$p, R.R], R.Q)
    of 4:
      repeat("$#$#," % [$p, R.L], R.Q) & 
        repeat("$#$#," % [$q, R.U], R.P) &
        repeat("$#$#," % [$p, R.R], R.Q) & 
        repeat("$#$#," % [$q, R.D], R.P)
    of 7:
      repeat("$#$#," % [$v, R.D], R.P) & 
        repeat("$#$#," % [$u, R.R], R.Q) &
        repeat("$#$#," % [$v, R.U], R.P) & 
        repeat("$#$#," % [$u, R.L], R.Q)
    of 8:
      repeat("$#$#," % [$s, R.R], R.Q) & 
        repeat("$#$#," % [$t, R.D], R.P) &
        repeat("$#$#," % [$s, R.L], R.Q) & 
        repeat("$#$#," % [$t, R.U], R.P)
    else: ""

proc Tw(p, t, P, Q: int): string =
  let S = P + Q
  result = "$#D,$#$#U,$#$#D,$#$#U," % [
    $t, if P > n - P: repeat("$#L," % $p, n - P) else: repeat("$#R," % $p, P),
    $t, if S > n - S: repeat("$#R," % $p, n - S) else: repeat("$#L," % $p, S), 
    $t, if Q > n - Q: repeat("$#L," % $p, n - Q) else: repeat("$#R," % $p, Q), 
    $t]

proc line(r: int): string=
  let p = n - 1
  let q = r mod n
  let i = find(m, o[r])
  var t = i mod n
  if t == q: 
    return ""
  let j = t == n - 1
  var P = t - q
  let x = p*n + q
  let y = x + P
  let z = y + (if j: -1 else: 1)
  let w = m[x]
  m[x] = m[y]
  m[y] = m[z]
  m[z] = w
  if j:
    let R = rotations(1, P)
    result = "$#D,$#$#U,$#$#R,$#D,$#L,$#U," % [
      $t, repeat("$#$#," % [$p, R.R], R.Q), 
      $t, repeat("$#$#," % [$p, R.L], R.Q), 
      $p, $t, $p, $t]
  else:
    result = Tw(p, t, P, 1)  
  
proc swap: string=
  result = ""
  if m[^1] != o[^1]:
    m = o
    for i in 0..(n div 2-1):
      result &= Tw(n - 1, n - 2*i - 1, 1, 1)
    result &= "$#R," % $(n - 1)
  
var moves = ""
for r in 0..(n^2 - n - 1):
  moves &= triangle(r)
if n == 2 and m[^1] != o[^1]:
  m = o
  moves &= "1R"
else:
  for r in (n^2 - n)..(n^2 - 3):
    moves &= line(r)
  if n mod 2 == 0:
    moves &= swap()
  if len(moves) > 0:
    moves = moves[0..^2]
  
echo moves

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

टोरोस पहेली समाधान एल्गोरिदम को एल्गोरिदम 2012, 5, 18-29 में प्रकाशित एक लेख से लागू करने का एक त्वरित प्रयास जिसे मैंने टिप्पणियों में उल्लेख किया है।

स्पेस-सीमांकित संख्याओं की एक पंक्ति के रूप में चपटे रूप में इनपुट मैट्रिक्स को स्वीकार करता है।

यहाँ पायथन 2 में एक सत्यापनकर्ता भी है । यह इनपुट के रूप में दो लाइनें लेता है: मुख्य कोड के रूप में मूल रूप से तले हुए मैट्रिक्स, और चालों के प्रस्तावित अनुक्रम। सत्यापनकर्ता का आउटपुट इन चालों को लागू करने से उत्पन्न मैट्रिक्स है।

व्याख्या

एल्गोरिथ्म के पहले भाग में, हम पिछले एक को छोड़कर सभी पंक्तियों का आदेश देते हैं।

हम "त्रिभुज घुमाव" की श्रृंखला का प्रदर्शन करके ऐसा करते हैं ( proc triangle) - चाल के अनुक्रम जो केवल तीन कोशिकाओं की अदला-बदली वाले स्थानों में परिणाम करते हैं, और शेष सभी अपरिवर्तित रहते हैं। हम निर्देशांक साथ प्रत्येक "लगातार" काम कर रहे सेल को लेते हैं , फिर उस सेल को खोजते हैं जिसमें वर्तमान में वह संख्या है जिसे जाना चाहिए , और एक तीसरे बिंदु का चयन करके सही त्रिकोण को पूरा करना चाहिए। कुछ पैटर्न के अनुसार, जैसा कि जुड़े लेख के चित्र ४ में दिखाया गया है।[पी,क्ष][रों,टी][पी,क्ष][यू,v]

अंजीर। 2 में, लेखक 8 संभावित पैटर्न और चालों के अनुरूप क्रम प्रस्तुत करते हैं, लेकिन मेरे कोड में सभी मामलों को वास्तव में केवल 5 पैटर्न द्वारा कवर किया गया है, ताकि नं। 1, 5, और 6 का उपयोग नहीं किया जाता है।

दूसरे भाग में, दो अंतिम तत्वों को छोड़कर अंतिम पंक्ति को एक पंक्ति ( proc line) पर "तीन तत्व घुमाव" प्रदर्शन करके आदेश दिया जाता है , जिसमें दो त्रिभुज घुमाव प्रत्येक होते हैं (देखें लेख का चित्र 3)।

[पी,क्ष][रों,टी][रों,टी+1]टीडब्ल्यूटीटी+1[रों,टी-1]टीडब्ल्यू

nnटीडब्ल्यू=आरproc swapटीडब्ल्यू

n=21आर

अद्यतन: नया जोड़ा गया proc rotationsजो चालों की दिशा को उलट देता है यदि परिणाम कम चरणों में होता है।

— किरिल एल।
स्रोत
प्रभावशाली! मैं तब कुछ और परीक्षण मामले बनाऊंगा। इस बीच, मुझे यकीन है कि इस समाधान को ऑप्टिमाइज़ किया जा सकता है, क्योंकि इसमें चंक्स 7L,7L,7L,7L,7D,7D,7D,7Dकम किए जा सकते हैं और 9x9 मैट्रिक्स के लिए 8R,8R,8R,8R,8R,8R,8Rपरिवर्तित किए जा सकते हैं 8L,8L।
— चार्ली
मैंने आपके एल्गोरिथ्म को 100x100 मैट्रिक्स के साथ आज़माया है और यह 4 सेकंड से भी कम समय में हल कर देता है। मैं वास्तव में इस समस्या को एक रेखीय समय समाधान की उम्मीद नहीं थी। मैं भविष्य में बेहतर चुनौतियों को लिखने की कोशिश करूँगा!
— चार्ली
हो सकता है कि इस चुनौती को एकल, निश्चित मैट्रिक्स के साथ एकमात्र परीक्षण मामले के रूप में प्रस्तुत करना बेहतर होता, और इसे हल करने के लिए मिली हुई राह का आकार निर्धारित करने के लिए जीतने की कसौटी निर्धारित करें, क्या मुझे पहले पता था कि यह समस्या एक ओ थी। (एन ^ 2) समाधान। क्या आप इस सवाल के जवाब को ऐसे विजयी मानदंड के साथ पेश करने पर विचार करेंगे?
— चार्ली
@Charlie जबकि मैं अभी भी वर्तमान समाधान को थोड़ा परिष्कृत करने की कोशिश करूंगा, मुझे वास्तव में कोई पता नहीं है, समग्र पथ अनुकूलन समस्या से कैसे निपटा जाए ...
— Kirill L.
5

पायो 2 , TIO पर <30 सेकंड में आकार 100

import random
def f(a):
 d = len(a)
 r = []
 def V(j, b = -1):
  b %= d
  if d - b < b:
   for k in range(d - b):
    if r and r[-1] == "U%d" % j:r.pop()
    else:r.append("D%d" % j)
    b = a[-1][j]
    for i in range(len(a) - 1):
     a[-1 - i][j] = a[-2 - i][j]
    a[0][j] = b
  else:
   for k in range(b):
    if r and r[-1] == "D%d" % j:r.pop()
    else:r.append("U%d" % j)
    b = a[0][j]
    for i in range(len(a) - 1):
     a[i][j] = a[i + 1][j]
    a[-1][j] = b
 def H(i, b = -1):
  b %= d
  if d - b < b:
   for k in range(d - b):
    if r and r[-1] == "L%d" % i:r.pop()
    else:r.append("R%d" % i)
    a[i] = a[i][-1:] + a[i][:-1]
  else:
   for k in range(b):
    if r and r[-1] == "R%d" % i:r.pop()
    else:r.append("L%d" % i)
    a[i] = a[i][1:] + a[i][:1]
 b = sorted(sum(a, []))
 for i in range(d - 1):
  for j in range(d):
   c = b.pop(0)
   e = sum(a, []).index(c)
   if e / d == i:
    if j == 0:H(i, e - j)
    elif j < e % d:
     if i:
      V(e % d, 1)
      H(i, j - e)
      V(e % d)
      H(i, e - j)
     else:
      V(e)
      H(1, e - j)
      V(j, 1)
   else:
    if j == e % d:
     H(e / d)
     e += 1
     if e % d == 0:e -= d
    if i:
     V(j, i - e / d)
    H(e / d, e - j)
    V(j, e / d - i)
 c = [b.index(e) for e in a[-1]]
 c = [sum(c[(i + j) % d] < c[(i + k) % d] for j in range(d) for k in range(j)) % 2 and d * d or sum(abs(c[(i + j) % d] - j) for j in range(d)) for i in range(d)]
 e = min(~c[::-1].index(min(c)), c.index(min(c)), key = abs)
 H(d - 1, e)
 for j in range(d - 2):
  e = a[-1].index(b[j])
  if e > j:
   c = b.index(a[-1][j])
   if c == e:
    if e - j == 1:c = j + 2
    else:c = j + 1
   V(e)
   H(d - 1, j - e)
   V(e, 1)
   H(d - 1, c - j)
   V(e)
   H(d - 1, e - c)
   V(e, 1)
 return r

इसे ऑनलाइन आज़माएं! लिंक में पूर्ण चालन आउटपुट के साथ तीन छोटे परीक्षण मामले शामिल हैं, साथ ही यह दिखाने के लिए कि कोड काम करता है (चाल उत्पादन TIO की सीमा से अधिक होगा) यह दिखाने के लिए 100x100 की एक मूक परीक्षा। स्पष्टीकरण: कोड सरणी पर सम्मिलन प्रकार का प्रदर्शन करने का प्रयास करता है, इसे बढ़ते हुए क्रम में बनाता है। अंतिम पंक्ति को छोड़कर सभी पंक्तियों के लिए, कई मामले हैं:

  • तत्व सही पंक्ति में है, लेकिन स्तंभ 0. में है। इस मामले में, इसे केवल 0 तक पहुंचने तक घुमाया जाता है।
  • तत्व सही जगह पर है। इस मामले में, कुछ भी नहीं होता है। (यह भी सच है यदि तत्व कॉलम 0 में है, यह केवल 0 घुमाव है जो उस स्थिति में होता है।)
  • तत्व शीर्ष पंक्ति में है लेकिन गलत कॉलम में है। उस स्थिति में, इसे नीचे घुमाया जाता है, फिर क्षैतिज रूप से जब तक तत्व सही स्तंभ में नहीं होता है, तब तक फिर से घुमाया जाता है।
  • तत्व सही पंक्ति में है लेकिन गलत कॉलम में है। उस स्थिति में, इसे घुमाया जाता है, फिर पंक्ति को इसके स्तंभ पर घुमाया जाता है, फिर इसे नीचे घुमाया जाता है, फिर पंक्ति को पीछे घुमाया जाता है। (प्रभावी रूप से यह अगले मामले का एक रोटेशन है।)
  • तत्व सही कॉलम में है लेकिन गलत पंक्ति में है। उस स्थिति में, पंक्ति को दाईं ओर घुमाया जाता है, ताकि इसे अंतिम मामले में कम किया जा सके।
  • तत्व गलत पंक्ति और गलत कॉलम में है। इस स्थिति में, सही स्तंभ गलत पंक्ति (शीर्ष पंक्ति के लिए छोड़ दिया गया) पर घुमाया जाता है, उस पंक्ति को फिर सही स्तंभ पर घुमाया जाता है, और फिर स्तंभ को वापस घुमाया जाता है।

उपरोक्त घुमाव जो भी दिशा में किया जाता है वह चरणों की संख्या को कम करता है; आकार 2 वर्ग हमेशा बाईं और ऊपर की चाल का उपयोग करके हल किया जाता है, ऊपर दिए गए विवरण की परवाह किए बिना।

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

निचली पंक्ति के लिए एल्गोरिथ्म एक 7-ऑपरेशन अनुक्रम पर निर्भर करता है जो तीन स्तंभों में तत्वों का आदान-प्रदान करता है। अनुक्रम नीचे पंक्ति के शेष संख्या में से प्रत्येक पर लागू किया जाता है ताकि उन्हें उनके वांछित स्थान पर लाया जा सके; यदि संभव हो तो उस स्थान के तत्व को उसके इच्छित स्थान पर ले जाया जाता है, लेकिन अगर एक सीधे स्वैप की आवश्यकता होती है, तो तत्व को केवल निकटतम उपलब्ध कॉलम में ले जाया जाता है, उम्मीद है कि इसे अगली बार ठीक किया जा सकता है।

— नील
स्रोत
आपके उत्तर के लिए बहुत बहुत धन्यवाद, नील! लेकिन याद रखें, यह एक कोड गोल्फ नहीं है। कोड की लंबाई के बजाय आपको उस NxN मैट्रिक्स का सबसे बड़ा आकार N इंगित करना चाहिए जिसे आपने हल किया है और उस मैट्रिक्स को हल करने के लिए आंदोलनों की सूची की लंबाई।
— चार्ली
@Charlie खैर, यह 6 है, लेकिन केवल क्योंकि मैं बहुत बड़े मैट्रिक्स में पेस्ट करने के लिए बहुत आलसी रहा हूं। हालांकि यह क्रूर बल है, यह क्षेत्र के साथ रैखिक रूप से तराजू है, इसलिए यह बड़े मैट्रिक्स में सक्षम होना चाहिए।
— नील
वास्तव में, सबसे खराब स्थिति क्षेत्र के साथ द्विघात हो सकती है।
— नील
1
@Charlie TIO लिंक अब एक यादृच्छिक 100x100 मैट्रिक्स हल करता है।
— नील
1
@Charlie मैं अब नीचे पंक्ति के लिए एक प्रमुख अनुकूलन के साथ आया हूं, लेकिन मुझे लगता है कि यह आखिरी बदलाव है जो मैं इस उत्तर के लिए करने जा रहा हूं।
— नील
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.