क्या आप डॉट्स कनेक्ट कर सकते हैं?

Question

यह चुनौती फ्लो फ्री पर आधारित है। एक ऑनलाइन संस्करण यहां पाया जा सकता है: http://www.moh97.us/

आपको एक पहेली दी जाएगी, और 1यदि पहेली हल करने योग्य है, या नहीं 0तो आपको वापस लौटना होगा ।

एक पहेली को हल करने के लिए, खिलाड़ी को प्रत्येक खाली वर्ग का उपयोग करते हुए प्रत्येक जोड़ी संख्या को एक बार जोड़ने के लिए एक पथ बनाना होगा।

आप वर्ग के आयामों में पारित हो जाते हैं, और फिर प्रत्येक डॉट के x, y, c (जहां c एक संख्या है जो रंग का प्रतिनिधित्व करता है)। उदाहरण के लिए:

यदि 5,5 0,0,0 3,0,1 1,1,2 1,2,2 4,2,1 4,4,0आप के लिए पारित किया गया था, यह प्रतिनिधित्व करेगा:

0..1.
.2...
.2..1
....0

और 1 वापस करना चाहिए।

---

यहाँ कुछ और परीक्षण समस्याएं हैं:

5,2 2,0,1 0,1,2 4,1,2 का प्रतिनिधित्व करता है:

..1..
2...2

और सॉल्व नहीं है क्योंकि केवल 1 है 1।

4,2 0,0,0 3,0,0 0,1,0 3,1,0 का प्रतिनिधित्व करता है:

0..0
0..0

और सॉल्व करने योग्य नहीं है क्योंकि इसमें 2 से अधिक 0एस शामिल हैं।

8,6 0,0,1 7,5,1 का प्रतिनिधित्व करता है:

1.......
........
........
........
........
.......1

और सॉल्व नहीं है (जैसा कि आप हर वर्ग का उपयोग नहीं कर सकते हैं)।

2,5 0,0,1 2,0,6 4,0,6 0,1,4 3,1,4 4,1,1 का प्रतिनिधित्व करता है:

1.6.6
4..41

और सॉल्व नहीं है क्योंकि आप 1s को कनेक्ट नहीं कर सकते हैं।

6,3 1,0,4 5,0,1 0,1,4 1,1,3 5,1,3 0,2,2 3,2,2 5,2,1 का प्रतिनिधित्व करता है:

.4...1
43...3
2..2.1

और सॉल्व नहीं है क्योंकि आप 1s (या 3s) को कनेक्ट नहीं कर सकते हैं, क्योंकि दो रास्तों को आवश्यक रूप से पार करना चाहिए।

5,2 0,0,1 3,0,1 0,1,3 4,1,1 का प्रतिनिधित्व करता है:

1..1.
3...3

और सॉल्व करने योग्य नहीं है क्योंकि आप एक पथ के निर्माण में सभी वर्गों का उपयोग नहीं कर सकते हैं।

2,2 0,0,0 1,1,0 का प्रतिनिधित्व करता है:

1.
.1

और सॉल्व करने योग्य नहीं है क्योंकि आप यहाँ सभी वर्गों का उपयोग नहीं कर सकते हैं

यहाँ कुछ और परीक्षण हैं:

5,5 0,3,0 0,4,1 1,2,2 1,3,1 2,0,0 3,0,4 3,1,2 3,3,5 3,4,4 4,4,5 1 वापस करना चाहिए

13,13 1,1,0 9,1,1 10,1,2 11,1,3 1,2,4 2,2,5 5,2,6 7,2,7 3,3,0 5,4,6 6,4,1 9,6,3 4,7,8 5,8,9 12,8,8 11,9,10 2,10,4 4,10,2 9,10,5 11,10,7 1,11,9 12,12,10 1 वापस करना चाहिए

7,7 0,0,0 0,1,1 1,1,2 2,1,3 4,2,4 0,3,1 5,3,3 0,4,4 2,4,5 5,4,2 0,5,0 1,5,5 3,5,6 3,7,6 वापस आना चाहिए

---

यह एक कोड गोल्फ है, और मानक नियम लागू होते हैं।

Comments

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

— सीओटीओ

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

— सीओटीओ

@NathanMerrill: इस समस्या का समाधान SAT और इस प्रकार NP कठिन है।

— सीओटीओ

@NathanMerrill किसी समस्या को SAT में कम करने का अर्थ है कि समस्या NP में है, ऐसा नहीं है कि यह NP-hard है - यह SAT को एक समस्या को कम कर रही है जो समस्या की NP-कठोरता को दर्शाता है। आपके द्वारा लिंक किए गए पृष्ठ में NP-पूर्णता के प्रमाण का एक लिंक है, हालांकि।

— कार्डबोर्ड_बॉक्स

@VisualMelon डिजिट का रंग गलत शब्द है। प्रत्येक रंग को एक अलग संख्या द्वारा दर्शाया जाता है, अंक नहीं।

— नाथन मेरिल

Answer 1

हास्केल

import Data.List.Split
import qualified Data.Sequence as Q
import Data.List
import Control.Monad

data A a = S a | E a | P a | X deriving Eq

sc = foldr1 (Q.><)
sp b x y p = Q.update y (Q.update x p $ b `Q.index` y) b
dt b c | S c `elem` sc b = E c
       | otherwise = S c
ad b [x, y, c] = sp b x y (dt b c)

ep b [x, y, c] = do
  let nps = filter ob [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]
      ns = map gp nps
  [b | E c `elem` ns] ++ do
    (x', y') <- filter ((== X) . gp) nps
    ep (sp b x' y' (P c)) [x', y', c]
  where ob (u, v) = 0 <= u && u < length (b `Q.index` 0) && 0 <= v && v < length b
        gp (u, v) = b `Q.index` v `Q.index` u

rd i = let [c, r] : ps = (map read . splitOn ",") <$> words i :: [[Int]]
           e = Q.replicate r $ Q.replicate c X
           cs = map last ps
           ss = nubBy (\[_,_,c1] [_,_,c2] -> c1 == c2) ps
           b = foldl ad e ps
           bs = foldM ep b ss
       in if even (length cs) && length ss == length cs `div` 2 &&
             (all (\[j,k] -> j==k) . chunksOf 2 . sort $ cs) &&
             any (null . Q.elemIndicesL X . sc) bs
           then 1
           else 0

main = rd <$> getContents >>= print

चाभी

• sc: सीक कॉनैट
• सपा: स्थिति निर्धारित करें
• dt: डॉट प्रकार (यानी, लाइन का प्रारंभ या अंत)
• विज्ञापन: डॉट जोड़ें
• ep: पथ का विस्तार करें
• आरडी: रन डॉट्स (प्राथमिक शुद्ध एल्गोरिदम)

Comments

प्रस्तुत करने के लिए धन्यवाद, और PPCG स्टैक एक्सचेंज में आपका स्वागत है। यह एक कोड गोल्फ चुनौती है, जिसका उद्देश्य सबसे छोटा कार्यक्रम लिखना है जो चुनौती को हल करता है। आप नेतृत्व में हैं, क्योंकि आपके पास एकमात्र उत्तर है, लेकिन आपको अपने कार्यक्रम को यथासंभव छोटा करने की कोशिश करनी चाहिए।

— इसहाक

मैं ईमानदारी से प्रभावित हूं कि आपने इस सवाल का जवाब इस समय के बाद दिया। इसके अलावा, यह समस्या एक कोड-चुनौती के रूप में अधिक थी, लेकिन मैंने कोड-गोल्फ का उपयोग किया, क्योंकि एक अलग स्कोरिंग आधार के साथ आना मुश्किल था।

— नाथन मेरिल

हां, मैंने "गोल्फ" पहलू के बारे में बहुत अधिक चिंता नहीं की; मैं हास्केल सीखने की कोशिश कर रहा हूं और यह एक मजेदार समस्या की तरह लग रहा था :-)

— मैट