इन कोशिकाओं को समूहित करें!

Question

यह चुनौती लेयरेज़ खेल पर आधारित है ।

यह देखते हुए, स्टड पर या एक फ़ंक्शन तर्क के रूप में, कोशिकाओं का एक 2 डी आयताकार सरणी जहां प्रत्येक सेल में एक खाली होता है (आप बिना किसी दंड के रिक्त स्थान के 0 का उपयोग करना चुन सकते हैं), 1, 2, 3, या 4। ; इसे वैध क्षेत्रों में विभाजित करने का एक तरीका खोजें (जैसा कि नीचे परिभाषित किया गया है) जैसे कि प्रत्येक गैर-रिक्त सेल बिल्कुल एक क्षेत्र द्वारा निहित है। फिर, किसी भी उचित प्रारूप में पाए गए समाधान का उत्पादन करें। यदि कोई समाधान नहीं है, तो उत्पादन या उत्पादन को रोकने के बिना या तो एक फॉल्सी मूल्य को रोकें।

निम्नलिखित में से कोई एक वैध क्षेत्र बनाता है:

• एक एकल कक्ष जिसमें 1 है
• एक सेल जिसमें 2 और इसके गैर-रिक्त ओर्थोगोनल पड़ोसियों में से एक है
• एक सेल जिसमें 3 और इसके दो गैर-रिक्त ओर्थोगोनल पड़ोसी हैं
• एक सेल जिसमें 4 और उसके तीन गैर-रिक्त ओर्थोगोनल पड़ोसी हैं

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम वैध उत्तर, जीतता है।

कुछ परीक्षण मामले:

1. बल्कि एक तुच्छ:

और यह एक अलग रंग में प्रत्येक क्षेत्र के साथ समाधान है:

2. एक और दिलचस्प एक

यह एक से अधिक समाधान है, लेकिन यहाँ उनमें से एक है:

3. एक छोटा एक, जिसमें रिक्त स्थान होता है, जिसका कोई समाधान नहीं होता है (इस पर निर्भर करता है कि आप दो में से दो को लेने के लिए दो में से एक का उपयोग करते हैं या दो में से दो लेने के लिए तीन में से एक है, आप या तो एक के साथ बचे हैं अगोचर की जोड़ी [और इसलिए गैर-ज्वलनशील] दो या अपने आप एक एकल))

क्योंकि इस ग्रिड का कोई समाधान नहीं है, इसलिए इस ग्रिड को दिए जाने पर आपके प्रोग्राम को किसी भी आउटपुट का उत्पादन किए बिना रोकना चाहिए।

4. इस एक (शीर्ष 2 के साथ एक सेल को बाईं ओर स्थानांतरित) के पास हालांकि एक समाधान है:

उपाय:

(नीचे दाईं ओर 2 का प्रयोग 3 पर "कब्जा" करने के लिए किया जाता है)

5. क्योंकि हमें कुछ चौकों के साथ टेस्ट केस की जरूरत थी:

एक हल:

Comments

यह उपयोगी होगा यदि परीक्षण के मामलों के ASCII संस्करण थे, ताकि लोगों को उन सभी को टाइप करने की आवश्यकता न हो, और 4यदि वे वैध इनपुट हैं , तो परीक्षण मामलों को भी कवर करना चाहिए ।

— मार्टिन एंडर

क्या ऑर्थोगोनल पड़ोसियों का मतलब केवल दाएं बाएं, या विकर्ण भी है? यदि केवल दाईं ओर नीचे छोड़ दिया जाता है, तो कैसे 3 अन्य दो 3 के समान क्षेत्र में आता है? उनमें से एक पड़ोसी नहीं है।

— ईयाल लेव

@ ईयालव केवल बाएं-दाएं-ऊपर-नीचे। शीर्ष दाएं 3 और उसके 2 पड़ोसी क्षेत्र का गठन करते हैं।

— SuperJedi224

@ SuperJedi224 शीर्ष दाएं 3 और यह दो पड़ोसी एक वैध क्षेत्र का गठन करते हैं, हां, लेकिन वे पड़ोसी नहीं करते हैं। क्या किसी क्षेत्र में "बंद सेट" नहीं होना चाहिए? अर्थात क्षेत्र का प्रत्येक सदस्य उस क्षेत्र का वैध सदस्य होना चाहिए?

— ईयाल लेव

Answer 1

मुझे पता है कि यह चुनौती एक साल से अधिक पुरानी है, लेकिन मैंने इसे "अनुत्तरित" में पाया और मुझे काफी दिलचस्प लगा।

यह मानते हुए कि "रूट" सेल की संख्या प्रत्येक क्षेत्र में एकमात्र महत्वपूर्ण है (उदाहरणों के अनुसार), यहां मेरा बैकट्रैकिंग समाधान है:

पायथन 3 , 355 351 349 बाइट्स

from itertools import*
def f(a):
 D=len(a[0])+1;S={D*r+c for r in range(len(a))for c in range(D-1)if a[r][c]};s=[{x,*t}for x in S for t in combinations({x-D,x-1,x+1,x+D}&S,a[x//D][x%D]-1)]
 def B(s,S,d=1):
  if{0}>S:return a
  if[]==s:return 0
  h,*t=s
  if h<=S:
   for x in h:a[x//D][x%D]=d
  return h<=S and B(t,S-h,d+1)or B(t,S,d)
 return B(s,S)

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

इनपुट प्रारूप पूर्णांकों की एक 2 डी सूची है, शून्य के रूप में रिक्त है, और आउटपुट स्वरूप पूर्णांक की 2 डी सूची भी है जो एक संख्या के साथ एक क्षेत्र का प्रतिनिधित्व करता है। क्षेत्र संख्या एक पर शुरू होती है; शून्य रिक्त कोशिकाओं (इनपुट के अनुसार) के लिए आरक्षित है। यदि दिया गया इनपुट असाध्य है, तो फ़ंक्शन सिंगल जीरो (मिथ्या मूल्य) लौटाता है।

उदाहरण के लिए, टेस्ट केस 5 इनपुट है

[[2,3,2],
 [3,4,3],
 [0,4,0],
 [3,3,3],
 [2,3,2],
 [0,3,0]]

और आउटपुट है

[[1,1,1],
 [2,2,2],
 [0,2,0],
 [3,4,5],
 [3,4,5],
 [0,4,0]]

टिप्पणियों के साथ असंगठित:

from itertools import*
def f(a):
 # Rows, cols, fake-cols to prevent neighbors wrap around
 R,C=len(a),len(a[0]);D=C+1
 # All valid cells represented as integers
 S={D*r+c for r in range(R) for c in range(C) if a[r][c]}
 # All valid regions rooted at each cell
 s=[{x,*t} for x in S for t in combinations({x-D,x-1,x+1,x+D}&S,a[x//D][x%D]-1)]
 # Start backtracking
 return backtrack(a,s,S,D)

# a: array to fill in the region numbers
# s: current candidates of regions
# S: current remaining cells to cover
# D: constant from f
# d: recursion depth == group number in the result
def backtrack(a,s,S,D,d=1):
 # Empty S: the board is correctly covered, return the result
 if not S:return a
 # Empty s: no more candidate regions to use, return false
 if not s:return 0
 h,*t=s
 # h is not a subset of S: h is not a valid cover, try with the rest using same depth
 if not h<=S:return backtrack(a,t,S,D,d)
 # h is a valid cover, write d to the cells in h
 for x in h:a[x//D][x%D]=d
 return backtrack(a,t,S-h,D,d+1)or backtrack(a,t,S,D,d)
 

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

नोट: यह सेट पैकिंग का एक विशेष मामला है जिसे एनपी-पूर्ण होने के लिए जाना जाता है। इस विशिष्ट समस्या में सीमित आकार का आकार (अधिकतम 4) है और बहुपद समय में "अच्छा" सेट पैकिंग खोजने के लिए सन्निकटन एल्गोरिदम मौजूद है, लेकिन वे अधिकतम संभव सेट पैकिंग की गारंटी नहीं देते हैं (जो इस समस्या में कड़ाई से आवश्यक है)।