बराबर क्षेत्र के भागों में एक वर्ग ग्रिड का विभाजन

Question

यह चुनौती निम्नलिखित पहेली पर आधारित है: आप nद्वारा दिए गए हैंn ग्रिडn चिह्नित कोशिकाओं के साथ । आपका काम ग्रिड को उन nहिस्सों में विभाजित करना है, जहां प्रत्येक भाग में बिल्कुल nकोशिकाएं होती हैं, प्रत्येक में बिल्कुल एक चिह्नित सेल होता है।

उदाहरण

यहाँ बाईं ओर एक पहेली है और दाईं ओर इसका (अनोखा) हल:

चुनौती

आपको nकिसी भी उचित प्रारूप में शून्य-अनुक्रमित निर्देशांक का एक सेट दिया जाएगा ।

[(0,0), (0,3), (1,0), (1,1), (2,2)]

और आपका काम एक ऐसा प्रोग्राम लिखना है जो किसी भी मान्य प्रतिमान (फिर, किसी भी उचित प्रारूप में) को लौटाता है।

[
  [(0,0), (0,1), (0,2), (1,2), (1,3)],
  [(0,3), (0,4), (1,4), (2,4), (3,4)],
  [(1,0), (2,0), (3,0), (4,0), (4,1)],
  [(1,1), (2,1), (3,1), (3,2), (4,2)],
  [(2,2), (2,3), (3,3), (4,3), (4,4)]
]

यदि पहेली का कोई हल नहीं है, तो प्रोग्राम को संकेत देना चाहिए कि त्रुटि फेंकने या खाली समाधान वापस करने से।

इनपुट / आउटपुट उदाहरण

[(0,0)]               => [[(0,0)]]

[(0,0), (1,1)]        => [
                          [(0,0), (1,0)], 
                          [(0,1), (1,1)]
                         ]

[(0,0), (0,1), (1,0)] => [] (no solution)

[(0,0), (0,1), (0,2)] => [
                          [(0,0), (1,0), (2,0)], 
                          [(0,1), (1,1), (2,1)],
                          [(0,2), (1,2), (2,2)],
                         ]

[(0,0), (0,2), (1,2)] => [
                          [(0,0), (1,0), (2,0)], 
                          [(0,1), (0,2), (1,1)],
                          [(1,2), (2,1), (2,2)],
                         ]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

Comments

यह इस मैथ स्टैक एक्सचेंज प्रश्न से प्रेरित था ।

— पीटर केजी

@ अर्नुलड, यह शिक्कू पहेली के लिए दिखता है, "इसका उद्देश्य ग्रिड को आयताकार और चौकोर टुकड़ों में विभाजित करना है"। इस मामले में, ऐसी कोई अड़चन नहीं है।

— पीटर केजी

गलतफहमी के लिए खेद है। मुझे लगता है कि सैंडबॉक्स में कहीं न कहीं एक Shikaku चुनौती हो सकती है, या शायद मैं किसी बिंदु पर खुद को बनाने की योजना बना रहा हूं - मुझे यकीन नहीं है। किसी भी तरह से, मुझे लगा कि यह पहली नज़र में एक ही बात थी।

— अरनौलद

परिणाम निर्देशांक का 2d सरणी क्यों है? मुझे समझ नहीं आ रहा है कि वहाँ क्या व्यक्त किया जा रहा है ... क्या यह सरणी के सूचकांक का 2d सरणी नहीं हो सकता है? उदाहरण के लिए पंक्ति 3, कॉलम 2 में 4 इंडेक्स पर निर्देशांक के साथ विभाजन होता है?

— ओलिवियर ग्रेजायर

क्या हम मान सकते हैं कि संदर्भ निर्देशांक से शुरू करके प्रत्येक क्षेत्र को खींचा जा सकता है, जैसा कि उदाहरण से पता चलता है? मुझे सिर्फ एहसास हुआ है कि मैंने अनजाने में इसे लिया है।

— अरनौलद

Answer 1

जावास्क्रिप्ट (ईएस 7), 166 बाइट्स

पूर्णांक के एक मैट्रिक्स को आउटपुट करता है जो विभाजन का वर्णन करता है, या $false$

a=>(m=a.map(_=>[...a]),g=(n,X,Y,j=0,i)=>a[n]?a[j]?m.some((r,y)=>r.some((v,x)=>++v|(X-x)**2+(Y-y)**2-1?0:g(r[x]=n,x,y,j+1,i|x+[,y]==a[n])?1:r[x]=v)):i&&g(n+1):1)(0)&&m

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

कैसे?

$m$$N\times N$$N$

m = a.map(_ => [...a])

$m$$N$$m$++

$g$$n$$(X,Y)$$j$$i$

g = (n, X, Y, j = 0, i) => a[n] ? a[j] ? ... : i && g(n + 1) : 1

हम परीक्षण करते हैं $a[n]$$a[j]$

$g$$m$ उन सभी पर पुनरावृत्ति करके भरने के लिए है:

m.some((r, y) =>          // for each row r[] at position y in m[]:
  r.some((v, x) =>        //   for each cell of value v at position x in r[]:
    ++v |                 //     if this cell is already filled (i.e. v is numeric)
    (X - x) ** 2 +        //     or the squared Euclidean distance between
    (Y - y) ** 2 -        //     (X, Y) and (x, y)
    1 ?                   //     is not equal to 1:
      0                   //       this is an invalid target square: do nothing
    :                     //     else:
      g(                  //       do a recursive call to g:
        r[x] = n,         //         pass n unchanged and fill the cell with n
        x, y,             //         pass the coordinates of the current cell
        j + 1,            //         increment j
        i |               //         update i:
        x + [,y] == a[n]  //         set it if (x, y) = a[n]
      ) ?                 //       if the result of the call is truthy:
        1                 //         return 1
      :                   //       else:
        r[x] = v          //         reset the cell to NaN
  )                       //   end of inner map()
)                         // end of outer map()