एक गैर-अनुमानी सुडोकू सॉल्वर लागू करें

Question

सबसे छोटे सुडोकू सॉल्वर को लागू करें।

सुडोकू पहेली:

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A|   3   |     1 |
B|     6 |       |   5
C| 5     |       | 9 8 3
-+-----------------------
D|   8   |     6 | 3   2
E|       |   5   |
F| 9   3 | 8     |   6
-+-----------------------
G| 7 1 4 |       |     9
H|   2   |       | 8
I|       | 4     |   3

उत्तर:

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A| 8 3 2 | 5 9 1 | 6 7 4
B| 4 9 6 | 3 8 7 | 2 5 1
C| 5 7 1 | 2 6 4 | 9 8 3
-+-----------------------
D| 1 8 5 | 7 4 6 | 3 9 2
E| 2 6 7 | 9 5 3 | 4 1 8
F| 9 4 3 | 8 1 2 | 7 6 5
-+-----------------------
G| 7 1 4 | 6 3 8 | 5 2 9
H| 3 2 9 | 1 7 5 | 8 4 6
I| 6 5 8 | 4 2 9 | 1 3 7

नियम:

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

उदाहरण I / O:

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

Comments

आपको वास्तव में एक समय सीमा जोड़ना चाहिए।

— JPvdMerwe

@JPvdMerwe: अच्छी बात है, लेकिन एक समय सीमा को मानकीकृत करना कठिन होगा।

— 1

@gnibbler: यह पहले किया गया हो सकता है (लेकिन कोडगॉल्फ पर नहीं)। मुझे लगता है कि यह अभी भी हल करने के साथ-साथ समुदाय में कुछ मूल्य जोड़ने के लिए मजेदार होगा, खासकर अगर कोई इसके बारे में ईमानदारी से जाता है।

— 1

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

— एंडी

समस्याएँ "केवल तर्क द्वारा हल करने योग्य" बहुत अस्पष्ट है। क्या आप का मतलब है, शायद, केवल a के मूल चरणों का उपयोग करके) एक सेल में मान लिखना जिसके लिए इसकी पंक्ति, कॉलम और ब्लॉक बी में मूल्य नहीं है) एक संख्या की पहचान करना जो केवल अपनी पंक्ति में एक स्थान पर जा सकता है, कॉलम , या ब्लॉक करें, और इसे वहां लिखें?

— xnor

Answer 1

रुबी ( 449 436 वर्ण)

I=*(0..8)
b=$*[0].split('').map{|v|v<'1'?I.map{|d|d+1}:[v.to_i]};f=b.map{|c|!c[1]}
[[z=I.map{|v|v%3+v/3*9},z.map{|v|v*3}],[x=I.map{|v|v*9},I],[I,x]
].map{|s,t|t.map{|i|d=[a=0]*10;s.map{|j|c=b[i+j];c.map{|v|d[v]+=1if !f[i+j]}
v,r=*c;s.map{|k|b[i+k].delete(v)if j!=k}if !r 
s[(a+=1)..8].map{|k|s.map{|l|b[i+l]-=c if l!=k&&l!=j}if c.size==2&&c==b[i+k]}}
v=d.index 1;f[i+k=s.find{|j|b[i+j].index v}]=b[i+k]=[v]if v}}while f.index(!1)
p b*''

उदाहरण:

C:\golf>soduku2.rb 030001000006000050500000983080006302000050000903800060714000009020000800000400030
"832591674496387251571264983185746392267953418943812765714638529329175846658429137"

त्वरित स्पष्टीकरण:
बोर्ड b81 सरणियों का एक सरणी है जो प्रत्येक सेल के लिए सभी संभावित मूल्यों को रखता है। प्रत्येक समूह (बक्से, पंक्तियों, स्तंभों) के लिए लाइन थ्री होल्ड [ऑफसेट, start_index] पर सरणी। समूहों के माध्यम से पुनरावृति करते हुए तीन कार्य किए जाते हैं।

1. आकार 1 के किसी भी सेल का मान समूह के बाकी हिस्सों से हटा दिया जाता है।
2. यदि किसी भी जोड़ी कोशिकाओं में समान 2 मान हैं, तो ये मान समूह के बाकी हिस्सों से हटा दिए जाते हैं।
3. प्रत्येक मान की गिनती में संग्रहीत किया जाता है d- यदि मूल्य का केवल 1 उदाहरण है, तो हम उस मान से युक्त सेल को सेट करते हैं, और में तय सेल को चिह्नित करते हैंf

तब तक दोहराएं जब तक कि सभी कोशिकाएं ठीक न हो जाएं।

Comments

आप कोष्ठक को छोड़ सकते हैं I=*(0..8), 2 वर्णों को बचाएगा।

— डॉगबर्ट

मुझे लगता है sudokusolver.rb:8: unterminated string meets end of fileअगर मैं इसके साथ शुरू करता हूं ruby1.8 sudokusolver.rb 030...। मैं क्या गलत कर रहा हूं?

— उपयोगकर्ता अज्ञात

लगता है कि अंतिम पंक्ति पर एक अतिरिक्त 'है। यकीन नहीं होता कि वहां कैसे

— पहुंचा

Answer 2

प्रस्तावना - 493 वर्ण

:-use_module(library(clpfd)).
a(X):-all_distinct(X).
b([],[],[]).
b([A,B,C|X],[D,E,F|Y],[G,H,I|Z]):-a([A,B,C,D,E,F,G,H,I]),b(X,Y,Z).
c([A,B,C,D,E,F,G,H,I|X])-->[[A,B,C,D,E,F,G,H,I]],c(X).
c([])-->[].
l(X,Y):-length(X,Y).
m(X,Y):-maplist(X,Y).
n(L,M):-l(M,L).
o(48,_).
o(I,O):-O is I-48.
:-l(L,81),see(user),m(get,L),seen,maplist(o,L,M),phrase(c(M),R),l(R,9),m(n(9),R),append(R,V),V ins 1..9,m(a,R),transpose(R,X),m(a,X),R=[A,B,C,D,E,F,G,H,I],b(A,B,C),b(D,E,F),b(G,H,I),flatten(R,O),m(write,O).

आउटपुट:

इनपुटिंग: 000000000000003085001020000000507000004000100090000000500000073002010000000040009 आउटपुट: 987654321246173985351928746128537694634892157795461832519286473472319568863745219

इनपुटिंग: 030001000006000050500000983080006302000050000903800060714000009020000800000400030 आउटपुट: 832591674496387251571264983185746392267953418943812765714638529329175846658429137