० एन ० एक बहुत ही सरल और आनंददायक खेल है, थोड़ा सुडोकू या खानों की तरह।

खेल के नियमों

(मैं ट्यूटोरियल का उपयोग करने की सलाह देता हूं खेल में यदि आप कर सकते हैं, तो यह बहुत सरल और उपयोगी है)

पहेली एक n * nबोर्ड के साथ शुरू होती है जिसमें कुछ निश्चित टुकड़े और कुछ खाली कोशिकाएं होती हैं, और सॉल्वर को टुकड़ों के साथ खाली कोशिकाओं को भरने और निश्चित टुकड़ों द्वारा लगाए गए सभी बाधाओं को पूरा करने का एक तरीका खोजना चाहिए। इस प्रकार के टुकड़े हम संक्षिप्त नाम के साथ प्रयोग करेंगे:

# लाल टुकड़ा (नीले टुकड़े का ब्लॉक दृश्य)
O नीला टुकड़ा
. खाली स्थान
numberनीले रंग का टुकड़ा ( numberएक अंक की संख्या> 0 है)

सभी गिने टुकड़ों को नीले रंग के टुकड़ों की संख्या के बराबर दिखाई देना चाहिए। उदाहरण के लिए:

#1O#O
...O.

1टुकड़ा केवल एक अन्य नीले टुकड़ा देख सकते हैं।

टुकड़े एक दूसरे को कैसे देखते हैं

दो नीले टुकड़े एक दूसरे को देख सकते हैं यदि वे एक ही पंक्ति या स्तंभ में हैं और कोई लाल टुकड़ा उनके बीच नहीं है। उदाहरण:

( Sएक ऐसा स्थान है जिसे Oटुकड़ा देख Xसकता है, देखा नहीं जा सकता)

   S
   S
X#SOSS
   #
   X

प्रत्येक नीले टुकड़े को कम से कम एक नीला टुकड़ा देखना चाहिए:

#O#

काम नहीं, लेकिन:

#OO

या:

###

काम करो।

डेमो बोर्ड हल

.1..
..1.
....
22#2

दाईं ओर नीचे 2 केवल ऊपर ही देख सकते हैं, इसलिए उन्हें नीला होना चाहिए, और ऊपर दाईं ओर लाल होना चाहिए।

.1.#
..1O
...O
22#2

चूंकि 1भरा हुआ है, हम इसे लाल टुकड़ों के साथ घेर सकते हैं।

.1##
.#1O
..#O
22#2

शीर्ष बाईं ओर 1केवल एक दिशा में देखा जा सकता है, इसलिए हम इसे भर सकते हैं।

O1##
.#1O
..#O
22#2

अब उन आखिरी 2एस के बारे में । हम उनके ऊपर 2 नीले टुकड़े रख सकते हैं।

O1##
.#1O
OO#O
22#2

सबसे आखिरी में भरा जाएगा #

O1##
##1O
OO#O
22#2

इनपुट

इनपुट एक बहु-पंक्ति स्ट्रिंग है। आकार 9x9अनुगामी अंतरिक्ष के बिना होगा । इसके निम्नलिखित प्रकार हैं:

. खाली
# पूर्व निर्धारित लाल, बदला नहीं जा सकता
number प्रीसेट नंबर, बदला नहीं जा सकता

(ध्यान दें कि नीला कभी इनपुट में नहीं होगा)

उत्पादन

आउटपुट इनपुट के समान है, जिसमें परिवर्तन के साथ खाली ( .) को बोर्ड को हल करने के लिए लाल या नीले रंग के साथ बदल दिया जाता है, और संख्याओं को नीले टुकड़ों से बदल दिया जाता है (O ) के ।

उदाहरण

(ध्यान दें कि प्रत्येक पहेली के लिए कई समाधान संभव हो सकते हैं, लेकिन आपको केवल उनमें से एक को दिखाना होगा)

Input:
........4
...3.1...
45...2.3.
..9......
1..6#44..
....4..5.
....4.36.
2.......6
1....4...

Output:
OOO###OOO
OOOO#O#OO
OOO#OO#OO
#OOOO#O##
O#OO#OOOO
O#OOOO#OO
#OOOO#OOO
OO#O#OOOO
O#OOOO#O#

Input:
..7..#...
#...8..11
2....5...
..5...48.
...#...4.
.5...6...
...1.2...
2.....6.8
.7..#....

Output:
OOOOO####
##OOOO#OO
O#OOOO###
OOO#OOOOO
OO##O##O#
#O##OOOOO
#O#O#O#OO
OO#OOOOOO
OOO###O#O

Input:
5.3..33..
...4...23
.6.6.34..
...3#....
....5..4.
.5....3..
7.98.6#.3
.5.6..2..
..6...2..

Output:
OOOOO####
##OOOO#OO
O#OOOO###
OOO#OOOOO
OO##O##O#
#O##OOOOO
#O#O#O#OO
OO#OOOOOO
OOO###O#O

_{के लिए धन्यवाद @PeterTaylor और @apsillers सैंडबॉक्स में अपने सभी की मदद के लिए!}

code-golf puzzle-solver

— जे एटकिन
स्रोत

मैंने शीर्षक को केवल एक बहुत ही छोटा संपादित किया क्योंकि "एक" बेहतर लगता है यदि निम्न शब्द एक स्वर से शुरू होता है - मैं गैर-देशी अंग्रेजी बोलने वालों या यहां तक कि देशी वक्ताओं से परेशान होने की उम्मीद नहीं करता, लेकिन यह व्याकरणिक है।

— बिल्ली

हास्केल, 224 बाइट्स

पूरी तरह से परीक्षण नहीं किया गया है, क्योंकि यह इतना धीमा है (कम से कम O(n*2^n^2))।

t=1<2
x!p|p<0=0|t=mod(div x$2^p)2
l#x=[[sum$map(p&)[-1,1,l+1,-l-1]|p<-[q..q+l]]|q<-[0,l..l*l],let i&v|x!i<1=0|t=x!(i+v)+(i+v)&v]
b%v|b<1=t|t=b==v
s b|l<-length b-1=[l#x|x<-[0..2^l^2],and.map and$zipWith(zipWith(%))b(l#x)]!!0

स्पष्टीकरण:

मूल विचार Red, Blueटुकड़ों की एक बोर्ड की सूची की सूची के रूप में प्रतिनिधित्व करना है 0, 1, जहां सूचियों की सूची को आसान गणना के लिए एक पूर्णांक में पैक किया जाता है। बोर्ड आकार के लिए इस तरह के सभी पूर्णांक उत्पन्न होते हैं और पड़ोसी के रूप में बदल जाते हैं। पहला ऐसा बोर्ड जो इनपुट का एक वैध समाधान है, वापस आ गया है।

-- integer x at position p with out of bounds defined to be 0 (so no bounds checking)
(!) :: (Integral b, Integral r) => r -> b -> r
x ! p | p < 0     = 0 
      | otherwise = mod (div x (2^p)) 2


-- Sum of values from position p along vector v (x is implicit)
-- Note that a cartesian vector (x,y) in this representation is (l*x + y)
(&) :: (Integral a, Integral b) => b -> b -> a
p & v | x ! p == 0 = 0
      | otherwise  = x ! (p+v)  +  (p+v) & v


-- Value of board at position p (implicit x, l)
value :: Integral a => a -> a
value p = sum $ map (p&) [-1, 1, l+1, -l-1]


-- Integer to board, where l is length, x is input integer
(#) :: (Integral t, Integral a) => a -> t -> [[t]]
l # x = [[sum $ map (p&) [-1,1,l+1,-l-1] | p <- [q..q+l-1]] | q <- [0,l..l*l]]


-- Comparison operator, to see whether a solved board is a solution of the input
(%) :: (Num a, Ord a) => a -> a -> Bool
b % v | b == 0    = True
      | otherwise = b == v


-- Check one possible solution
check :: Integral a => [[a]] -> Int -> [[a]] -> Bool
check b l x = (and . (map and)) zipWith(zipWith (%)) b (l # x)

-- Solver
solve :: Integral t => [[t]] -> [[t]]
solve b = [l # x | x <- [0..2^l^2], check b l x]
  where
    l = length b

हिस्सा शायद सबसे golfed जा सकता है कि यह है: and.map and$zipWith(zipWith(%))। अन्यथा, मैंने कुछ ऑफ-बाय-वन त्रुटियां पकड़ीं जो लंबाई बढ़ाती हैं और शायद अधिक गोल्फ हो सकती हैं।

— माइकल क्लेन
स्रोत

0h n0 बोर्ड को हल करें